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

zou/app/models/working_file.py

@@ -17,7 +17,7 @@ class WorkingFile(db.Model, BaseMixin, SerializerMixin):
     shotgun_id = db.Column(db.Integer(), index=True)
 
     name = db.Column(db.String(250))
-    description = db.Column(db.String(200))
+    description = db.Column(db.Text())
     comment = db.Column(db.Text())
     revision = db.Column(db.Integer())
     size = db.Column(db.Integer())

zou/app/services/assets_service.py

@@ -40,7 +40,7 @@ from zou.app.services.exception import (
 
 def clear_asset_cache(asset_id):
     cache.cache.delete_memoized(get_asset, asset_id)
-    cache.cache.delete_memoized(get_asset_with_relations, asset_id)
+    cache.cache.delete_memoized(get_asset, asset_id, True)
     cache.cache.delete_memoized(get_full_asset, asset_id)
 
 
@@ -84,7 +84,7 @@ def build_entity_type_asset_type_filter():
     return ~EntityType.id.in_(ids_to_exclude)
 
 
-def get_assets(criterions={}):
+def get_assets(criterions={}, is_admin=False):
     """
     Get all assets for given criterions.
     """
@@ -102,6 +102,12 @@ def get_assets(criterions={}):
         query = query.outerjoin(Task)
         query = query.filter(user_service.build_assignee_filter())
 
+    if "is_shared" in criterions:
+        if not is_admin:
+            query = query.join(Project).filter(
+                user_service.build_team_filter()
+            )
+
     if episode_id is not None:
         # Filter based on main episode.
         query = query.filter(Entity.source_id == episode_id)
@@ -121,7 +127,7 @@ def get_assets(criterions={}):
         result += [a for a in query.all() if a.source_id != episode_id]
     else:
         result = query.all()
-    return EntityType.serialize_list(result, obj_type="Asset")
+    return Entity.serialize_list(result, obj_type="Asset")
 
 
 def get_all_raw_assets():
@@ -194,7 +200,9 @@ def get_assets_and_tasks(criterions={}, page=1, with_episode_ids=False):
         Task.end_date,
         Task.start_date,
         Task.due_date,
+        Task.done_date,
         Task.last_comment_date,
+        Task.difficulty,
         assignees_table.columns.person,
     ).order_by(EntityType.name, Entity.name)
 
@@ -240,6 +248,18 @@ def get_assets_and_tasks(criterions={}, page=1, with_episode_ids=False):
             episode_links_query = episode_links_query.filter(
                 Episode.project_id == criterions["project_id"]
             )
+        if "episode_id" in criterions and criterions["episode_id"] not in [
+            "main",
+            "all",
+        ]:
+            episode_links_query = episode_links_query.filter(
+                EntityLink.entity_in_id == criterions["episode_id"]
+            )
+        if "id" in criterions:
+            episode_links_query = episode_links_query.filter(
+                EntityLink.entity_out_id == criterions["id"]
+            )
+
         for link in episode_links_query.all():
             if str(link.entity_out_id) not in cast_in_episode_ids:
                 cast_in_episode_ids[str(link.entity_out_id)] = []
@@ -272,7 +292,9 @@ def get_assets_and_tasks(criterions={}, page=1, with_episode_ids=False):
         task_end_date,
         task_start_date,
         task_due_date,
+        task_done_date,
         task_last_comment_date,
+        task_difficulty,
         person_id,
     ) in query_result:
         if asset.source_id is None:
@@ -304,6 +326,7 @@ def get_assets_and_tasks(criterions={}, page=1, with_episode_ids=False):
                 "episode_id": source_id,
                 "casting_episode_ids": cast_in_episode_ids.get(asset_id, []),
                 "is_casting_standby": asset.is_casting_standby,
+                "is_shared": asset.is_shared,
                 "data": data,
                 "tasks": [],
             }
@@ -314,6 +337,7 @@ def get_assets_and_tasks(criterions={}, page=1, with_episode_ids=False):
                 task_dict = {
                     "id": task_id,
                     "due_date": fields.serialize_value(task_due_date),
+                    "done_date": fields.serialize_value(task_done_date),
                     "duration": task_duration,
                     "entity_id": asset_id,
                     "estimation": task_estimation,
@@ -328,6 +352,7 @@ def get_assets_and_tasks(criterions={}, page=1, with_episode_ids=False):
                     ),
                     "retake_count": task_retake_count,
                     "start_date": fields.serialize_value(task_start_date),
+                    "difficulty": task_difficulty,
                     "task_status_id": str(task_status_id),
                     "task_type_id": str(task_type_id),
                     "assignees": [],
@@ -403,19 +428,13 @@ def get_asset_raw(entity_id):
 
 
 @cache.memoize_function(120)
-def get_asset(entity_id):
-    """
-    Return a given asset as a dict.
-    """
-    return get_asset_raw(entity_id).serialize(obj_type="Asset")
-
-
-@cache.memoize_function(120)
-def get_asset_with_relations(entity_id):
+def get_asset(entity_id, relations=False):
     """
     Return a given asset as a dict.
     """
-    return get_asset_raw(entity_id).serialize(obj_type="Asset", relations=True)
+    return get_asset_raw(entity_id).serialize(
+        obj_type="Asset", relations=relations
+    )
 
 
 def get_asset_by_shotgun_id(shotgun_id):
@@ -445,7 +464,7 @@ def get_full_asset(asset_id):
     """
     assets = get_assets_and_tasks({"id": asset_id}, with_episode_ids=True)
     if len(assets) > 0:
-        asset = get_asset_with_relations(asset_id)
+        asset = get_asset(asset_id, relations=True)
         asset_type_id = asset["entity_type_id"]
         asset_type = get_asset_type(asset_type_id)
         project = Project.get(asset["project_id"])
@@ -568,6 +587,7 @@ def create_asset(
     name,
     description,
     data,
+    is_shared=False,
     source_id=None,
     created_by=None,
 ):
@@ -584,6 +604,7 @@ def create_asset(
         name=name,
         description=description,
         data=data,
+        is_shared=is_shared,
         source_id=source_id,
         created_by=created_by,
     )
@@ -703,3 +724,69 @@ def cancel_asset(asset_id, force=True):
         project_id=str(asset.project_id),
     )
     return asset_dict
+
+
+def set_shared_assets(
+    is_shared=True,
+    project_id=None,
+    asset_type_id=None,
+    asset_ids=None,
+    with_events=False,
+):
+    """
+    Set all assets of a project to is_shared=True or False.
+    """
+
+    query = Entity.query.filter(build_asset_type_filter()).filter()
+
+    if project_id is not None:
+        query = query.filter(Entity.project_id == project_id)
+
+    if asset_type_id is not None:
+        query = query.filter(Entity.entity_type_id == asset_type_id)
+
+    if asset_ids is not None:
+        query = query.filter(Entity.id.in_(asset_ids))
+
+    assets = query.all()
+
+    for asset in assets:
+        asset.update_no_commit({"is_shared": is_shared})
+
+    Entity.commit()
+
+    for asset in assets:
+        asset_id = str(asset.id)
+        clear_asset_cache(asset_id)
+        if with_events:
+            events.emit(
+                "asset:update",
+                {"asset_id": asset_id},
+                project_id=project_id,
+            )
+
+    return Entity.serialize_list(assets, obj_type="Asset")
+
+
+def get_shared_assets_used_in_project(project_id, episode_id=None):
+    """
+    Get all shared assets used in a project.
+    """
+    Shot = aliased(Entity, name="shot")
+    Sequence = aliased(Entity, name="sequence")
+
+    assets = (
+        Entity.query.filter(build_asset_type_filter())
+        .filter(Entity.is_shared == True)
+        .join(EntityLink, EntityLink.entity_out_id == Entity.id)
+        .join(Shot, EntityLink.entity_in_id == Shot.id)
+        .join(Sequence, Shot.parent_id == Sequence.id)
+        .filter(Shot.project_id == project_id)
+        .filter(Entity.canceled != True)
+        .filter(Entity.project_id != project_id)
+    )
+
+    if episode_id is not None and episode_id not in ["main", "all"]:
+        assets = assets.filter(Sequence.parent_id == episode_id)
+
+    return Entity.serialize_list(assets.all(), obj_type="Asset")

zou/app/services/auth_service.py

@@ -2,13 +2,12 @@ import pyotp
 import random
 import string
 import flask_bcrypt
-import fido2.features
-from datetime import datetime, timedelta
+
+from datetime import timedelta
 
 from flask import request, session, current_app
 from babel.dates import format_datetime
 
-from flask_jwt_extended import get_jti
 from ldap3 import Server, Connection, ALL, NTLM, SIMPLE
 from ldap3.core.exceptions import (
     LDAPSocketOpenError,
@@ -37,29 +36,15 @@ from zou.app.services.exception import (
 )
 from zou.app.stores import auth_tokens_store
 from zou.app.utils import date_helpers, emails
-from zou.app import config
 
 from fido2.webauthn import (
-    PublicKeyCredentialRpEntity,
     PublicKeyCredentialUserEntity,
 )
-from fido2.server import Fido2Server
 from sqlalchemy.orm.attributes import flag_modified
-from urllib.parse import urlparse
+
 from fido2.utils import bytes2int, int2bytes
 from fido2.webauthn import AttestedCredentialData
 
-fido2.features.webauthn_json_mapping.enabled = True
-
-fido_server = Fido2Server(
-    PublicKeyCredentialRpEntity(
-        name="Kitsu", id=urlparse(f"https://{config.DOMAIN_NAME}").hostname
-    ),
-    verify_origin=(
-        None if config.DOMAIN_NAME != "localhost:8080" else lambda a: True
-    ),
-)
-
 
 def check_auth(
     app,
@@ -103,7 +88,9 @@ def check_auth(
             raise NoAuthStrategyConfigured()
     except WrongPasswordException:
         update_login_failed_attemps(
-            person["id"], login_failed_attemps + 1, datetime.utcnow()
+            person["id"],
+            login_failed_attemps + 1,
+            date_helpers.get_utc_now_datetime(),
         )
         raise WrongPasswordException()
 
@@ -116,7 +103,9 @@ def check_auth(
             recovery_code,
         ):
             update_login_failed_attemps(
-                person["id"], login_failed_attemps + 1, datetime.utcnow()
+                person["id"],
+                login_failed_attemps + 1,
+                date_helpers.get_utc_now_datetime(),
             )
             raise WrongOTPException()
 
@@ -341,7 +330,7 @@ def check_fido(person, authentication_response):
     except KeyError:
         return False
     try:
-        fido_server.authenticate_complete(
+        current_app.extensions["fido_server"].authenticate_complete(
             state,
             get_fido_attested_credential_data_from_person(
                 person["fido_credentials"],
@@ -488,7 +477,7 @@ def send_email_otp(person):
     )
     organisation = persons_service.get_organisation()
     time_string = format_datetime(
-        datetime.utcnow(),
+        date_helpers.get_utc_now_datetime(),
         tzinfo=person["timezone"],
         locale=person["locale"],
     )
@@ -547,7 +536,7 @@ def pre_register_fido(person_id):
     Pre-register FIDO device for a person.
     """
     person = Person.get(person_id)
-    options, state = fido_server.register_begin(
+    options, state = current_app.extensions["fido_server"].register_begin(
         PublicKeyCredentialUserEntity(
             id=str(person.id).encode(),
             name=person.email,
@@ -573,7 +562,9 @@ def register_fido(person_id, registration_response, device_name):
     except KeyError:
         raise FIDONoPreregistrationException()
     try:
-        auth_data = fido_server.register_complete(state, registration_response)
+        auth_data = current_app.extensions["fido_server"].register_complete(
+            state, registration_response
+        )
     except BaseException:
         raise FIDOServerException()
     credential_data = {
@@ -634,7 +625,7 @@ def get_challenge_fido(person_id):
     Get new FIDO challenge for a person.
     """
     person = Person.get(person_id)
-    options, state = fido_server.authenticate_begin(
+    options, state = current_app.extensions["fido_server"].authenticate_begin(
         credentials=get_fido_attested_credential_data_from_person(
             person.fido_credentials
         ),
@@ -673,24 +664,6 @@ def generate_new_recovery_codes(person_id):
     return otp_recovery_codes
 
 
-def register_tokens(app, access_token, refresh_token=None):
-    """
-    Register access and refresh tokens to auth token store. That way they
-    can be used like a session.
-    """
-    access_jti = get_jti(encoded_token=access_token)
-
-    auth_tokens_store.add(
-        access_jti, "false", app.config["JWT_ACCESS_TOKEN_EXPIRES"]
-    )
-
-    if refresh_token is not None:
-        refresh_jti = get_jti(encoded_token=refresh_token)
-        auth_tokens_store.add(
-            refresh_jti, "false", app.config["JWT_REFRESH_TOKEN_EXPIRES"]
-        )
-
-
 def revoke_tokens(app, jti):
     """
     Remove access and refresh tokens from auth token store.
@@ -754,7 +727,7 @@ def check_login_failed_attemps(person):
         login_failed_attemps >= 5
         and date_helpers.get_datetime_from_string(person["last_login_failed"])
         + timedelta(minutes=1)
-        > datetime.utcnow()
+        > date_helpers.get_utc_now_datetime()
     ):
         raise TooMuchLoginFailedAttemps()
     return login_failed_attemps

zou/app/services/breakdown_service.py

@@ -50,6 +50,8 @@ def get_casting(shot_id):
             Entity.preview_file_id,
             Entity.source_id,
             Entity.ready_for,
+            Entity.is_shared,
+            Entity.project_id,
         )
         .order_by(EntityType.name, Entity.name)
     )
@@ -61,6 +63,8 @@ def get_casting(shot_id):
         entity_preview_file_id,
         episode_id,
         entity_ready_for,
+        entity_is_shared,
+        entity_project_id,
     ) in links:
         casting.append(
             {
@@ -74,6 +78,8 @@ def get_casting(shot_id):
                 ),
                 "nb_occurences": link.nb_occurences,
                 "label": link.label,
+                "is_shared": entity_is_shared,
+                "project_id": entity_project_id,
             }
         )
     return casting
@@ -93,11 +99,27 @@ def get_production_episodes_casting(project_id):
         .join(EntityType, Entity.entity_type_id == EntityType.id)
         .filter(Episode.project_id == project_id)
         .filter(Entity.canceled != True)
-        .add_columns(Entity.name, EntityType.name, Entity.preview_file_id)
-        .order_by(EntityType.name, Entity.name)
+        .add_columns(
+            Entity.name,
+            EntityType.name,
+            Entity.preview_file_id,
+            Entity.is_shared,
+            Entity.project_id,
+        )
+        .order_by(
+            EntityType.name,
+            Entity.name,
+        )
     )
 
-    for link, entity_name, entity_type_name, entity_preview_file_id in links:
+    for (
+        link,
+        entity_name,
+        entity_type_name,
+        entity_preview_file_id,
+        entity_is_shared,
+        entity_project_id,
+    ) in links:
         episode_id = str(link.entity_in_id)
         if episode_id not in castings:
             castings[episode_id] = []
@@ -112,6 +134,8 @@ def get_production_episodes_casting(project_id):
                 ),
                 "nb_occurences": link.nb_occurences,
                 "label": link.label,
+                "is_shared": entity_is_shared,
+                "project_id": entity_project_id,
             }
         )
     return castings
@@ -139,6 +163,8 @@ def get_sequence_casting(sequence_id, project_id=None, episode_id=None):
             Entity.name,
             EntityType.name,
             Entity.preview_file_id,
+            Entity.is_shared,
+            Entity.project_id,
             Sequence.name,
         )
     )
@@ -163,6 +189,8 @@ def get_sequence_casting(sequence_id, project_id=None, episode_id=None):
         entity_name,
         entity_type_name,
         entity_preview_file_id,
+        entity_is_shared,
+        entity_project_id,
         sequence_name,
     ) in links:
         shot_id = str(link.entity_in_id)
@@ -180,6 +208,8 @@ def get_sequence_casting(sequence_id, project_id=None, episode_id=None):
                 ),
                 "nb_occurences": link.nb_occurences,
                 "label": link.label,
+                "is_shared": entity_is_shared,
+                "project_id": entity_project_id,
             }
         )
     return castings
@@ -384,7 +414,7 @@ def _create_episode_casting_link(entity, asset_id, nb_occurences=1, label=""):
                 link = EntityLink.create(
                     entity_in_id=sequence["parent_id"],
                     entity_out_id=asset_id,
-                    nb_occurences=1,
+                    nb_occurences=nb_occurences,
                     label=label,
                 )
                 events.emit(
@@ -799,7 +829,9 @@ def _get_task_type_priority_map(project_id):
 
 def _is_asset_ready(asset, task, priority_map):
     is_ready = False
-    if "ready_for" in asset and asset["ready_for"] is not None:
+    if asset["is_shared"] and asset["project_id"] != str(task.project_id):
+        is_ready = True
+    elif "ready_for" in asset and asset["ready_for"] is not None:
         priority_ready = priority_map.get(asset["ready_for"], -1) or -1
         priority_task = priority_map.get(str(task.task_type_id), 0) or 0
         is_ready = priority_task <= priority_ready