zou 0.20.38__py3-none-any.whl → 0.20.40__py3-none-any.whl

zou/app/services/budget_service.py

@@ -0,0 +1,195 @@
+from zou.app.models.budget import Budget
+from zou.app.models.budget_entry import BudgetEntry
+
+from zou.app.services.exception import (
+    BudgetNotFoundException,
+    BudgetEntryNotFoundException,
+)
+
+from zou.app.utils import events
+from zou.app.utils import fields
+
+from sqlalchemy.exc import StatementError
+
+
+def get_budget_raw(budget_id):
+    """
+    Return budget corresponding to given budget ID.
+    """
+    if budget_id is None:
+        raise BudgetNotFoundException()
+
+    try:
+        budget = Budget.get(budget_id)
+    except StatementError:
+        raise BudgetNotFoundException()
+
+    if budget is None:
+        raise BudgetNotFoundException()
+    return budget
+
+
+def get_budget(budget_id):
+    """
+    Return budget corresponding to given budget ID as a dictionary.
+    """
+    return get_budget_raw(budget_id).serialize(relations=True)
+
+
+def get_budgets(project_id):
+    """
+    Return all budgets for given project ID.
+    """
+    budgets = Budget.get_all_by(project_id=project_id)
+    return fields.present_models(budgets)
+
+
+def create_budget(project_id, name, currency=None):
+    """
+    Create a new budget for given project ID.
+    """
+    last_budget = (
+        Budget.query.filter_by(project_id=project_id)
+        .order_by(Budget.revision.desc())
+        .first()
+    )
+    last_revision = 1
+    if last_budget is not None:
+        last_revision = last_budget.revision + 1
+    budget = Budget(
+        project_id=project_id,
+        name=name,
+        currency=currency,
+        revision=last_revision,
+    )
+    budget.save()
+    events.emit(
+        "budget:create",
+        {"budget_id": str(budget.id)},
+        project_id=project_id,
+    )
+    return budget.serialize()
+
+
+def update_budget(budget_id, name=None, currency=None):
+    """
+    Update budget corresponding to given budget ID.
+    """
+    budget = get_budget_raw(budget_id)
+    if name is not None:
+        budget.name = name
+    if currency is not None:
+        budget.currency = currency
+    budget.save()
+    events.emit(
+        "budget:update",
+        {"budget_id": str(budget.id)},
+        project_id=str(budget.project_id),
+    )
+    return budget.serialize()
+
+
+def delete_budget(budget_id):
+    """
+    Delete budget corresponding to given budget ID.
+    """
+    budget = get_budget_raw(budget_id)
+    budget_entries = BudgetEntry.delete_all_by(budget_id=budget_id)
+    budget.delete()
+    events.emit(
+        "budget:delete",
+        {"budget_id": budget_id},
+        project_id=str(budget.project_id),
+    )
+    return budget.serialize()
+
+
+def get_budget_entries(budget_id):
+    """
+    Return all budget entries for given budget ID.
+    """
+    budget_entries = BudgetEntry.get_all_by(budget_id=budget_id)
+    return fields.present_models(budget_entries)
+
+
+def get_budget_entry_raw(budget_entry_id):
+    """
+    Return budget entry corresponding to given budget entry ID.
+    """
+    try:
+        budget_entry = BudgetEntry.get(budget_entry_id)
+    except StatementError:
+        raise BudgetEntryNotFoundException()
+
+    if budget_entry is None:
+        raise BudgetEntryNotFoundException()
+    return budget_entry
+
+
+def get_budget_entry(budget_entry_id):
+    """
+    Return budget entry corresponding to given budget entry ID as a dictionary.
+    """
+    return get_budget_entry_raw(budget_entry_id).serialize()
+
+
+def create_budget_entry(
+    budget_id,
+    department_id,
+    start_date,
+    months_duration,
+    daily_salary,
+    position,
+    seniority,
+    person_id=None,
+):
+    """
+    Create a new budget entry for given budget ID.
+    """
+    budget = get_budget_raw(budget_id)
+    budget_entry = BudgetEntry.create(
+        budget_id=budget_id,
+        department_id=department_id,
+        person_id=person_id,
+        start_date=start_date,
+        months_duration=months_duration,
+        daily_salary=daily_salary,
+        position=position,
+        seniority=seniority,
+    )
+    events.emit(
+        "budget-entry:create",
+        {"budget_id": str(budget_id), "budget_entry_id": str(budget_entry.id)},
+        project_id=str(budget.project_id),
+    )
+    return budget_entry.serialize()
+
+
+def update_budget_entry(budget_entry_id, data):
+    """
+    Update budget entry corresponding to given budget entry ID.
+    """
+    budget_entry = get_budget_entry_raw(budget_entry_id)
+    budget = get_budget_raw(str(budget_entry.budget_id))
+    budget_entry.update(data)
+    events.emit(
+        "budget-entry:update",
+        {"budget_id": str(budget.id), "budget_entry_id": str(budget_entry.id)},
+        project_id=str(budget.project_id),
+    )
+    return budget_entry.serialize()
+
+
+def delete_budget_entry(budget_entry_id):
+    """
+    Delete budget entry corresponding to given budget entry ID.
+    """
+    budget_entry = get_budget_entry_raw(budget_entry_id)
+    budget = get_budget_raw(str(budget_entry.budget_id))
+    budget_entry.delete()
+    events.emit(
+        "budget-entry:delete",
+        {"budget_id": str(budget.id), "budget_entry_id": budget_entry_id},
+        project_id=str(budget.project_id),
+    )
+    return budget_entry.serialize()

zou/app/services/comments_service.py

@@ -333,7 +333,7 @@ def new_comment(
         {
             "comment_id": comment["id"],
             "task_id": task_id,
-            "task_status_id": task_status_id
+            "task_status_id": task_status_id,
         },
         project_id=task["project_id"],
     )

zou/app/services/exception.py

@@ -149,6 +149,14 @@ class MetadataDescriptorNotFoundException(NotFound):
     pass
 
 
+class BudgetNotFoundException(NotFound):
+    pass
+
+
+class BudgetEntryNotFoundException(NotFound):
+    pass
+
+
 class MalformedFileTreeException(Exception):
     pass
 

zou/app/services/plugins_service.py

@@ -0,0 +1,169 @@
+import zipfile
+import semver
+import shutil
+from pathlib import Path
+
+from zou.app import config, db
+from zou.app.models.plugin import Plugin
+from zou.app.utils.plugins import PluginManifest
+
+
+def install_plugin(path, force=False):
+    """
+    Install a plugin.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Plugin path '{path}' does not exist.")
+
+    manifest = PluginManifest.from_plugin_path(path)
+    plugin = Plugin.query.filter_by(plugin_id=manifest.id).one_or_none()
+
+    try:
+        already_installed = False
+        if plugin:
+            current = semver.Version.parse(plugin.version)
+            new = semver.Version.parse(str(manifest.version))
+            if not force and new <= current:
+                raise ValueError(
+                    f"Plugin version {new} is not newer than {current}."
+                )
+            plugin.update_no_commit(manifest.to_model_dict())
+            already_installed = True
+        else:
+            plugin = Plugin.create_no_commit(**manifest.to_model_dict())
+
+        install_plugin_files(manifest.id, path, already_installed)
+    except Exception:
+        uninstall_plugin_files(manifest.id)
+        db.session.rollback()
+        db.session.remove()
+        raise
+
+    Plugin.commit()
+    return plugin.serialize()
+
+
+def install_plugin_files(plugin_id, path, already_installed=False):
+    """
+    Install plugin files.
+    """
+    path = Path(path)
+    plugin_path = Path(config.PLUGIN_FOLDER) / plugin_id
+    if already_installed and plugin_path.exists():
+        shutil.rmtree(plugin_path)
+
+    plugin_path.mkdir(parents=True, exist_ok=True)
+
+    if path.is_dir():
+        shutil.copytree(path, plugin_path, dirs_exist_ok=True)
+    elif zipfile.is_zipfile(path):
+        shutil.unpack_archive(path, plugin_path, format="zip")
+    else:
+        raise ValueError(
+            f"Plugin path '{path}' is not a valid zip file or a directory."
+        )
+
+    return plugin_path
+
+
+def uninstall_plugin_files(plugin_id):
+    """
+    Uninstall plugin files.
+    """
+    plugin_path = Path(config.PLUGIN_FOLDER) / plugin_id
+    if plugin_path.exists():
+        shutil.rmtree(plugin_path)
+        return True
+    return False
+
+
+def uninstall_plugin(plugin_id):
+    """
+    Uninstall a plugin.
+    """
+    installed = uninstall_plugin_files(plugin_id)
+    plugin = Plugin.query.filter_by(plugin_id=plugin_id).one_or_none()
+    if plugin is not None:
+        installed = True
+        plugin.delete()
+
+    if not installed:
+        raise ValueError(f"Plugin '{plugin_id}' is not installed.")
+    return True
+
+
+def create_plugin_skeleton(
+    path,
+    id,
+    name,
+    description=None,
+    version=None,
+    maintainer=None,
+    website=None,
+    license=None,
+    force=False,
+):
+    plugin_template_path = (
+        Path(__file__).parent.parent.parent / "plugin_template"
+    )
+    plugin_path = Path(path) / id
+
+    if plugin_path.exists():
+        if force:
+            shutil.rmtree(plugin_path)
+        else:
+            raise FileExistsError(
+                f"Plugin '{id}' already exists in {plugin_path}."
+            )
+
+    shutil.copytree(plugin_template_path, plugin_path)
+
+    manifest = PluginManifest.from_file(plugin_path / "manifest.toml")
+
+    manifest.id = id
+    manifest.name = name
+    if description:
+        manifest.description = description
+    if version:
+        manifest.version = version
+    if maintainer:
+        manifest.maintainer = maintainer
+    if website:
+        manifest.website = website
+    if license:
+        manifest.license = license
+
+    manifest.validate()
+    manifest.write_to_path(plugin_path)
+
+    return plugin_path
+
+
+def create_plugin_package(path, output_path, force=False):
+    """
+    Create a plugin package.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Plugin path '{path}' does not exist.")
+
+    manifest = PluginManifest.from_plugin_path(path)
+
+    output_path = Path(output_path)
+    if not output_path.suffix == ".zip":
+        output_path /= f"{manifest.id}-{manifest.version}.zip"
+    if output_path.exists():
+        if force:
+            output_path.unlink()
+        else:
+            raise FileExistsError(
+                f"Output path '{output_path}' already exists."
+            )
+
+    output_path = shutil.make_archive(
+        output_path.with_suffix(""),
+        "zip",
+        path,
+    )
+    return output_path

zou/app/services/user_service.py

@@ -1460,9 +1460,7 @@ def get_last_notifications(
                 )
             else:
                 reply_mentions = []
-                reply_department_mentions = (
-                    []
-                )
+                reply_department_mentions = []
 
         if role == "client" and is_current_user_artist:
             comment_text = ""

zou/app/utils/commands.py

@@ -5,8 +5,10 @@ import datetime
 import tempfile
 import sys
 import shutil
+import click
+import orjson as json
 
-
+from tabulate import tabulate
 from ldap3 import Server, Connection, ALL, NTLM, SIMPLE
 from zou.app.utils import thumbnail as thumbnail_utils, auth
 from zou.app.stores import auth_tokens_store, file_store, queue_store
@@ -27,6 +29,7 @@ from zou.app.services import (
 from zou.app.models.person import Person
 from zou.app.models.preview_file import PreviewFile
 from zou.app.models.task import Task
+from zou.app.models.plugin import Plugin
 from sqlalchemy.sql.expression import not_
 
 from zou.app.services.exception import (
@@ -823,3 +826,50 @@ def renormalize_movie_preview_files(
                             f"Renormalization of preview file {preview_file_id} failed: {e}"
                         )
                         continue
+
+
+def list_plugins(output_format, verbose, filter_field, filter_value):
+    with app.app_context():
+        query = Plugin.query
+
+        # Apply filter if needed
+        if filter_field and filter_value:
+            if filter_field == "maintainer":
+                query = query.filter(
+                    Plugin.maintainer_name.ilike(f"%{filter_value}%")
+                )
+            else:
+                model_field = getattr(Plugin, filter_field)
+                query = query.filter(model_field.ilike(f"%{filter_value}%"))
+
+        plugins = query.order_by(Plugin.name).all()
+
+        if not plugins:
+            click.echo("No plugins found matching the criteria.")
+            return
+
+        plugin_list = []
+        for plugin in plugins:
+            maintainer = (
+                f"{plugin.maintainer_name} <{plugin.maintainer_email}>"
+                if plugin.maintainer_email
+                else plugin.maintainer_name
+            )
+            plugin_data = {
+                "Plugin ID": plugin.plugin_id,
+                "Name": plugin.name,
+                "Version": plugin.version,
+                "Maintainer": maintainer,
+                "License": plugin.license,
+            }
+            if verbose:
+                plugin_data["Description"] = plugin.description or "-"
+                plugin_data["Website"] = plugin.website or "-"
+            plugin_list.append(plugin_data)
+
+        if output_format == "table":
+            headers = plugin_list[0].keys()
+            rows = [p.values() for p in plugin_list]
+            click.echo(tabulate(rows, headers, tablefmt="fancy_grid"))
+        elif output_format == "json":
+            click.echo(json.dumps(plugin_list, indent=2, ensure_ascii=False))

zou/app/utils/fields.py

@@ -92,6 +92,13 @@ def serialize_models(models, relations=False, milliseconds=False):
     ]
 
 
+def present_models(models):
+    """
+    Present a list of models (useful for json dumping)
+    """
+    return [model.present() for model in models if model is not None]
+
+
 def gen_uuid():
     """
     Generate a unique identifier (useful for json dumping).
@@ -123,6 +130,9 @@ def get_default_date_object(date_string):
 
 
 def is_valid_id(uuid):
+    """
+    Check if a given string is a valid UUID.
+    """
     _UUID_RE = re.compile(
         "([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}){1}"
     )

zou/app/utils/plugins.py

@@ -0,0 +1,88 @@
+import tomlkit
+import semver
+import email.utils
+import spdx_license_list
+import zipfile
+
+from pathlib import Path
+from collections.abc import MutableMapping
+
+
+class PluginManifest(MutableMapping):
+    def __init__(self, data):
+        super().__setattr__("data", data)
+        self.validate()
+
+    @classmethod
+    def from_plugin_path(cls, path):
+        path = Path(path)
+        if path.is_dir():
+            return cls.from_file(path / "manifest.toml")
+        elif zipfile.is_zipfile(path):
+            with zipfile.ZipFile(path) as z:
+                with z.open("manifest.toml") as f:
+                    data = tomlkit.load(f)
+            return cls(data)
+        else:
+            raise ValueError(f"Invalid plugin path: {path}")
+
+    @classmethod
+    def from_file(cls, path):
+        with open(path, "rb") as f:
+            data = tomlkit.load(f)
+        return cls(data)
+
+    def write_to_path(self, path):
+        path = Path(path)
+        with open(path / "manifest.toml", "w", encoding="utf-8") as f:
+            tomlkit.dump(self.data, f)
+
+    def validate(self):
+        semver.Version.parse(str(self.data["version"]))
+        spdx_license_list.LICENSES[self.data["license"]]
+        if "maintainer" in self.data:
+            name, email_addr = email.utils.parseaddr(self.data["maintainer"])
+            self.data["maintainer_name"] = name
+            self.data["maintainer_email"] = email_addr
+
+    def to_model_dict(self):
+        return {
+            "plugin_id": self.data["id"],
+            "name": self.data["name"],
+            "description": self.data.get("description"),
+            "version": str(self.data["version"]),
+            "maintainer_name": self.data.get("maintainer_name"),
+            "maintainer_email": self.data.get("maintainer_email"),
+            "website": self.data.get("website"),
+            "license": self.data["license"],
+        }
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+    def __setitem__(self, key, value):
+        self.data[key] = value
+
+    def __delitem__(self, key):
+        del self.data[key]
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __len__(self):
+        return len(self.data)
+
+    def __repr__(self):
+        return f"<PluginManifest {self.data!r}>"
+
+    def __getattr__(self, attr):
+        try:
+            return self.data[attr]
+        except KeyError:
+            raise AttributeError(f"'PluginManifest' has no attribute '{attr}'")
+
+    def __setattr__(self, attr, value):
+        if attr == "data":
+            super().__setattr__(attr, value)
+        else:
+            self.data[attr] = value