vortex-cli 3.0.0__py3-none-any.whl

vortex/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from vortex.main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

vortex/colour.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Colour(Enum):
+    NORMAL = "\033[m"
+    RED = "\033[41m"
+    BOLD = "\033[1m"
+    GREEN = "\033[42m"
+    YELLOW = "\033[43;30m"
+
+    @staticmethod
+    def highlight(text: str, colour: Colour, replace_in: str | None = None) -> str:
+        highlighted_txt = f"{colour.value}{text}{Colour.NORMAL.value}"
+        if replace_in:
+            highlighted_txt = replace_in.replace(text, highlighted_txt)
+        return highlighted_txt

vortex/commands/clean.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import logging
+import shutil
+
+from vortex.workspace import Workspace
+
+
+logger = logging.getLogger("vortex")
+
+
+def clean(workspace: Workspace) -> int:
+    app_dirs = workspace.listdir(strict=False)
+    ret = 0
+    if app_dirs:
+        with workspace.exclusive_lock():
+            for app_dir in app_dirs:
+                shutil.rmtree(app_dir)
+                logger.info(f"Deleted directory '{app_dir}'")
+            ret = workspace.update_vscode_settings()
+    return ret

vortex/commands/clone.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import asyncio
+import binascii
+import logging
+import xml.etree.ElementTree as ET
+import zlib
+from pathlib import Path
+from typing import Any
+
+from vortex import util
+from vortex.models import DesignObject
+from vortex.models import DesignType
+from vortex.models import JavaClassVersion
+from vortex.models import PuakmaApplication
+from vortex.models import PuakmaServer
+from vortex.spinner import Spinner
+from vortex.workspace import Workspace
+
+logger = logging.getLogger("vortex")
+
+
+def clone(
+    workspace: Workspace,
+    server: PuakmaServer,
+    app_ids: list[int],
+    *,
+    get_resources: bool = False,
+    open_urls: bool = False,
+    reclone: bool = False,
+) -> int:
+    if reclone:
+        app_ids.extend(app.id for app in workspace.listapps(server))
+
+    with (
+        workspace.exclusive_lock(),
+        Spinner(f"Cloning {app_ids}..."),
+    ):
+        return asyncio.run(
+            _aclone_apps(workspace, server, app_ids, get_resources, open_urls)
+        )
+
+
+async def _aclone_apps(
+    workspace: Workspace,
+    server: PuakmaServer,
+    app_ids: list[int],
+    get_resources: bool,
+    open_urls: bool,
+) -> int:
+    tasks = []
+    async with server as s:
+        await s.server_designer.ainitiate_connection()
+        logger.info(f"Connected to {s.host}")
+
+        for app_id in app_ids:
+            task = asyncio.create_task(_aclone_app(workspace, s, app_id, get_resources))
+            tasks.append(task)
+
+        ret = 0
+        for done in asyncio.as_completed(tasks):
+            try:
+                app, _ret = await done
+                if open_urls and app:
+                    util.open_app_urls(app)
+                ret |= _ret
+            except (KeyboardInterrupt, Exception) as e:
+                for task in tasks:
+                    task.cancel()
+                raise e
+            except asyncio.CancelledError:
+                logger.error("Operation Cancelled")
+                for task in tasks:
+                    task.cancel()
+                ret = 1
+                break
+        else:
+            ret |= workspace.update_vscode_settings()
+    return ret
+
+
+async def _aclone_app(
+    workspace: Workspace,
+    server: PuakmaServer,
+    app_id: int,
+    get_resources: bool,
+) -> tuple[PuakmaApplication | None, int]:
+    """Clone a Puakma Application into a newly created directory"""
+
+    logger.info(f"Cloning [{app_id}] from {server.host}...")
+
+    app_xml, _obj_rows = await asyncio.gather(
+        server.app_designer.aget_application_xml(app_id),
+        PuakmaApplication.afetch_design_objects(server, app_id, get_resources),
+    )
+
+    try:
+        app, app_ele = _parse_app_xml(server, app_xml, app_id)
+    except (ValueError, KeyError) as e:
+        logger.error(e)
+        return None, 1
+
+    eles = app_ele.findall("designElement", namespaces=None)
+    objs = _aparse_design_objs(_obj_rows, app)
+    _match_and_validate_design_objs(objs, eles)
+
+    app.design_objects = objs
+    app_dir = workspace.mkdir(app, True)
+    try:
+        logger.info(f"Saving {len(objs)} ({len(eles)}) Design Objects [{app_id}]...")
+        await asyncio.to_thread(_save_objs, workspace, objs)
+    except asyncio.CancelledError:
+        util.rmtree(app_dir)
+        return None, 1
+
+    logger.info(f"Successfully cloned {app} into '{app_dir.name}'")
+
+    return app, 0
+
+
+def _save_objs(workspace: Workspace, objs: list[DesignObject]) -> None:
+    for obj in objs:
+        obj.save(workspace)
+
+
+def _aparse_design_objs(
+    objs: list[dict[str, Any]], app: PuakmaApplication
+) -> list[DesignObject]:
+    ret: list[DesignObject] = []
+    for obj in objs:
+        design_type_id = int(obj["type"])
+        name = obj["name"]
+        id_ = int(obj["id"])
+        try:
+            type_ = DesignType(design_type_id)
+        except ValueError:
+            logger.debug(
+                f"Skipped Design Object '{name}' [{obj['id']}]: "
+                f"Invalid Design Type [{design_type_id}]"
+            )
+            continue
+        ret.append(
+            DesignObject(
+                id_,
+                name,
+                app,
+                type_,
+                obj["ctype"],
+                obj["data"],
+                obj["src"],
+            )
+        )
+    return ret
+
+
+def _parse_app_xml(
+    server: PuakmaServer, app_xml: ET.Element, app_id: int
+) -> tuple[PuakmaApplication, ET.Element]:
+    app_ele = app_xml.find("puakmaApplication", namespaces=None)
+    if not app_ele:
+        raise ValueError(f"Application [{app_id}] does not exist")
+
+    java_version_ele = app_xml.find('.//sysProp[@name="java.class.version"]')
+    if java_version_ele is None or java_version_ele.text is None:
+        raise ValueError("Java class version not specified")
+    major, minor = (int(v) for v in java_version_ele.text.split(".", maxsplit=1))
+    version: JavaClassVersion = (major, minor)
+    app = PuakmaApplication(
+        id=int(app_ele.attrib["id"]),
+        name=app_ele.attrib["name"],
+        group=app_ele.attrib["group"],
+        inherit_from=app_ele.attrib["inherit"],
+        template_name=app_ele.attrib["template"],
+        java_class_version=version,
+        host=server.host,
+    )
+    return app, app_ele
+
+
+def _validate_crc32_checksum(obj: DesignObject, ele: dict[str, str]) -> bool:
+    data = obj.design_source if obj.do_save_source else obj.design_data
+    crc32_xml_key = "sourceCrc32" if obj.do_save_source else "dataCrc32"
+    crc32_checksum = int(ele.get(crc32_xml_key, 0))
+    try:
+        return crc32_checksum == zlib.crc32(data)
+    except (TypeError, binascii.Error):
+        return False
+
+
+def _match_and_validate_design_objs(
+    design_objs: list[DesignObject],
+    design_elements: list[ET.Element],
+) -> None:
+    design_objs_eles = {int(ele.attrib["id"]): ele for ele in design_elements}
+    for obj in reversed(design_objs):
+        ele = design_objs_eles.get(obj.id)
+        if ele is not None:
+            obj.is_jar_library = ele.attrib.get("library", "false") == "true"
+
+            package = ele.attrib.get("package", None)
+            obj.package_dir = Path(*package.split(".")) if package else None
+
+            open_action_param_ele = ele.find('.//designParam[@name="OpenAction"]')
+            if open_action_param_ele is not None:
+                obj.open_action = open_action_param_ele.attrib["value"]
+
+            save_action_param_ele = ele.find('.//designParam[@name="SaveAction"]')
+            if save_action_param_ele is not None:
+                obj.save_action = save_action_param_ele.attrib["value"]
+
+            parent_page_param_ele = ele.find('.//designParam[@name="ParentPage"]')
+            if parent_page_param_ele is not None:
+                obj.parent_page = parent_page_param_ele.attrib["value"]
+
+        if ele is None or not _validate_crc32_checksum(obj, ele.attrib):
+            design_objs.remove(obj)
+            logger.warning(
+                f"Unable to validate Design Object {obj}. It will not be saved."
+            )

vortex/commands/code.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import logging
+
+from vortex import util
+from vortex.workspace import Workspace
+
+logger = logging.getLogger("vortex")
+
+
+def code(workspace: Workspace, args: list[str]) -> int:
+    if not workspace.code_workspace_file.exists() and "--help" not in args:
+        logger.error(f"{workspace.code_workspace_file} does not exist")
+        return 1
+
+    args.insert(0, str(workspace.code_workspace_file))
+    cmd = "code"
+    try:
+        return util.execute_cmd(cmd, args)
+    except FileNotFoundError:
+        logger.error(f"VSCode '{cmd}' command not found. Check system PATH.")
+        return 1

vortex/commands/config.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from vortex import util
+from vortex.workspace import SAMPLE_CONFIG
+from vortex.workspace import Workspace
+
+
+def config(
+    workspace: Workspace,
+    server_name: str | None,
+    *,
+    init: bool = False,
+    print_sample: bool = False,
+    update_vscode_settings: bool = False,
+    reset_vscode_settings: bool = False,
+    output_config_path: bool = False,
+    output_workspace_path: bool = False,
+) -> int:
+    if print_sample:
+        print(SAMPLE_CONFIG, end="")
+        return 0
+    if update_vscode_settings or reset_vscode_settings:
+        return workspace.update_vscode_settings(reset_vscode_settings)
+    if output_config_path:
+        print(workspace.config_file)
+        return 0
+    if output_workspace_path:
+        print(workspace.path)
+        return 0
+    if not init:
+        workspace.print_info()
+        util.print_row_break(" Server Info ")
+        workspace.print_server_config_info(server_name)
+    return 0

vortex/commands/copy.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from vortex.models import DesignObject
+from vortex.models import DesignObjectAmbiguousError
+from vortex.models import DesignObjectNotFound
+from vortex.models import PuakmaApplication
+from vortex.models import PuakmaServer
+from vortex.spinner import Spinner
+from vortex.util import render_objects
+from vortex.workspace import Workspace
+
+
+logger = logging.getLogger("vortex")
+
+
+def copy(
+    workspace: Workspace,
+    server: PuakmaServer,
+    obj_ids: list[int],
+    to_app_ids: list[int],
+    copy_params: bool,
+) -> int:
+    workspace_apps = workspace.listapps(server)
+    to_apps = [app for app in workspace_apps if app.id in to_app_ids]
+    if not to_apps:
+        logger.error(f"No cloned application found with ID {to_app_ids}")
+        return 1
+    matches = [
+        obj for app in workspace_apps for obj in app.design_objects if obj.id in obj_ids
+    ]
+    if not matches or len(matches) != len(obj_ids):
+        logger.error(
+            f"Unable to match Design Objects {obj_ids} in {[o.id for o in matches]}"
+        )
+        return 1
+
+    print(f"The following Objects will be copied to {[str(app) for app in to_apps]}:\n")
+    render_objects(matches, show_params=copy_params)
+    if input("\n[Y/y] to continue:") not in ["Y", "y"]:
+        return 1
+
+    with (
+        workspace.exclusive_lock(),
+        Spinner("Copying..."),
+    ):
+        return asyncio.run(
+            _acopy_objects(workspace, server, to_apps, matches, copy_params)
+        )
+
+
+async def _acopy_objects(
+    workspace: Workspace,
+    server: PuakmaServer,
+    to_apps: list[PuakmaApplication],
+    objs_to_copy: list[DesignObject],
+    copy_params: bool,
+) -> int:
+    async with server:
+        await server.server_designer.ainitiate_connection()
+        logger.info(f"Connected to {server.host}")
+        ret = 0
+        tasks = []
+
+        for to_app in to_apps:
+            for obj_to_copy in objs_to_copy:
+                if to_app.id == obj_to_copy.app.id:
+                    _err = f"Failed to copy {obj_to_copy} to {to_app}: "
+                    logger.error(f"{_err} {obj_to_copy} already belongs to {to_app}")
+                    ret |= 1
+                    continue
+
+                obj_to_copy.app = to_app
+
+                task = asyncio.create_task(
+                    _acopy_obj(workspace, server, obj_to_copy, copy_params)
+                )
+                tasks.append(task)
+
+        for result in asyncio.as_completed(tasks):
+            try:
+                ret |= await result
+            except (Exception, asyncio.CancelledError) as e:
+                logger.error(f"Operation Cancelled: {e}")
+                for task in tasks:
+                    task.cancel()
+                ret = 1
+                break
+
+        for app in to_apps:
+            workspace.mkdir(app)
+
+    return ret
+
+
+async def _acopy_obj(
+    workspace: Workspace,
+    server: PuakmaServer,
+    obj: DesignObject,
+    copy_params: bool,
+) -> int:
+    _err_msg = f"Failed to copy {obj} to {obj.app.id}:"
+
+    try:
+        indx, existing_obj = obj.app.lookup_design_obj(obj.name)
+    except DesignObjectNotFound:
+        # Create a new object
+        obj.id = -1
+        ok = await obj.acreate(server.app_designer)
+        if not ok:
+            logger.error(f"{_err_msg} Unable to create Design Object {obj}")
+            return 1
+
+        if copy_params:
+            await obj.acreate_params(server.app_designer)
+
+        obj.app.design_objects.append(obj)
+    except DesignObjectAmbiguousError as e:
+        logger.error(f"{_err_msg } {e}")
+        return 1
+    else:
+        # Update the existing object
+        logger.info(
+            f"Design Object {obj} already exists in {obj.app}. "
+            "Only the Design data/source will be updated."
+        )
+        obj.id = existing_obj.id
+        obj.app.design_objects[indx].design_data = obj.design_data
+        obj.app.design_objects[indx].design_source = obj.design_source
+
+    tasks = []
+    if obj.do_save_source:
+        upload_src_task = asyncio.create_task(
+            obj.aupload(server.download_designer, True)
+        )
+        tasks.append(upload_src_task)
+    upload_data_task = asyncio.create_task(obj.aupload(server.download_designer))
+    tasks.append(upload_data_task)
+
+    ret = 0
+    for result in asyncio.as_completed(tasks):
+        try:
+            ok = await result
+            ret |= 0 if ok else 1
+        except (Exception, asyncio.CancelledError) as e:
+            for task in tasks:
+                task.cancel()
+            raise e
+
+    try:
+        await asyncio.to_thread(obj.save, workspace)
+    except OSError as e:
+        logger.error(e.strerror)
+        ret = 1
+
+    return ret

vortex/commands/delete.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from vortex.colour import Colour
+from vortex.models import DesignObject
+from vortex.models import PuakmaServer
+from vortex.soap import AppDesigner
+from vortex.util import render_objects
+from vortex.workspace import Workspace
+
+logger = logging.getLogger("vortex")
+
+
+def delete(
+    workspace: Workspace,
+    server: PuakmaServer,
+    obj_ids: list[int],
+) -> int:
+    objs = []
+    apps = []
+    for app in workspace.listapps(server):
+        for obj in app.design_objects:
+            if obj.id in obj_ids:
+                objs.append(obj)
+                apps.append(app)
+
+    if not objs:
+        logger.error(f"No cloned Design Object found with ID {obj_ids}")
+        return 1
+
+    _deleted = Colour.highlight("deleted", Colour.RED)
+    print(f"The following Design Objects will be {_deleted}:\n")
+    render_objects(objs)
+    if input("\n[Y/y] to continue:") not in ["Y", "y"]:
+        return 1
+
+    with workspace.exclusive_lock():
+        ret = asyncio.run(_adelete_objs(workspace, server, objs))
+        for app in apps:
+            workspace.mkdir(app)
+        return ret
+
+
+async def _adelete_objs(
+    workspace: Workspace, server: PuakmaServer, objs: list[DesignObject]
+) -> int:
+    async with server as s:
+        await s.server_designer.ainitiate_connection()
+        logger.info(f"Connected to {s.host}")
+        tasks = []
+        for obj in objs:
+            task = asyncio.create_task(_adelete(workspace, s.app_designer, obj))
+            tasks.append(task)
+        ret = 0
+        for done in asyncio.as_completed(tasks):
+            try:
+                ret |= await done
+            except (asyncio.CancelledError, Exception) as e:
+                for task in tasks:
+                    task.cancel()
+                raise e
+        return ret
+
+
+async def _adelete(
+    workspace: Workspace,
+    app_designer: AppDesigner,
+    obj: DesignObject,
+) -> int:
+    await obj.adelete(app_designer)
+    obj.app.design_objects.remove(obj)
+    path = obj.design_path(workspace).path
+    try:
+        path.unlink()
+        logger.info(f"Deleted Local File: {path}")
+    except FileNotFoundError as e:
+        err = (
+            f"Unable to delete local file because it does not exist: {path}\n"
+            "Hint: It may have already been deleted or saved without file extension."
+        )
+        logger.warning(f"{e}: {err}")
+    return 0

vortex/commands/find.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from vortex.models import DesignType
+from vortex.models import PuakmaServer
+from vortex.util import render_objects
+from vortex.workspace import Workspace
+
+
+def find(
+    workspace: Workspace,
+    server: PuakmaServer,
+    name: str,
+    *,
+    app_ids: list[int] | None = None,
+    design_types: list[DesignType] | None = None,
+    exclude_resources: bool = True,
+    show_params: bool = False,
+    show_ids_only: bool = False,
+    fuzzy_search: bool = True,
+) -> int:
+    apps = (
+        app
+        for app in workspace.listapps(server)
+        if (not app_ids or (app.id in app_ids))
+    )
+
+    if exclude_resources:
+        design_types = [t for t in DesignType if t != DesignType.RESOURCE]
+
+    matches = (
+        obj
+        for app in apps
+        for obj in app.design_objects
+        if (
+            (fuzzy_search and name.lower() in obj.name.lower())
+            or (name.lower() == obj.name.lower())
+        )
+        and (not design_types or obj.design_type in design_types)
+    )
+    if show_ids_only:
+        for obj in matches:
+            print(obj.id)
+    else:
+        render_objects(matches, show_params=show_params)
+
+    return 0

vortex/commands/grep.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import functools
+import re
+
+from vortex.colour import Colour
+from vortex.models import DesignObject
+from vortex.models import DesignType
+from vortex.models import PuakmaServer
+from vortex.workspace import Workspace
+
+
+def grep(
+    workspace: Workspace,
+    server: PuakmaServer,
+    pattern: str,
+    *,
+    app_ids: list[int] | None = None,
+    design_types: list[DesignType] | None = None,
+    output_paths: bool = False,
+    exclude_resources: bool = True,
+) -> int:
+    if exclude_resources:
+        design_types = [t for t in DesignType if t != DesignType.RESOURCE]
+
+    regex = re.compile(pattern.encode())
+    apps = (
+        app for app in workspace.listapps(server) if (not app_ids or app.id in app_ids)
+    )
+    objs = [
+        obj
+        for app in apps
+        for obj in app.design_objects
+        if (not obj.is_jar_library)
+        and (not design_types or obj.design_type in design_types)
+    ]
+
+    _output_match = functools.partial(_output, workspace, output_path=output_paths)
+
+    for obj in sorted(objs, key=lambda obj: obj.name):
+        bytes_to_search = obj.design_source if obj.do_save_source else obj.design_data
+        match = re.search(regex, bytes_to_search)
+        _output_match(match, obj) if match else None
+
+    return 0
+
+
+def _output(
+    workspace: Workspace,
+    match: re.Match[bytes],
+    obj: DesignObject,
+    *,
+    output_path: bool,
+) -> None:
+    try:
+        text = match.string.decode()
+    except UnicodeDecodeError:
+        # Found a binary resource or jar library etc., skip
+        return
+    line_indx = text.count("\n", 0, match.start())
+    line_no = line_indx + 1
+    if output_path:
+        print(f"{obj.design_path(workspace)}:{line_no}")
+    else:
+        matched_text = match.group().decode()
+        line = text.splitlines()[line_indx].strip()
+        new_text = Colour.highlight(matched_text, Colour.RED, line)
+        print(f"{Colour.highlight(obj.file_name, Colour.BOLD)}:{line_no}:{new_text}")