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

zou/app/services/user_service.py

@@ -1,5 +1,5 @@
 from sqlalchemy.orm import aliased
-from sqlalchemy import func
+from sqlalchemy import func, or_
 
 from zou.app import config
 from zou.app.models.comment import Comment
@@ -9,6 +9,7 @@ from zou.app.models.notification import Notification
 from zou.app.models.person import Person
 from zou.app.models.project import Project
 from zou.app.models.project_status import ProjectStatus
+from zou.app.models.subscription import Subscription
 from zou.app.models.search_filter import SearchFilter
 from zou.app.models.search_filter_group import SearchFilterGroup
 from zou.app.models.task import Task
@@ -32,16 +33,23 @@ from zou.app.services.exception import (
     SearchFilterNotFoundException,
     SearchFilterGroupNotFoundException,
     NotificationNotFoundException,
+    WrongParameterException,
 )
 from zou.app.utils import cache, fields, permissions
 
 
-def clear_filter_cache(user_id):
-    cache.cache.delete_memoized(get_user_filters, user_id)
+def clear_filter_cache(user_id=None):
+    if user_id is None:
+        cache.cache.delete_memoized(get_user_filters)
+    else:
+        cache.cache.delete_memoized(get_user_filters, user_id)
 
 
-def clear_filter_group_cache(user_id):
-    cache.cache.delete_memoized(get_user_filter_groups, user_id)
+def clear_filter_group_cache(user_id=None):
+    if user_id is None:
+        cache.cache.delete_memoized(get_user_filter_groups)
+    else:
+        cache.cache.delete_memoized(get_user_filter_groups, user_id)
 
 
 def clear_project_cache():
@@ -402,20 +410,27 @@ def check_belong_to_project(project_id):
     if project_id is None:
         return False
 
-    project = projects_service.get_project_with_relations(str(project_id))
+    project = projects_service.get_project(str(project_id), relations=True)
     current_user = persons_service.get_current_user()
     return current_user["id"] in project["team"]
 
 
-def check_project_access(project_id):
+def has_project_access(project_id):
     """
     Return true if current user is a manager or has a task assigned for this
     project.
     """
-    is_allowed = (
-        permissions.has_admin_permissions()
-        or check_belong_to_project(project_id)
+    return permissions.has_admin_permissions() or check_belong_to_project(
+        project_id
     )
+
+
+def check_project_access(project_id):
+    """
+    Return true if current user is a manager or has a task assigned for this
+    project. Raise a PermissionDenied exception if not.
+    """
+    is_allowed = has_project_access(project_id)
     if not is_allowed:
         raise permissions.PermissionDenied
     return is_allowed
@@ -463,6 +478,16 @@ def check_task_status_access(task_status_id):
     return True
 
 
+def check_task_access(task_id):
+    """
+    Return true if current user can have access to a task.
+    """
+    task = tasks_service.get_task(task_id)
+    check_project_access(task["project_id"])
+    check_entity_access(task["entity_id"])
+    return True
+
+
 def check_comment_access(comment_id):
     """
     Return true if current user can have access to a comment.
@@ -501,15 +526,23 @@ def check_comment_access(comment_id):
         return True
 
 
-def check_manager_project_access(project_id):
+def has_manager_project_access(project_id):
     """
     Return true if current user is a manager and has a task assigned for this
     project.
     """
-    is_allowed = permissions.has_admin_permissions() or (
+    return permissions.has_admin_permissions() or (
         permissions.has_manager_permissions()
         and check_belong_to_project(project_id)
     )
+
+
+def check_manager_project_access(project_id):
+    """
+    Return true if current user is a manager and has a task assigned for this
+    project. Raise a PermissionDenied exception if not.
+    """
+    is_allowed = has_manager_project_access(project_id)
     if not is_allowed:
         raise permissions.PermissionDenied
     return is_allowed
@@ -572,7 +605,7 @@ def check_supervisor_task_access(task, new_data={}):
         # checks that the supervisor only modifies columns
         # for which he is authorized
         allowed_columns = set(
-            ["priority", "start_date", "due_date", "estimation"]
+            ["priority", "start_date", "due_date", "estimation", "difficulty"]
         )
         if len(set(new_data.keys()) - allowed_columns) == 0:
             user_departments = persons_service.get_current_user(
@@ -692,7 +725,7 @@ def check_metadata_department_access(entity, new_data={}):
     return is_allowed
 
 
-def check_task_departement_access(task_id, person_id):
+def check_task_department_access(task_id, person_id):
     """
     Return true if current user is an admin or is a manager and is in team
     or is a supervisor in the department of the task or is an artist assigning
@@ -744,7 +777,7 @@ def check_person_is_not_bot(person_id):
         return True
 
 
-def check_task_departement_access_for_unassign(task_id, person_id=None):
+def check_task_department_access_for_unassign(task_id, person_id=None):
     """
     Return true if current user is an admin or is a manager and is in team
     or is a supervisor in the department of the task or is an artist assigning
@@ -852,43 +885,86 @@ def get_user_filters(current_user_id):
     result = {}
 
     filters = (
-        SearchFilter.query.join(Project)
-        .join(ProjectStatus)
-        .filter(SearchFilter.person_id == current_user_id)
-        .filter(build_open_project_filter())
+        SearchFilter.query.outerjoin(Project)
+        .outerjoin(ProjectStatus)
+        .filter(
+            or_(
+                SearchFilter.person_id == current_user_id,
+                SearchFilter.is_shared == True,
+            )
+        )
+        .filter(
+            or_(build_open_project_filter(), SearchFilter.project_id == None)
+        )
         .all()
     )
 
-    filters = (
-        filters
-        + SearchFilter.query.filter(SearchFilter.person_id == current_user_id)
-        .filter(SearchFilter.project_id == None)
-        .all()
-    )
+    current_user = persons_service.get_current_user(relations=True)
+    is_manager = permissions.has_manager_permissions()
 
     for search_filter in filters:
-        if search_filter.list_type not in result:
-            result[search_filter.list_type] = {}
-        subresult = result[search_filter.list_type]
+        department_id = search_filter.department_id
+        is_in_departments = (
+            department_id is not None
+            and str(department_id) in current_user["departments"]
+        )
 
-        if search_filter.project_id is None:
-            project_id = "all"
-        else:
-            project_id = str(search_filter.project_id)
+        if department_id is None or is_manager or is_in_departments:
+            if search_filter.list_type not in result:
+                result[search_filter.list_type] = {}
+            subresult = result[search_filter.list_type]
 
-        if project_id not in subresult:
-            subresult[project_id] = []
+            if search_filter.project_id is None:
+                project_id = "all"
+            else:
+                project_id = str(search_filter.project_id)
+
+            if project_id not in subresult:
+                subresult[project_id] = []
 
-        subresult[project_id].append(search_filter.serialize())
+            subresult[project_id].append(search_filter.serialize())
 
     return result
 
 
-def create_filter(list_type, name, query, project_id=None, entity_type=None):
+def create_filter(
+    list_type,
+    name,
+    query,
+    project_id=None,
+    entity_type=None,
+    is_shared=False,
+    search_filter_group_id=None,
+    department_id=None,
+):
     """
     Add a new search filter to the database.
     """
     current_user = persons_service.get_current_user()
+
+    if project_id is None or (
+        project_id is not None and not has_manager_project_access(project_id)
+    ):
+        is_shared = False
+
+    if search_filter_group_id is not None:
+        search_filter_group = SearchFilterGroup.get_by(
+            id=search_filter_group_id
+        )
+        if search_filter_group is None:
+            raise SearchFilterGroupNotFoundException
+        if is_shared != search_filter_group.is_shared:
+            raise WrongParameterException(
+                "A search filter should have the same value for is_shared than its search filter group."
+            )
+
+    if department_id is not None:
+        department = tasks_service.get_department(department_id)
+        if department is None:
+            raise WrongParameterException(
+                f"No department found with id: {department_id}"
+            )
+
     search_filter = SearchFilter.create(
         list_type=list_type,
         name=name,
@@ -896,9 +972,15 @@ def create_filter(list_type, name, query, project_id=None, entity_type=None):
         project_id=project_id,
         person_id=current_user["id"],
         entity_type=entity_type,
+        is_shared=is_shared,
+        search_filter_group_id=search_filter_group_id,
+        department_id=department_id,
     )
     search_filter.serialize()
-    clear_filter_cache(current_user["id"])
+    if search_filter.is_shared:
+        clear_filter_cache()
+    else:
+        clear_filter_cache(current_user["id"])
     return search_filter.serialize()
 
 
@@ -910,10 +992,64 @@ def update_filter(search_filter_id, data):
     search_filter = SearchFilter.get_by(
         id=search_filter_id, person_id=current_user["id"]
     )
+    if current_user["role"] == "admin" and search_filter is None:
+        search_filter = SearchFilter.get_by(id=search_filter_id)
+
     if search_filter is None:
         raise SearchFilterNotFoundException
+
+    department_id = data.get("department_id", None)
+    if department_id is not None:
+        department = tasks_service.get_department(department_id)
+        if department is None:
+            raise WrongParameterException(
+                f"No department found with id: {department_id}"
+            )
+
+    if (
+        data.get("is_shared", None) is not None
+        and search_filter.is_shared != data["is_shared"]
+        and (
+            data.get("project_id", None) is None
+            or (
+                data["project_id"] is not None
+                and not has_manager_project_access(data["project_id"])
+            )
+        )
+    ):
+        data["is_shared"] = False
+
+    if (
+        search_filter_group_id := data.get(
+            "search_filter_group_id", search_filter.search_filter_group_id
+        )
+    ) is not None:
+        search_filter_group = SearchFilterGroup.get_by(
+            id=search_filter_group_id
+        )
+        if search_filter_group is None:
+            raise SearchFilterGroupNotFoundException
+        if (
+            data.get("is_shared", search_filter.is_shared)
+            != search_filter_group.is_shared
+        ):
+            raise WrongParameterException(
+                "A search filter should have the same value for is_shared than its search filter group."
+            )
+
+    department_id = data.get("department_id", None)
+    if department_id is not None:
+        department = tasks_service.get_department(department_id)
+        if department is None:
+            raise WrongParameterException(
+                f"No department found with id: {department_id}"
+            )
+
     search_filter.update(data)
-    clear_filter_cache(current_user["id"])
+    if search_filter.is_shared:
+        clear_filter_cache()
+    else:
+        clear_filter_cache(current_user["id"])
     return search_filter.serialize()
 
 
@@ -928,7 +1064,10 @@ def remove_filter(search_filter_id):
     if search_filter is None:
         raise SearchFilterNotFoundException
     search_filter.delete()
-    clear_filter_cache(current_user["id"])
+    if search_filter.is_shared:
+        clear_filter_cache()
+    else:
+        clear_filter_cache(current_user["id"])
     return search_filter.serialize()
 
 
@@ -942,7 +1081,7 @@ def get_filter_groups():
     return get_user_filter_groups(current_user["id"])
 
 
-@cache.memoize_function(120)
+@cache.memoize_function(10)
 def get_user_filter_groups(current_user_id):
     """
     Retrieve search filter groups used for given user. It groups them by
@@ -953,49 +1092,74 @@ def get_user_filter_groups(current_user_id):
     result = {}
 
     filter_groups = (
-        SearchFilterGroup.query.join(
+        SearchFilterGroup.query.outerjoin(
             Project, Project.id == SearchFilterGroup.project_id
         )
-        .join(ProjectStatus, ProjectStatus.id == Project.project_status_id)
-        .filter(SearchFilterGroup.person_id == current_user_id)
-        .filter(build_open_project_filter())
-        .all()
-    )
-
-    filter_groups = (
-        filter_groups
-        + SearchFilterGroup.query.filter(
-            SearchFilterGroup.person_id == current_user_id
+        .outerjoin(
+            ProjectStatus, ProjectStatus.id == Project.project_status_id
+        )
+        .filter(
+            or_(
+                SearchFilterGroup.person_id == current_user_id,
+                SearchFilterGroup.is_shared == True,
+            )
         )
-        .filter(SearchFilterGroup.project_id == None)
+        .filter(or_(build_open_project_filter(), Project.id == None))
         .all()
     )
 
+    current_user = persons_service.get_current_user(relations=True)
+    is_manager = permissions.has_manager_permissions()
+
     for search_filter_group in filter_groups:
         if search_filter_group.list_type not in result:
             result[search_filter_group.list_type] = {}
-        subresult = result[search_filter_group.list_type]
 
-        if search_filter_group.project_id is None:
-            project_id = "all"
-        else:
-            project_id = str(search_filter_group.project_id)
+        department_id = search_filter_group.department_id
+        is_in_departments = (
+            department_id is not None
+            and str(department_id) in current_user["departments"]
+        )
+        if department_id is None or is_manager or is_in_departments:
+            subresult = result[search_filter_group.list_type]
 
-        if project_id not in subresult:
-            subresult[project_id] = []
+            if search_filter_group.project_id is None:
+                project_id = "all"
+            else:
+                project_id = str(search_filter_group.project_id)
 
-        subresult[project_id].append(search_filter_group.serialize())
+            if project_id not in subresult:
+                subresult[project_id] = []
+            subresult[project_id].append(search_filter_group.serialize())
 
     return result
 
 
 def create_filter_group(
-    list_type, name, color, project_id=None, entity_type=None
+    list_type,
+    name,
+    color,
+    project_id=None,
+    entity_type=None,
+    is_shared=False,
+    department_id=None,
 ):
     """
     Add a new search filter group to the database.
     """
     current_user = persons_service.get_current_user()
+    if project_id is None or (
+        project_id is not None and not has_manager_project_access(project_id)
+    ):
+        is_shared = False
+
+    if department_id is not None:
+        department = tasks_service.get_department(department_id)
+        if department is None:
+            raise WrongParameterException(
+                f"No department found with id: {department_id}"
+            )
+
     search_filter_group = SearchFilterGroup.create(
         list_type=list_type,
         name=name,
@@ -1003,9 +1167,16 @@ def create_filter_group(
         project_id=project_id,
         person_id=current_user["id"],
         entity_type=entity_type,
+        is_shared=is_shared,
+        department_id=department_id,
     )
     search_filter_group.serialize()
-    clear_filter_group_cache(current_user["id"])
+
+    if search_filter_group.is_shared:
+        clear_filter_group_cache()
+    else:
+        clear_filter_group_cache(current_user["id"])
+
     return search_filter_group.serialize()
 
 
@@ -1030,10 +1201,43 @@ def update_filter_group(search_filter_group_id, data):
     search_filter_group = SearchFilterGroup.get_by(
         id=search_filter_group_id, person_id=current_user["id"]
     )
+
     if search_filter_group is None:
         raise SearchFilterGroupNotFoundException
+
+    if (
+        data.get("is_shared", None) is not None
+        and search_filter_group.is_shared != data["is_shared"]
+        and (
+            data.get("project_id", None) is None
+            or (
+                data["project_id"] is not None
+                and not has_manager_project_access(data["project_id"])
+            )
+        )
+    ):
+        data["is_shared"] = False
+
     search_filter_group.update(data)
-    clear_filter_group_cache(current_user["id"])
+
+    if (
+        data.get("is_shared", None) is not None
+        and data.get("project_id", None) is not None
+        and has_manager_project_access(data["project_id"])
+    ):
+        if (
+            SearchFilter.query.filter_by(
+                search_filter_group_id=search_filter_group_id
+            ).update({"is_shared": data["is_shared"]})
+            > 0
+        ):
+            SearchFilter.query.session.commit()
+            clear_filter_cache()
+
+    if search_filter_group.is_shared:
+        clear_filter_group_cache()
+    else:
+        clear_filter_group_cache(current_user["id"])
     return search_filter_group.serialize()
 
 
@@ -1047,8 +1251,19 @@ def remove_filter_group(search_filter_group_id):
     )
     if search_filter_group is None:
         raise SearchFilterGroupNotFoundException
+    if (
+        SearchFilter.query.filter_by(
+            search_filter_group_id=search_filter_group_id
+        ).delete()
+        > 0
+    ):
+        SearchFilter.query.session.commit()
+        clear_filter_cache()
     search_filter_group.delete()
-    clear_filter_group_cache(current_user["id"])
+    if search_filter_group.is_shared:
+        clear_filter_group_cache()
+    else:
+        clear_filter_group_cache(current_user["id"])
     return search_filter_group.serialize()
 
 
@@ -1064,6 +1279,18 @@ def get_notification(notification_id):
     return notifications[0]
 
 
+def update_notification(notification_id, read):
+    """
+    Update read status of given notification.
+    """
+    current_user = persons_service.get_current_user()
+    notification = Notification.get_by(
+        id=notification_id, person_id=current_user["id"]
+    )
+    notification.update({"read": read})
+    return notification.serialize()
+
+
 def get_unread_notifications_count(notification_id=None):
     """
     Return the number of unread notifications.
@@ -1074,6 +1301,9 @@ def get_unread_notifications_count(notification_id=None):
     ).count()
 
 
+from sqlalchemy import and_, func
+
+
 def get_last_notifications(
     notification_id=None,
     after=None,
@@ -1081,6 +1311,8 @@ def get_last_notifications(
     task_type_id=None,
     task_status_id=None,
     notification_type=None,
+    read=None,
+    watching=None,
 ):
     """
     Return last 100 user notifications.
@@ -1095,6 +1327,13 @@ def get_last_notifications(
         .join(Author, Author.id == Notification.author_id)
         .join(Task, Task.id == Notification.task_id)
         .join(Project, Project.id == Task.project_id)
+        .outerjoin(
+            Subscription,
+            and_(
+                Subscription.task_id == Task.id,
+                Subscription.person_id == current_user["id"],
+            ),
+        )
         .outerjoin(Comment, Comment.id == Notification.comment_id)
         .add_columns(
             Project.id,
@@ -1105,6 +1344,7 @@ def get_last_notifications(
             Comment.text,
             Comment.replies,
             Task.entity_id,
+            Subscription.id,
             Author.role,
         )
     )
@@ -1133,6 +1373,15 @@ def get_last_notifications(
     if notification_type is not None:
         query = query.filter(Notification.type == notification_type)
 
+    if read is not None:
+        query = query.filter(Notification.read == read)
+
+    if watching is not None:
+        if watching:
+            query = query.filter(Subscription.id != None)
+        else:
+            query = query.filter(Subscription.id == None)
+
     notifications = query.limit(100).all()
 
     for (
@@ -1145,10 +1394,11 @@ def get_last_notifications(
         comment_text,
         comment_replies,
         task_entity_id,
+        subscription_id,
         role,
     ) in notifications:
-        (full_entity_name, episode_id) = names_service.get_full_entity_name(
-            task_entity_id
+        (full_entity_name, episode_id, entity_preview_file_id) = (
+            names_service.get_full_entity_name(task_entity_id)
         )
         preview_file_id = None
         mentions = []
@@ -1208,6 +1458,8 @@ def get_last_notifications(
                     "change": notification.change,
                     "full_entity_name": full_entity_name,
                     "episode_id": episode_id,
+                    "entity_preview_file_id": entity_preview_file_id,
+                    "subscription_id": subscription_id,
                 }
             )
         )
@@ -1220,17 +1472,21 @@ def mark_notifications_as_read():
     Mark all recent notifications for current_user as read. It is useful
     to mark a list of notifications as read after an user retrieved them.
     """
+    from sqlalchemy import update
+    from zou.app import db
+
     current_user = persons_service.get_current_user()
-    notifications = (
-        Notification.query.filter_by(person_id=current_user["id"], read=False)
-        .order_by(Notification.created_at)
-        .all()
+    update_stmt = (
+        update(Notification)
+        .where(Notification.person_id == current_user["id"])
+        .where(Notification.read == False)
+        .values(read=True)
     )
 
-    for notification in notifications:
-        notification.update({"read": True})
+    db.session.execute(update_stmt)
+    db.session.commit()
 
-    return fields.serialize_list(notifications)
+    return True
 
 
 def has_task_subscription(task_id):
@@ -1313,38 +1569,25 @@ def get_timezone():
 
 
 def get_context():
-    if permissions.has_admin_permissions():
-        projects = projects_service.open_projects()
-    else:
-        projects = get_open_projects()
-
-    asset_types = assets_service.get_asset_types()
-    custom_actions = custom_actions_service.get_custom_actions()
-    status_automations = status_automations_service.get_status_automations()
-    persons = persons_service.get_persons(
-        minimal=not permissions.has_manager_permissions()
-    )
-    notification_count = get_unread_notifications_count()
-    project_status_list = projects_service.get_project_statuses()
-    departments = tasks_service.get_departments()
-    task_types = tasks_service.get_task_types()
-    task_status_list = tasks_service.get_task_statuses()
-    search_filters = get_filters()
-    search_filter_groups = get_filter_groups()
-    preview_background_files = files_service.get_preview_background_files()
-
-    return {
-        "asset_types": asset_types,
-        "custom_actions": custom_actions,
-        "status_automations": status_automations,
-        "departments": departments,
-        "notification_count": notification_count,
-        "persons": persons,
-        "project_status": project_status_list,
-        "projects": projects,
-        "task_types": task_types,
-        "task_status": task_status_list,
-        "search_filters": search_filters,
-        "search_filter_groups": search_filter_groups,
-        "preview_background_files": preview_background_files,
+    context = {
+        "asset_types": assets_service.get_asset_types(),
+        "custom_actions": custom_actions_service.get_custom_actions(),
+        "status_automations": status_automations_service.get_status_automations(),
+        "departments": tasks_service.get_departments(),
+        "studios": tasks_service.get_studios(),
+        "notification_count": get_unread_notifications_count(),
+        "persons": persons_service.get_persons(
+            minimal=not permissions.has_manager_permissions()
+        ),
+        "project_status": projects_service.get_project_statuses(),
+        "projects": get_open_projects(),
+        "task_types": tasks_service.get_task_types(),
+        "task_status": tasks_service.get_task_statuses(),
+        "search_filters": get_filters(),
+        "search_filter_groups": get_filter_groups(),
+        "preview_background_files": files_service.get_preview_background_files(),
     }
+
+    if permissions.has_admin_permissions():
+        context["user_limit"] = config.USER_LIMIT
+    return context