zou 0.20.44__tar.gz → 0.20.46__tar.gz

{zou-0.20.44/zou.egg-info → zou-0.20.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zou
-Version: 0.20.44
+Version: 0.20.46
 Summary: API to store and manage the data of your animation production
 Home-page: https://zou.cg-wire.com
 Author: CG Wire

zou-0.20.46/zou/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.20.46"

{zou-0.20.44 → zou-0.20.46}/zou/app/api.py

@@ -1,9 +1,4 @@
-import os
 import sys
-import importlib
-import traceback
-
-from pathlib import Path
 
 from zou.app.blueprints.assets import blueprint as assets_blueprint
 from zou.app.blueprints.auth import blueprint as auth_blueprint
@@ -29,7 +24,7 @@ from zou.app.blueprints.user import blueprint as user_blueprint
 from zou.app.blueprints.edits import blueprint as edits_blueprint
 from zou.app.blueprints.concepts import blueprint as concepts_blueprint
 
-from zou.app.utils.plugins import PluginManifest
+from zou.app.utils.plugins import load_plugins
 from zou.app.utils import events
 
 
@@ -92,40 +87,3 @@ def register_event_handlers(app):
         # app.logger.info("No event handlers folder is configured.")
         pass
     return app
-
-
-def load_plugins(app):
-    """
-    Load plugins from the plugin folder.
-    """
-    plugin_folder = app.config["PLUGIN_FOLDER"]
-    abs_plugin_path = os.path.abspath(plugin_folder)
-    if abs_plugin_path not in sys.path:
-        sys.path.insert(0, abs_plugin_path)
-
-    if os.path.exists(plugin_folder):
-        for plugin_id in os.listdir(plugin_folder):
-            try:
-                load_plugin(app, plugin_id)
-                app.logger.info(f"Plugin {plugin_id} loaded.")
-            except ImportError as e:
-                app.logger.error(f"Plugin {plugin_id} failed to import: {e}")
-            except Exception as e:
-                app.logger.error(
-                    f"Plugin {plugin_id} failed to initialize: {e}"
-                )
-                app.logger.debug(traceback.format_exc())
-
-    if abs_plugin_path in sys.path:
-        sys.path.remove(abs_plugin_path)
-
-
-def load_plugin(app, plugin_id):
-    plugin_path = Path(app.config["PLUGIN_FOLDER"]) / plugin_id
-    manifest = PluginManifest.from_file(plugin_path / "manifest.toml")
-
-    plugin_module = importlib.import_module(plugin_id)
-    if hasattr(plugin_module, "init_plugin"):
-        plugin_module.init_plugin(app, manifest)
-
-    return plugin_module

{zou-0.20.44 → zou-0.20.46}/zou/app/blueprints/crud/person.py

@@ -101,6 +101,13 @@ class PersonsResource(BaseModelsResource):
                 raise
             except:
                 raise WrongParameterException("Expiration date is not valid.")
+
+        if "email" in data:
+            try:
+                data["email"] = auth.validate_email(data["email"])
+            except auth.EmailNotValidException as e:
+                raise WrongParameterException(str(e))
+
         return data
 
     def update_data(self, data):
@@ -184,6 +191,13 @@ class PersonResource(BaseModelResource, ArgsMixin):
                 raise
             except:
                 raise WrongParameterException("Expiration date is not valid.")
+
+        if "email" in data:
+            try:
+                data["email"] = auth.validate_email(data["email"])
+            except auth.EmailNotValidException as e:
+                raise WrongParameterException(str(e))
+
         return data
 
     def check_delete_permissions(self, instance_dict):

{zou-0.20.44 → zou-0.20.46}/zou/app/blueprints/projects/__init__.py

@@ -30,6 +30,7 @@ from zou.app.blueprints.projects.resources import (
     ProductionBudgetResource,
     ProductionBudgetEntriesResource,
     ProductionBudgetEntryResource,
+    ProductionMonthTimeSpentsResource,
 )
 
 routes = [
@@ -127,6 +128,10 @@ routes = [
         "/data/projects/<project_id>/budgets/<budget_id>/entries/<entry_id>",
         ProductionBudgetEntryResource,
     ),
+    (
+        "/data/projects/<project_id>/budgets/time-spents",
+        ProductionMonthTimeSpentsResource,
+    ),
 ]
 
 blueprint = Blueprint("projects", "projects")

{zou-0.20.44 → zou-0.20.46}/zou/app/blueprints/projects/resources.py

@@ -5,9 +5,11 @@ from flask_jwt_extended import jwt_required
 from zou.app.services import budget_service
 from zou.app.mixin import ArgsMixin
 from zou.app.services import (
+    persons_service,
     projects_service,
     schedule_service,
     tasks_service,
+    time_spents_service,
     user_service,
 )
 from zou.app.utils import permissions
@@ -1494,3 +1496,33 @@ class ProductionBudgetEntryResource(Resource, ArgsMixin):
         user_service.check_manager_project_access(project_id)
         budget_service.delete_budget_entry(entry_id)
         return "", 204
+
+
+class ProductionMonthTimeSpentsResource(Resource, ArgsMixin):
+
+    @jwt_required()
+    def get(self, project_id):
+        """
+        Get aggregated time spents by month for given project.
+        ---
+        tags:
+        - Projects
+        parameters:
+        - in: path
+            name: project_id
+            required: True
+            type: string
+            format: UUID
+            x-example: a24a6ea4-ce75-4665-a070-57453082c25
+        responses:
+            200:
+                description: Aggregated time spents for given person and month
+            400:
+                description: Wrong ID format
+        """
+        permissions.check_admin_permissions()
+        self.check_id_parameter(project_id)
+        user = persons_service.get_current_user()
+        return time_spents_service.get_project_month_time_spents(
+            project_id, user["timezone"]
+        )

{zou-0.20.44 → zou-0.20.46}/zou/app/config.py

@@ -88,6 +88,7 @@ MAIL_USE_SSL = envtobool("MAIL_USE_SSL", False)
 MAIL_DEFAULT_SENDER = os.getenv(
     "MAIL_DEFAULT_SENDER", "no-reply@your-studio.com"
 )
+MAIL_CHECK_DELIVERABILITY = envtobool("MAIL_CHECK_DELIVERABILITY", True)
 DOMAIN_NAME = os.getenv("DOMAIN_NAME", "localhost:8080")
 DOMAIN_PROTOCOL = os.getenv("DOMAIN_PROTOCOL", "https")
 

{zou-0.20.44 → zou-0.20.46}/zou/app/models/plugin.py

@@ -19,3 +19,4 @@ class Plugin(db.Model, BaseMixin, SerializerMixin):
     maintainer_email = db.Column(EmailType)
     website = db.Column(URLType)
     license = db.Column(db.String(80), nullable=False)
+    revision = db.Column(db.String(12), nullable=True)

zou-0.20.46/zou/app/services/plugins_service.py

@@ -0,0 +1,66 @@
+import semver
+from pathlib import Path
+
+from zou.app import config, db
+from zou.app.models.plugin import Plugin
+from zou.app.utils.plugins import (
+    PluginManifest,
+    run_plugin_migrations,
+    downgrade_plugin_migrations,
+    uninstall_plugin_files,
+    install_plugin_files,
+)
+
+
+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:
+        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())
+        else:
+            plugin = Plugin.create_no_commit(**manifest.to_model_dict())
+
+        plugin_path = install_plugin_files(
+            path, Path(config.PLUGIN_FOLDER) / manifest.id
+        )
+        run_plugin_migrations(plugin_path, plugin)
+    except Exception:
+        uninstall_plugin_files(manifest.id)
+        db.session.rollback()
+        db.session.remove()
+        raise
+
+    Plugin.commit()
+    return plugin.serialize()
+
+
+def uninstall_plugin(plugin_id):
+    """
+    Uninstall a plugin.
+    """
+    plugin_path = Path(config.PLUGIN_FOLDER) / plugin_id
+    downgrade_plugin_migrations(plugin_path)
+    installed = uninstall_plugin_files(plugin_path)
+    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

{zou-0.20.44 → zou-0.20.46}/zou/app/services/time_spents_service.py

@@ -7,6 +7,7 @@ from sqlalchemy.exc import DataError
 from sqlalchemy.orm import aliased
 
 from zou.app.models.day_off import DayOff
+from zou.app.models.department import Department
 from zou.app.models.project import Project
 from zou.app.models.task import Task
 from zou.app.models.task_type import TaskType
@@ -535,3 +536,38 @@ def get_timezoned_interval(start, end):
     """
     timezone = user_service.get_timezone()
     return date_helpers.get_timezoned_interval(start, end, timezone)
+
+
+def get_project_month_time_spents(project_id, timezone=None):
+    """
+    Get aggregated time spents by department by person by month for given
+    project.
+    """
+    data = {}
+    query = (
+        TimeSpent.query
+        .join(Task)
+        .join(TaskType, TaskType.id == Task.task_type_id)
+        .join(Department, Department.id == TaskType.department_id)
+        .filter(Task.project_id == project_id)
+        .add_columns(Department.id)
+        .order_by(TimeSpent.date)
+    )
+
+    for time_spent, department_id in query.all():
+        date_key = date_helpers.get_simple_string_with_timezone_from_date(
+            time_spent.date, timezone
+        )[0:7]
+        if department_id not in data:
+            data[department_id] = { "total": 0 }
+        if time_spent.person_id not in data[department_id]:
+            data[department_id][time_spent.person_id] = { "total": 0 }
+        if date_key not in data[department_id][time_spent.person_id]:
+            data[department_id][time_spent.person_id][date_key] = 0
+
+        data[department_id][time_spent.person_id][date_key] += \
+            time_spent.duration
+        data[department_id]["total"] += time_spent.duration
+        data[department_id][time_spent.person_id]["total"] += \
+            time_spent.duration
+    return data

{zou-0.20.44 → zou-0.20.46}/zou/app/utils/auth.py

@@ -23,9 +23,13 @@ def encrypt_password(password):
     return flask_bcrypt.generate_password_hash(password)
 
 
-def validate_email(email):
+def validate_email(
+    email, check_deliverability=config.MAIL_CHECK_DELIVERABILITY
+):
     try:
-        return email_validator.validate_email(email).normalized
+        return email_validator.validate_email(
+            email, check_deliverability=check_deliverability
+        ).normalized
     except email_validator.EmailNotValidError as e:
         raise EmailNotValidException(str(e))
 

{zou-0.20.44 → zou-0.20.46}/zou/app/utils/commands.py

@@ -865,6 +865,9 @@ def list_plugins(output_format, verbose, filter_field, filter_value):
             if verbose:
                 plugin_data["Description"] = plugin.description or "-"
                 plugin_data["Website"] = plugin.website or "-"
+                plugin_data["Revision"] = plugin.revision or "-"
+                plugin_data["Installation Date"] = plugin.created_at
+                plugin_data["Last Update"] = plugin.updated_at
             plugin_list.append(plugin_data)
 
         if output_format == "table":

zou-0.20.46/zou/app/utils/plugins.py

@@ -0,0 +1,340 @@
+import tomlkit
+import semver
+import email.utils
+import spdx_license_list
+import zipfile
+import importlib
+import importlib.util
+import sys
+import os
+import traceback
+import shutil
+
+from pathlib import Path
+from flask import current_app
+from alembic import command
+from alembic.config import Config
+
+
+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
+
+
+def load_plugin(app, plugin_path, init_plugin=True):
+    """
+    Load a plugin from the plugin folder.
+    """
+    plugin_path = Path(plugin_path)
+    manifest = PluginManifest.from_plugin_path(plugin_path)
+
+    plugin_module = importlib.import_module(manifest["id"])
+    if init_plugin and hasattr(plugin_module, "init_plugin"):
+        plugin_module.init_plugin(app, manifest)
+
+    return plugin_module
+
+
+def load_plugins(app):
+    """
+    Load plugins from the plugin folder.
+    """
+    plugin_folder = Path(app.config["PLUGIN_FOLDER"])
+    if plugin_folder.exists():
+        abs_plugin_path = str(plugin_folder.absolute())
+        if abs_plugin_path not in sys.path:
+            sys.path.insert(0, abs_plugin_path)
+
+        for plugin_id in os.listdir(plugin_folder):
+            try:
+                load_plugin(app, plugin_folder / plugin_id)
+                app.logger.info(f"Plugin {plugin_id} loaded.")
+            except ImportError as e:
+                app.logger.error(f"Plugin {plugin_id} failed to import: {e}")
+            except Exception as e:
+                app.logger.error(
+                    f"Plugin {plugin_id} failed to initialize: {e}"
+                )
+                app.logger.debug(traceback.format_exc())
+
+        if abs_plugin_path in sys.path:
+            sys.path.remove(abs_plugin_path)
+
+
+def migrate_plugin_db(plugin_path, message):
+    """
+    Generates Alembic migration files in path/migrations.
+    """
+    plugin_path = Path(plugin_path).absolute()
+    models_path = plugin_path / "models.py"
+
+    if not models_path.exists():
+        raise FileNotFoundError(f"'models.py' not found in '{plugin_path}'")
+
+    manifest = PluginManifest.from_plugin_path(plugin_path)
+
+    module_name = f"_plugin_models_{manifest['id']}"
+    spec = importlib.util.spec_from_file_location(module_name, models_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load 'models.py' from '{plugin_path}'")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    try:
+        spec.loader.exec_module(module)
+        migrations_dir = plugin_path / "migrations"
+        versions_dir = migrations_dir / "versions"
+        versions_dir.mkdir(parents=True, exist_ok=True)
+
+        alembic_cfg = Config()
+        alembic_cfg.config_file_name = str(
+            plugin_path / "migrations" / "alembic.ini"
+        )
+        alembic_cfg.set_main_option("script_location", str(migrations_dir))
+        alembic_cfg.set_main_option(
+            "sqlalchemy.url", current_app.config["SQLALCHEMY_DATABASE_URI"]
+        )
+
+        command.revision(alembic_cfg, autogenerate=True, message=message)
+    finally:
+        del sys.modules[module_name]
+
+
+def run_plugin_migrations(plugin_path, plugin):
+    """
+    Run plugin migrations.
+    """
+    plugin_path = Path(plugin_path)
+
+    alembic_cfg = Config()
+    alembic_cfg.config_file_name = str(
+        plugin_path / "migrations" / "alembic.ini"
+    )
+    alembic_cfg.set_main_option(
+        "script_location", str(plugin_path / "migrations")
+    )
+    alembic_cfg.set_main_option(
+        "sqlalchemy.url", current_app.config["SQLALCHEMY_DATABASE_URI"]
+    )
+
+    command.upgrade(alembic_cfg, "head")
+
+    script = command.ScriptDirectory.from_config(alembic_cfg)
+    head_revision = script.get_current_head()
+
+    plugin.revision = head_revision
+
+    return head_revision
+
+
+def downgrade_plugin_migrations(plugin_path):
+    """
+    Downgrade plugin migrations to base.
+    """
+    plugin_path = Path(plugin_path)
+    manifest = PluginManifest.from_plugin_path(plugin_path)
+
+    alembic_cfg = Config()
+    alembic_cfg.config_file_name = str(
+        plugin_path / "migrations" / "alembic.ini"
+    )
+    alembic_cfg.set_main_option(
+        "script_location", str(plugin_path / "migrations")
+    )
+    alembic_cfg.set_main_option(
+        "sqlalchemy.url", current_app.config["SQLALCHEMY_DATABASE_URI"]
+    )
+
+    try:
+        command.downgrade(alembic_cfg, "base")
+    except Exception as e:
+        current_app.logger.warning(
+            f"Downgrade failed for plugin {manifest.id}: {e}"
+        )
+
+
+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
+
+
+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 install_plugin_files(files_path, installation_path):
+    """
+    Install plugin files.
+    """
+    files_path = Path(files_path)
+    installation_path = Path(installation_path)
+
+    installation_path.mkdir(parents=True, exist_ok=True)
+
+    if files_path.is_dir():
+        shutil.copytree(files_path, installation_path, dirs_exist_ok=True)
+    elif zipfile.is_zipfile(files_path):
+        shutil.unpack_archive(files_path, installation_path, format="zip")
+    else:
+        raise ValueError(
+            f"Plugin path '{files_path}' is not a valid zip file or a directory."
+        )
+
+    return installation_path
+
+
+def uninstall_plugin_files(plugin_path):
+    """
+    Uninstall plugin files.
+    """
+    plugin_path = Path(plugin_path)
+    if plugin_path.exists():
+        shutil.rmtree(plugin_path)
+        return True
+    return False