zou 0.20.61__py3-none-any.whl → 0.20.63__py3-none-any.whl

zou/app/services/departments_service.py

@@ -0,0 +1,153 @@
+from zou.app.models.department import (
+    Department,
+    SoftwareDepartmentLink,
+    HardwareItemDepartmentLink,
+)
+from zou.app.models.hardware_item import HardwareItem
+from zou.app.models.software import Software
+from zou.app.utils import fields
+
+from zou.app.services.exception import (
+    DepartmentNotFoundException,
+    SoftwareNotFoundException,
+    HardwareItemNotFoundException,
+)
+
+
+def _check_department_exists(department_id):
+    department = Department.get(department_id)
+    if not department:
+        raise DepartmentNotFoundException
+    return department
+
+
+def _check_software_exists(software_id):
+    software = Software.get(software_id)
+    if not software:
+        raise SoftwareNotFoundException
+    return software
+
+
+def _check_hardware_item_exists(hardware_item_id):
+    hardware_item = HardwareItem.get(hardware_item_id)
+    if not hardware_item:
+        raise HardwareItemNotFoundException
+    return hardware_item
+
+
+def get_all_software_for_departments():
+    """
+    Get all software items for all departments organized by department
+    in a dictionary where the key is the department id and the value is a
+    list of linked software items.
+    """
+    software_list = (
+        Software.query.join(SoftwareDepartmentLink)
+        .add_columns(SoftwareDepartmentLink.department_id)
+        .all()
+    )
+    department_map = {}
+    for software, department_id in software_list:
+        if department_id not in department_map:
+            department_map[department_id] = []
+        department_map[department_id].append(software.serialize())
+    return department_map
+
+
+def get_all_hardware_items_for_departments():
+    """
+    Get all hardware items for all departments organized by department
+    in a dictionary where the key is the department id and the value is a
+    list of linked hardware items.
+    """
+    hardware_item_list = (
+        HardwareItem.query.join(HardwareItemDepartmentLink)
+        .add_columns(HardwareItemDepartmentLink.department_id)
+        .all()
+    )
+    department_map = {}
+    for hardware_item, department_id in hardware_item_list:
+        if department_id not in department_map:
+            department_map[department_id] = []
+        department_map[department_id].append(hardware_item.serialize())
+    return department_map
+
+
+def get_software_for_department(department_id):
+    """
+    Get all software items for a given department.
+    """
+    _check_department_exists(department_id)
+    return fields.serialize_models(
+        Software.query.join(SoftwareDepartmentLink)
+        .filter(SoftwareDepartmentLink.department_id == department_id)
+        .all()
+    )
+
+
+def get_hardware_items_for_department(department_id):
+    """
+    Get all hardware items for a given department.
+    """
+    _check_department_exists(department_id)
+    return fields.serialize_models(
+        HardwareItem.query.join(HardwareItemDepartmentLink)
+        .filter(HardwareItemDepartmentLink.department_id == department_id)
+        .all()
+    )
+
+
+def add_software_to_department(department_id, software_id):
+    """
+    Add a software item to a department.
+    """
+    _check_department_exists(department_id)
+    _check_software_exists(software_id)
+    link = SoftwareDepartmentLink.get_or_create(
+        department_id=department_id, software_id=software_id
+    )
+    return link.serialize()
+
+
+def remove_software_from_department(department_id, software_id):
+    """
+    Remove a software item from a department.
+    """
+    _check_department_exists(department_id)
+    _check_software_exists(software_id)
+    link = SoftwareDepartmentLink.get_by(
+        department_id=department_id, software_id=software_id
+    )
+    if not link:
+        return None
+    else:
+        link.delete()
+        return link.serialize()
+
+
+def add_hardware_item_to_department(department_id, hardware_item_id):
+    """
+    Add a hardware item to a department.
+    """
+    _check_department_exists(department_id)
+    _check_hardware_item_exists(hardware_item_id)
+    link = HardwareItemDepartmentLink.get_or_create(
+        department_id=department_id, hardware_item_id=hardware_item_id
+    )
+    return link.serialize()
+
+
+def remove_hardware_item_from_department(department_id, hardware_item_id):
+    """
+    Remove a hardware item from a department.
+    """
+    _check_department_exists(department_id)
+    _check_hardware_item_exists(hardware_item_id)
+    link = HardwareItemDepartmentLink.get_by(
+        department_id=department_id, hardware_item_id=hardware_item_id
+    )
+    if not link:
+        return None
+    else:
+        link.delete()
+        return link.serialize()

zou/app/services/edits_service.py

@@ -16,8 +16,7 @@ from zou.app.models.entity import (
 )
 from zou.app.models.project import Project
 from zou.app.models.subscription import Subscription
-from zou.app.models.task import Task
-from zou.app.models.task import assignees_table
+from zou.app.models.task import Task, TaskPersonLink
 
 from zou.app.services import (
     deletion_service,
@@ -90,7 +89,7 @@ def get_edits_and_tasks(criterions={}):
         Entity.query.join(Project, Entity.project_id == Project.id)
         .outerjoin(Episode, Episode.id == Entity.parent_id)
         .outerjoin(Task, Task.entity_id == Entity.id)
-        .outerjoin(assignees_table)
+        .outerjoin(TaskPersonLink)
         .add_columns(
             Episode.id,
             Episode.name,
@@ -108,7 +107,7 @@ def get_edits_and_tasks(criterions={}):
             Task.last_comment_date,
             Task.last_preview_file_id,
             Task.nb_assets_ready,
-            assignees_table.columns.person,
+            TaskPersonLink.person_id,
             Project.id,
             Project.name,
         )

zou/app/services/entities_service.py

@@ -18,8 +18,7 @@ from zou.app.models.entity import Entity, EntityLink, EntityConceptLink
 from zou.app.models.entity_type import EntityType
 from zou.app.models.preview_file import PreviewFile
 from zou.app.models.project import Project
-from zou.app.models.task import assignees_table
-from zou.app.models.task import Task
+from zou.app.models.task import Task, TaskPersonLink
 
 from zou.app import db
 
@@ -255,7 +254,7 @@ def get_entities_and_tasks(criterions={}):
 
     query = (
         Entity.query.outerjoin(Task, Task.entity_id == Entity.id)
-        .outerjoin(assignees_table)
+        .outerjoin(TaskPersonLink)
         .add_columns(
             Task.id,
             Task.task_type_id,
@@ -272,7 +271,7 @@ def get_entities_and_tasks(criterions={}):
             Task.last_comment_date,
             Task.last_preview_file_id,
             Task.difficulty,
-            assignees_table.columns.person,
+            TaskPersonLink.person_id,
         )
     )
 
@@ -416,7 +415,7 @@ def get_linked_entities_with_tasks(entity_id):
     query = (
         Entity.query.join(Project, Project.id == Entity.project_id)
         .outerjoin(Task, Task.entity_id == Entity.id)
-        .outerjoin(assignees_table)
+        .outerjoin(TaskPersonLink)
         .join(EntityType)
         .add_columns(
             Task.id,
@@ -433,7 +432,7 @@ def get_linked_entities_with_tasks(entity_id):
             Task.last_comment_date,
             Task.nb_assets_ready,
             Task.assigner_id,
-            assignees_table.columns.person,
+            TaskPersonLink.person_id,
             Project.id,
             Project.name,
             EntityType.name,

zou/app/services/exception.py

@@ -89,6 +89,10 @@ class SoftwareNotFoundException(NotFound):
     pass
 
 
+class HardwareItemNotFoundException(NotFound):
+    pass
+
+
 class OutputTypeNotFoundException(NotFound):
     pass
 
@@ -287,3 +291,7 @@ class WrongTaskTypeForEntityException(Exception):
 
 class IsUserLimitReachedException(Exception):
     pass
+
+
+class ProductionScheduleVersionNotFoundException(NotFound):
+    pass

zou/app/services/file_tree_service.py

@@ -789,7 +789,7 @@ def extract_variable_values_from_path(elements, template_elements):
                 continue
             else:
                 raise WrongPathFormatException(
-                    "{} doesn't match {}".format(elements, template_elements)
+                    f"{elements} doesn't match {template_elements}"
                 )
 
         data_type = token.group("token")
@@ -1131,7 +1131,7 @@ def guess_from_path(project_id, file_path, sep="/"):
                 # Some template_element don't have a corresponding token,
                 # like "05_publish" folder, for example.
                 for token, token_value in tokens.items():
-                    if "<{}>".format(token) in template_element:
+                    if f"<{token}>" in template_element:
                         break
                 else:
                     continue

zou/app/services/preview_files_service.py

@@ -522,8 +522,12 @@ def _apply_annotation_deletions(annotations, deletions):
         if deletion["time"] in annotation_map:
             annotation = annotation_map[deletion["time"]]
             deleted_object_ids = deletion.get("objects", [])
-            previous_objects = annotation.get("drawing", {}).get("objects", [])
-            annotation.get("drawing", {})["objects"] = [
+            if "drawing" not in annotation or not isinstance(
+                annotation["drawing"], dict
+            ):
+                annotation["drawing"] = {}
+            previous_objects = annotation["drawing"].get("objects", [])
+            annotation["drawing"]["objects"] = [
                 previous_object
                 for previous_object in previous_objects
                 if previous_object.get("id", "") not in deleted_object_ids

zou/app/services/schedule_service.py

@@ -1,18 +1,43 @@
 from datetime import date, timedelta
+from sqlalchemy.exc import StatementError
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy import update
+
 
 from zou.app.models.entity import Entity
 from zou.app.models.entity_type import EntityType
 from zou.app.models.milestone import Milestone
 from zou.app.models.schedule_item import ScheduleItem
-from zou.app.utils import events, fields
+from zou.app.models.task import Task
+from zou.app.models.task_type import TaskType
+from zou.app.models.production_schedule_version import (
+    ProductionScheduleVersion,
+    ProductionScheduleVersionTaskLink,
+)
+from zou.app.utils import events, fields, cache
 from zou.app.services import (
     assets_service,
     base_service,
     shots_service,
     tasks_service,
+    projects_service,
+)
+from zou.app import db
+
+from zou.app.services.exception import (
+    ProductionScheduleVersionNotFoundException,
 )
 
 
+def clear_production_schedule_version_cache(production_schedule_version_id):
+    cache.cache.delete_memoized(
+        get_production_schedule_version, production_schedule_version_id
+    )
+    cache.cache.delete_memoized(
+        get_production_schedule_version, production_schedule_version_id, True
+    )
+
+
 def get_schedule_items(project_id):
     """
     Get all project schedule items (mainly for sync purpose).
@@ -204,3 +229,220 @@ def get_milestones_for_project(project_id):
     """
     query = Milestone.query.filter_by(project_id=project_id)
     return [milestone.present() for milestone in query.all()]
+
+
+def get_production_schedule_version_raw(production_schedule_version_id):
+    """
+    Get production schedule version matching given id.
+    """
+    try:
+        production_schedule_version = ProductionScheduleVersion.get(
+            production_schedule_version_id
+        )
+    except StatementError:
+        raise ProductionScheduleVersionNotFoundException
+
+    if production_schedule_version is None:
+        raise ProductionScheduleVersionNotFoundException
+
+    return production_schedule_version
+
+
+@cache.memoize_function(120)
+def get_production_schedule_version(
+    production_schedule_version_id, relations=False
+):
+    """
+    Get production schedule version matching given id and serialize it.
+    """
+    return get_production_schedule_version_raw(
+        production_schedule_version_id
+    ).serialize(relations=relations)
+
+
+def get_production_schedule_version_task_links(
+    production_schedule_version_id, task_type_id=None, relations=False
+):
+    """
+    Get all task links for given production schedule version.
+    """
+    query = ProductionScheduleVersionTaskLink.query.filter_by(
+        production_schedule_version_id=production_schedule_version_id
+    )
+
+    if task_type_id is not None:
+        query = (
+            query.join(Task)
+            .join(TaskType)
+            .filter(Task.task_type_id == task_type_id)
+        )
+
+    return fields.serialize_models(query.all(), relations=relations)
+
+
+def update_production_schedule_version(production_schedule_version_id, data):
+    """
+    Update production schedule version with given id with data.
+    """
+    production_schedule_version = get_production_schedule_version_raw(
+        production_schedule_version_id
+    )
+
+    production_schedule_version.update(data)
+    clear_production_schedule_version_cache(production_schedule_version_id)
+    events.emit(
+        "production_schedule_version:update",
+        {"production_schedule_version_id": production_schedule_version_id},
+        project_id=str(production_schedule_version.project_id),
+    )
+    return production_schedule_version.serialize()
+
+
+def set_production_schedule_version_task_links_from_production(
+    production_schedule_version_id,
+):
+    """
+    Set task links for given production schedule version from tasks in the
+    production.
+    """
+    production_schedule_version = get_production_schedule_version(
+        production_schedule_version_id
+    )
+
+    tasks = (
+        db.session.query(Task)
+        .filter(Task.project_id == production_schedule_version["project_id"])
+        .all()
+    )
+
+    rows = [
+        {
+            "id": fields.gen_uuid(),
+            "production_schedule_version_id": production_schedule_version_id,
+            "task_id": task.id,
+            "start_date": task.start_date,
+            "due_date": task.due_date,
+            "estimation": task.estimation,
+        }
+        for task in tasks
+    ]
+    insert_stmt = insert(ProductionScheduleVersionTaskLink).values(rows)
+    insert_stmt = insert_stmt.on_conflict_do_update(
+        index_elements=["production_schedule_version_id", "task_id"],
+        set_={
+            "start_date": insert_stmt.excluded.start_date,
+            "due_date": insert_stmt.excluded.due_date,
+            "estimation": insert_stmt.excluded.estimation,
+        },
+    ).returning(ProductionScheduleVersionTaskLink)
+
+    results = db.session.execute(insert_stmt).scalars().all()
+
+    tasks_map = {task.id: task for task in tasks}
+
+    for task_link in results:
+        task_link.assignees = tasks_map[task_link.task_id].assignees
+
+    db.session.commit()
+
+    return fields.serialize_models(results, relations=True)
+
+
+def set_production_schedule_version_task_links_from_production_schedule_version(
+    production_schedule_version_id, other_production_schedule_version_id
+):
+    """
+    Set task links for given production schedule version from another.
+    """
+
+    other_links = (
+        db.session.query(ProductionScheduleVersionTaskLink)
+        .filter(
+            ProductionScheduleVersionTaskLink.production_schedule_version_id
+            == other_production_schedule_version_id
+        )
+        .all()
+    )
+
+    rows = [
+        {
+            "id": fields.gen_uuid(),
+            "production_schedule_version_id": production_schedule_version_id,
+            "task_id": links.task_id,
+            "start_date": links.start_date,
+            "due_date": links.due_date,
+            "estimation": links.estimation,
+        }
+        for links in other_links
+    ]
+
+    insert_stmt = insert(ProductionScheduleVersionTaskLink).values(rows)
+    insert_stmt = insert_stmt.on_conflict_do_update(
+        index_elements=["production_schedule_version_id", "task_id"],
+        set_={
+            "start_date": insert_stmt.excluded.start_date,
+            "due_date": insert_stmt.excluded.due_date,
+            "estimation": insert_stmt.excluded.estimation,
+        },
+    ).returning(ProductionScheduleVersionTaskLink)
+
+    results = db.session.execute(insert_stmt).scalars().all()
+
+    tasks_map = {link.task_id: link for link in other_links}
+
+    for task_link in results:
+        task_link.assignees = tasks_map[task_link.task_id].assignees
+
+    db.session.commit()
+
+    update_production_schedule_version(
+        production_schedule_version_id,
+        {"production_schedule_from": other_production_schedule_version_id},
+    )
+
+    return fields.serialize_models(results, relations=True)
+
+
+def apply_production_schedule_version_to_production(
+    production_schedule_version_id,
+):
+    """
+    Apply production schedule version to production.
+    """
+
+    stmt = (
+        update(Task)
+        .values(
+            start_date=ProductionScheduleVersionTaskLink.start_date,
+            due_date=ProductionScheduleVersionTaskLink.due_date,
+            estimation=ProductionScheduleVersionTaskLink.estimation,
+        )
+        .where(Task.id == ProductionScheduleVersionTaskLink.task_id)
+        .where(
+            ProductionScheduleVersionTaskLink.production_schedule_version_id
+            == production_schedule_version_id
+        )
+        .returning(Task)
+    )
+
+    results = db.session.execute(stmt).scalars().all()
+
+    db.session.commit()
+
+    for task in results:
+        events.emit(
+            "task:update",
+            {"task_id": str(task.id)},
+            project_id=str(task.project_id),
+        )
+
+    production_schedule_version = update_production_schedule_version(
+        production_schedule_version_id, {"locked": True}
+    )
+
+    projects_service.update_project(
+        production_schedule_version["project_id"],
+        {"from_schedule_version_id": production_schedule_version_id},
+    )
+
+    return fields.serialize_models(results, relations=True)

zou/app/services/shots_service.py

@@ -23,8 +23,7 @@ from zou.app.models.project import Project
 from zou.app.models.preview_file import PreviewFile
 from zou.app.models.schedule_item import ScheduleItem
 from zou.app.models.subscription import Subscription
-from zou.app.models.task import Task
-from zou.app.models.task import assignees_table
+from zou.app.models.task import Task, TaskPersonLink
 from zou.app.models.time_spent import TimeSpent
 
 from zou.app.services import (
@@ -234,7 +233,7 @@ def get_shots_and_tasks(criterions={}):
         .join(Sequence, Sequence.id == Entity.parent_id)
         .outerjoin(Episode, Episode.id == Sequence.parent_id)
         .outerjoin(Task, Task.entity_id == Entity.id)
-        .outerjoin(assignees_table)
+        .outerjoin(TaskPersonLink)
         .add_columns(
             Episode.name,
             Episode.id,
@@ -257,7 +256,7 @@ def get_shots_and_tasks(criterions={}):
             Task.nb_assets_ready,
             Task.difficulty,
             Task.nb_drawings,
-            assignees_table.columns.person,
+            TaskPersonLink.person_id,
             Project.id,
             Project.name,
         )

zou/app/services/tasks_service.py

@@ -1846,7 +1846,7 @@ def reset_task_data(task_id):
     return task.serialize(relations=True)
 
 
-def get_persons_tasks_dates():
+def get_persons_tasks_dates(project_id=None):
     """
     For schedule usages, for each active person, it returns the first start
     date of all tasks of assigned to this person and the last end date.
@@ -1861,6 +1861,10 @@ def get_persons_tasks_dates():
         .group_by(Person.id)
         .join(Task.assignees)
     )
+
+    if project_id is not None:
+        query = query.filter(Task.project_id == project_id)
+
     return [
         {
             "person_id": str(person_id),