gOdoo-cli 0.7.0__py3-none-any.whl

godoo_cli/commands/bootstrap.py

@@ -0,0 +1,187 @@
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any, List
+
+from ..cli_common import CommonCLI
+from ..helpers.bootstrap import _install_py_reqs_by_odoo_cmd
+from ..helpers.odoo_files import get_addon_paths, get_odoo_module_paths
+from ..helpers.system import run_cmd
+
+CLI = CommonCLI()
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _add_default_argument(cmd_list: List[str], arg: str, arg_val: Any):
+    if not any([arg in s for s in cmd_list]):
+        cmd_list.append(f'{arg}="{arg_val}"')
+
+
+def _boostrap_command(
+    odoo_main_path: Path,
+    odoo_conf_path: Path,
+    addon_paths: List[Path],
+    workspace_addon_path: Path,
+    db_host: str,
+    db_filter: str,
+    db_name: str,
+    db_user: str,
+    db_password: str,
+    db_port: str,
+    extra_cmd_args: List[str] = None,
+    install_base: bool = True,
+    install_workspace_modules: bool = True,
+    multithread_worker_count: int = -1,
+    languages: str = "de_DE,en_US",
+) -> str:
+    """
+    Generate Bootstrap Command.
+
+    Parameters
+    ----------
+    odoo_main_path : Path
+        folder with odoo-bin
+    odoo_conf_path : Path
+        path to odoo.conf
+    addon_paths : List[Path]
+        odoo bin --addons-path
+    workspace_addon_path : Path
+        path to addons in dev repo
+    db_filter : str
+        db filter for odoo.conf
+    db_host : str
+        db hostname for odoo.conf
+    db_name : str
+        database name for odoo.conf
+    db_user : str
+        db user
+    db_password : str
+        db user password
+    db_port : str
+        db host port
+    extra_cmd_args : List[str], optional
+        extra args to pass to odoo-bin, by default None
+    install_base : bool, optional
+        install base,web, by default True
+    install_workspace_modules : bool, optional
+        install all modules found in workspace_path, by default True
+    multithread_worker_count : int, optional
+        cound of threads. if >0 cli also sets proxy mode flag, by default 9
+    languages : str, optional
+        languages to load, by default "de_DE,en_US"
+
+    Returns
+    -------
+    str
+        odoo-bin command
+    """
+    LOGGER.info("Generating Bootstrap Command")
+
+    odoo_conf_path.parent.mkdir(parents=True, exist_ok=True)
+
+    db_command = [
+        f"--database {db_name}",
+        f"--db_user {db_user}",
+        f"--db_password {db_password}",
+        f"--db_host {db_host}" if db_host else "",
+        f"--db_port {db_port}" if db_host else "",
+        f"--db-filter=^{db_filter}$",
+    ]
+
+    LOGGER.info("Getting Addon Paths")
+
+    workspace_addons = get_odoo_module_paths(workspace_addon_path)
+    if any([re.match(r"( |^)(-i|--init)", i) for i in extra_cmd_args]):
+        init_modules = []
+    else:
+        init_modules = ["base", "web"] if install_base else []
+        if install_workspace_modules and workspace_addons:
+            init_modules += [f.name for f in workspace_addons]
+    init_cmd = "--init " + ",".join(init_modules) if init_modules else ""
+
+    addon_paths = [str(p.absolute()) for p in addon_paths]
+    addon_paths = ", ".join(list(filter(None, addon_paths)))
+
+    base_cmds = [
+        str(odoo_main_path.absolute()) + "/odoo-bin",
+        init_cmd,
+        f"--config {str(odoo_conf_path.absolute())}",
+        "--save",
+        f"--load-language {languages}",
+        "--stop-after-init",
+        f"--addons-path '{addon_paths}'",
+    ]
+    odoo_cmd = base_cmds + db_command
+    if extra_cmd_args:
+        odoo_cmd += extra_cmd_args
+
+    _add_default_argument(cmd_list=odoo_cmd, arg="--data-dir", arg_val="/var/lib/odoo")
+
+    if multithread_worker_count == -1:
+        multithread_worker_count = os.cpu_count() or 0 + 1
+
+    if multithread_worker_count > 0:
+        odoo_cmd += [
+            "--proxy-mode",
+            f"--workers {multithread_worker_count}",
+        ]
+
+    odoo_cmd = list(filter(None, odoo_cmd))
+    return " ".join(odoo_cmd)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def bootstrap_odoo(
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+    db_filter=CLI.database.db_filter,
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_name=CLI.database.db_name,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+    extra_cmd_args=CLI.odoo_launch.extra_cmd_args,
+    multithread_worker_count=CLI.odoo_launch.multithread_worker_count,
+    languages=CLI.odoo_launch.languages,
+    no_install_base=CLI.odoo_launch.no_install_base,
+    no_install_workspace_modules=CLI.odoo_launch.no_install_workspace_modules,
+):
+    """Bootstrap Odoo."""
+
+    addon_paths = get_addon_paths(
+        odoo_main_repo=odoo_main_path,
+        workspace_addon_path=workspace_addon_path,
+        thirdparty_addon_path=thirdparty_addon_path,
+    )
+
+    cmd_string = _boostrap_command(
+        odoo_main_path=odoo_main_path,
+        odoo_conf_path=odoo_conf_path,
+        workspace_addon_path=workspace_addon_path,
+        addon_paths=addon_paths,
+        db_host=db_host,
+        db_name=db_name,
+        db_filter=db_filter,
+        db_user=db_user,
+        db_password=db_password,
+        db_port=db_port,
+        extra_cmd_args=extra_cmd_args,
+        install_base=not no_install_base,
+        install_workspace_modules=not no_install_workspace_modules,
+        multithread_worker_count=multithread_worker_count,
+        languages=languages,
+    )
+
+    # Always update Pip reqs regardless of --no-update-source
+    _install_py_reqs_by_odoo_cmd(addon_paths=addon_paths, odoo_bin_cmd=cmd_string)
+
+    LOGGER.info("Launching Bootstrap Commandline")
+    ret = run_cmd(cmd_string).returncode
+    if ret != 0:
+        LOGGER.error("Odoo-Bin Returned %d", ret)
+    return CLI.returner(ret)

godoo_cli/commands/config.py

@@ -0,0 +1,43 @@
+"""
+Set odoo.conf variables
+"""
+import logging
+from configparser import ConfigParser
+from pathlib import Path
+from typing import List
+
+import typer
+
+from ..cli_common import CommonCLI
+
+CLI = CommonCLI()
+LOGGER = logging.getLogger(__name__)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def set_odoo_config(
+    options: List[str] = typer.Argument(..., help="odoo.conf options by key=value"),
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+):
+    """
+    Set odoo.conf values.
+    """
+    conf_path = Path(odoo_conf_path)
+    odoo_conf = ConfigParser()
+    odoo_conf.read(conf_path)
+    LOGGER.info("Setting Odoo Conf Options for Stage")
+    custom_opts = {}
+    for op in options:
+        if "=" not in op:
+            LOGGER.error("Cannot parse Option: '%s' --> missing = sign", op)
+            raise ValueError("")
+        op_split = op.split("=")
+        custom_opts[op_split[0]] = op_split[1]
+    LOGGER.debug("Writing Conf Options: %s", custom_opts)
+    if "options" not in odoo_conf:
+        odoo_conf.add_section("options")
+        odoo_conf["options"] = {}
+    odoo_conf["options"].update(custom_opts)
+    conf_path.touch(exist_ok=True)
+    odoo_conf.write(conf_path.open("w"))

godoo_cli/commands/db/__init__.py

@@ -0,0 +1 @@
+from .cli import db_cli_app

godoo_cli/commands/db/cli.py

@@ -0,0 +1,18 @@
+import typer
+
+from .connection import login_db
+from .passwords import set_passwords
+from .query import query_database
+
+
+def db_cli_app():
+    app = typer.Typer(
+        no_args_is_help=True,
+        help="Functions that directly act on the Postgres DB",
+    )
+
+    app.command()(set_passwords)
+    app.command("login")(login_db)
+    app.command("query")(query_database)
+
+    return app

godoo_cli/commands/db/connection.py

@@ -0,0 +1,94 @@
+import logging
+import subprocess
+from contextlib import contextmanager
+from dataclasses import dataclass
+
+import psycopg2
+
+from ...cli_common import CommonCLI
+from ...helpers.system import run_cmd
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+@CLI.arg_annotator
+def login_db(
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_name=CLI.database.db_name,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+):
+    """Login Interactive psql CLI using provided credentials"""
+    command = ["psql", f"-h{db_host}", f"-p{db_port}", f"-U{db_user}", f"-d{db_name}"]
+    subprocess.run(command, env={"PGPASSWORD": db_password})
+
+
+@dataclass
+class DBConnection:
+    db_name: str
+    hostname: str
+    username: str
+    password: str
+    port: int = 0
+    conn_timeout: int = 5
+
+    def get_connection(self):
+        LOGGER.debug(
+            "Connecting to DB: '%s:%s' U='%s' P='%s' D='%s'",
+            self.hostname,
+            self.port,
+            self.username,
+            self.password,
+            self.db_name,
+        )
+        return psycopg2.connect(
+            host=self.hostname,
+            port=self.port or None,
+            user=self.username,
+            password=self.password,
+            dbname=self.db_name,
+            connect_timeout=self.conn_timeout,
+        )
+
+    @contextmanager
+    def connect(self):
+        connection = self.get_connection()
+        cr = connection.cursor()
+        try:
+            yield cr
+            LOGGER.debug("Committing DB cursor")
+            connection.commit()
+        except Exception as e:
+            LOGGER.warning("Rolling Back DB cursor. Got Exception: %s", e)
+            connection.rollback()
+            raise e
+        finally:
+            LOGGER.debug("Closing DB connection")
+            cr.close()
+            connection.close()
+
+    def run_psql_shell_command(self, command: str, **kwargs):
+        """Run a psql command using the provided credentials. {} in the command will get templated with the connection string"""
+        LOGGER.debug("Running PSQL Command: %s", command)
+        arg_list = []
+        if h := self.hostname:
+            arg_list += ["-h", h]
+        if p := self.port:
+            arg_list += ["-p", p]
+        if u := self.username:
+            arg_list += ["-U", u]
+        if d := self.db_name:
+            arg_list += ["-d", d]
+        command_env = {}
+        if p := self.password:
+            command_env["PGPASSWORD"] = p
+
+        arg_str = " ".join(arg_list)
+        if "{}" in command:
+            command = command.format(arg_str)
+        else:
+            command += " " + " ".join(arg_list)
+
+        return run_cmd(command, env=command_env, **kwargs)

godoo_cli/commands/db/passwords.py

@@ -0,0 +1,56 @@
+import logging
+
+import typer
+from passlib.context import CryptContext
+
+from ...cli_common import CommonCLI
+from ...helpers.cli import check_dangerous_command
+from .connection import DBConnection
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+def _hash_odoo_password(password: str) -> str:
+    """Hash Password for Odoo
+
+    Parameters
+    ----------
+    password : str
+        Password to hash
+
+    Returns
+    -------
+    str
+        Hashed Password
+    """
+    return CryptContext(schemes=["pbkdf2_sha512", "md5_crypt"]).encrypt(password)
+
+
+@CLI.arg_annotator
+def set_passwords(
+    new_password: str = typer.Argument(..., help="Password to set for all users"),
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_name=CLI.database.db_name,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+):
+    """Set Login Password for all Users."""
+
+    check_dangerous_command()
+
+    connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+    hashed_pw = _hash_odoo_password(new_password)
+    with connection.connect() as conn:
+        try:
+            conn.execute(f"UPDATE res_users SET password='{hashed_pw}'")
+        except Exception:
+            raise typer.Exit(1)
+    LOGGER.info("Password for all users set to: '%s'", new_password)

godoo_cli/commands/db/query.py

@@ -0,0 +1,41 @@
+import logging
+
+import typer
+
+from ...cli_common import CommonCLI
+from ...helpers.cli import check_dangerous_command
+from .connection import DBConnection
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+@CLI.arg_annotator
+def query_database(
+    query: str = typer.Argument(..., help="SQL Query"),
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_name=CLI.database.db_name,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+):
+    """Run a Query against the database."""
+
+    check_dangerous_command()
+    # regex to check if SQL query contains writing command
+
+    connection = DBConnection(
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+        db_name=db_name,
+    )
+    with connection.connect() as cursor:
+        try:
+            cursor.execute(query)
+            rows = cursor.fetchall()
+            for row in rows:
+                print("\t".join(row))  # pylint: disable=print-used
+        except Exception:
+            raise typer.Exit(1)