app_data.py

Go to the documentation of this file.

"""!
********************************************************************************
@file   app_data.py
@brief  Data module (path related constants and functions)
********************************************************************************
"""
 
import sys
import os
import logging
import enum
from typing import Any, Optional, TYPE_CHECKING
from pathlib import Path
import base64
import socket
import locale
import copy
import subprocess
import platform
import threading
import serial  # serial.Serial need this
from serial.tools.list_ports import comports
from serial.tools.list_ports_common import ListPortInfo
if TYPE_CHECKING:
    from Source.Controller.main_window import MainWindow
 
if platform.system() == 'Windows':
    import win32crypt
 
from Source.version import __title__  # pylint: disable=wrong-import-position
from Source.Util.gui_toolkit import SETTINGS, input_dialog, BYTE_ARRAY  # pylint: disable=wrong-import-position
 
log = logging.getLogger(__title__)
 
 
def resource_path(s_relative_path: str) -> str:
    """!
    @brief Returns the absolute path to a resource given by a relative path depending on the environment (EXE or Python)
    @param s_relative_path : the relative path to a file or directory
    @return absolute path to the resource
    """
    if hasattr(sys, "_MEIPASS"):  # check without function call for mypy
        # PyInstaller creates a temp folder and stores path in _MEIPASS
        s_base_path = sys._MEIPASS
    else:
        s_base_path = os.path.abspath("../")
    s_resource_path = os.path.join(s_base_path, s_relative_path)
    log.debug("Resource Path (relative %s): %s", s_relative_path, s_resource_path)
    return s_resource_path
 
 
def thread_loop(obj: Any, thread_name: str) -> None:
    """!
    @brief loop for threads.
    @param obj : object of thread class
    @param thread_name : thread name
    """
    threading.current_thread().name = thread_name
    try:
        while True:
            obj.loop()
    except Exception:
        exc_type, exc_obj, exc_tb = sys.exc_info()
        if exc_tb is not None:
            fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
            lineno = exc_tb.tb_lineno
        else:
            fname = "None"
            lineno = 0
        s_err = f"Thread {thread_name}: {exc_type} {fname} {exc_obj} {lineno}"
        log.error(s_err)
        obj.ui.qt_exception_hook.exception_caught.emit(s_err)
        sys.exit(1)
 
 
def reset_config_dialog(ui: "MainWindow | None") -> tuple[bool, bool | None]:
    """!
    @brief Show reset configuration dialog. Enter reset PW to reset configuration.
    @param ui : main window controller
    @return status if PW is correct
    """
    l_reset_title = ["Reset", "Zurücksetzen"]
    l_reset_text = ["Enter reset code to reset configuration.", "Reset-Code eingeben, um die Konfiguration zurückzusetzen."]
    if ui:
        reset_title = ui.model.c_language.get_language_text(l_reset_title)
        reset_text = ui.model.c_language.get_language_text(l_reset_text)
    else:
        reset_title = l_reset_title[0]
        reset_text = l_reset_text[0]
    password, ok = input_dialog(ui, reset_title, reset_text, password_input=True, icon=ICON_APP)
    b_reset = bool(ok and password.isdigit() and (base64.b64encode(password.encode("utf-8")) == RESET_CODE))
    if b_reset:
        clear_settings()
    return b_reset, ok
 
 
def get_computer_name() -> str:
    """!
    @brief Get computer name.
    @return computer name
    """
    try:
        hostname = socket.gethostname()
    except BaseException:
        hostname = ""
    return hostname
 
 
def open_explorer(explorer_path: str, b_open_input: bool = False) -> None:
    """!
    @brief Open explorer.
    @param explorer_path : path to open
    @param b_open_input : open explorer into folder
    """
    s_open_folder = explorer_path.replace("/", "\\")
    mode = "explorer " if b_open_input else r"explorer /select, "
    with subprocess.Popen(mode + s_open_folder):
        pass
 
 
def check_serial_device(s_com_port: str) -> bool:
    """!
    @brief Check if serial device is present at this COM port
    @param s_com_port : COM port to check
    @return return display status: [True] serial device at this COM port available; [False] not available
    """
    b_present = False
    try:
        device = serial.Serial(s_com_port)
    except BaseException:
        b_present = False
    else:
        device.close()
        b_present = True
    return b_present
 
 
def get_serial_ports() -> list[ListPortInfo]:
    """!
    @brief Check if serial device is present at this COM port
    @return return list of present serial ports
    """
    l_present_ports = sorted(comports())  # list of objects with port class
    return l_present_ports
 
 
# Files and Paths
# https://icons8.com/icons/fluency-systems-regular
# https://compresspng.com/
# https://ezgif.com/optimize
# https://compress-image.net/compress-image-online/compress-ico
# https://www.zamzar.com/compress-bmp/
# General Icon and Images
ICON_APP_PATH = "Resources/app.ico"
ICON_APP_FAVICON_PATH = "Resources/favicon.ico"
ICON_APP = resource_path(ICON_APP_PATH)
ICON_LOCK_LIGHT = resource_path("Resources/Icon/lock_light.png")
ICON_LOCK_DARK = resource_path("Resources/Icon/lock_dark.png")
IMG_SPLASH = resource_path("Resources/splash.gif")
# Menu Prints
ICON_STATUS_LIGHT = resource_path("Resources/Icon/status_light.png")
ICON_STATUS_DARK = resource_path("Resources/Icon/status_dark.png")
ICON_OPEN_FOLDER_LIGHT = resource_path("Resources/Icon/open_folder_light.png")
ICON_OPEN_FOLDER_DARK = resource_path("Resources/Icon/open_folder_dark.png")
ICON_COMBINE_LIGHT = resource_path("Resources/Icon/combine_light.png")
ICON_COMBINE_DARK = resource_path("Resources/Icon/combine_dark.png")
ICON_PRINT_FILE_LIGHT = resource_path("Resources/Icon/print_file_light.png")
ICON_PRINT_FILE_DARK = resource_path("Resources/Icon/print_file_dark.png")
ICON_PRINT_PREVIEW_LIGHT = resource_path("Resources/Icon/print_preview_light.png")
ICON_PRINT_PREVIEW_DARK = resource_path("Resources/Icon/print_preview_dark.png")
ICON_REPORT_LIGHT = resource_path("Resources/Icon/report_light.png")
ICON_REPORT_DARK = resource_path("Resources/Icon/report_dark.png")
# Menu Configuration
ICON_USER_LIGHT = resource_path("Resources/Icon/user_light.png")
ICON_USER_DARK = resource_path("Resources/Icon/user_dark.png")
ICON_USER_EDIT_LIGHT = resource_path("Resources/Icon/user_edit_light.png")
ICON_USER_EDIT_DARK = resource_path("Resources/Icon/user_edit_dark.png")
ICON_USER_IMPORT_LIGHT = resource_path("Resources/Icon/user_import_light.png")
ICON_USER_IMPORT_DARK = resource_path("Resources/Icon/user_import_dark.png")
ICON_USER_EXPORT_LIGHT = resource_path("Resources/Icon/user_export_light.png")
ICON_USER_EXPORT_DARK = resource_path("Resources/Icon/user_export_dark.png")
ICON_USER_RESET_LIGHT = resource_path("Resources/Icon/user_reset_light.png")
ICON_USER_RESET_DARK = resource_path("Resources/Icon/user_reset_dark.png")
ICON_ARTICLES_LIGHT = resource_path("Resources/Icon/articles_light.png")
ICON_ARTICLES_DARK = resource_path("Resources/Icon/articles_dark.png")
ICON_ARTICLES_EDIT_LIGHT = resource_path("Resources/Icon/articles_edit_light.png")
ICON_ARTICLES_EDIT_DARK = resource_path("Resources/Icon/articles_edit_dark.png")
ICON_ARTICLES_IMPORT_LIGHT = resource_path("Resources/Icon/articles_import_light.png")
ICON_ARTICLES_IMPORT_DARK = resource_path("Resources/Icon/articles_import_dark.png")
ICON_ARTICLES_EXPORT_LIGHT = resource_path("Resources/Icon/articles_export_light.png")
ICON_ARTICLES_EXPORT_DARK = resource_path("Resources/Icon/articles_export_dark.png")
ICON_ARTICLES_RESET_LIGHT = resource_path("Resources/Icon/articles_reset_light.png")
ICON_ARTICLES_RESET_DARK = resource_path("Resources/Icon/articles_reset_dark.png")
ICON_CHANGE_FOLDER_LIGHT = resource_path("Resources/Icon/change_folder_light.png")
ICON_CHANGE_FOLDER_DARK = resource_path("Resources/Icon/change_folder_dark.png")
ICON_PRINTER_LIGHT = resource_path("Resources/Icon/printer_light.png")
ICON_PRINTER_DARK = resource_path("Resources/Icon/printer_dark.png")
ICON_PAPER_LIGHT = resource_path("Resources/Icon/paper_light.png")
ICON_PAPER_DARK = resource_path("Resources/Icon/paper_dark.png")
# Menu Settings
ICON_SOUND_LIGHT = resource_path("Resources/Icon/sound_light.png")
ICON_SOUND_DARK = resource_path("Resources/Icon/sound_dark.png")
ICON_SOUND_MUTE_LIGHT = resource_path("Resources/Icon/sound_mute_light.png")
ICON_SOUND_MUTE_DARK = resource_path("Resources/Icon/sound_mute_dark.png")
ICON_THEME_LIGHT = resource_path("Resources/Icon/theme_light.png")
ICON_THEME_DARK = resource_path("Resources/Icon/theme_dark.png")
ICON_LANGUAGE_LIGHT = resource_path("Resources/Icon/language_light.png")
ICON_LANGUAGE_DARK = resource_path("Resources/Icon/language_dark.png")
ICON_LANGUAGE_ENGLISH = resource_path("Resources/Icon/language_english.png")
ICON_LANGUAGE_GERMAN = resource_path("Resources/Icon/language_german.png")
ICON_LOG_LIGHT = resource_path("Resources/Icon/log_light.png")
ICON_LOG_DARK = resource_path("Resources/Icon/log_dark.png")
# Menu Help
ICON_HELP_LIGHT = resource_path("Resources/Icon/help_light.png")
ICON_HELP_DARK = resource_path("Resources/Icon/help_dark.png")
ICON_RESET_LIGHT = resource_path("Resources/Icon/reset_light.png")
ICON_RESET_DARK = resource_path("Resources/Icon/reset_dark.png")
HELP_PATH = resource_path("Resources/Help/")
# Sound
S_SOUND_CASH_PATH = resource_path("Resources/Sound/cash.wav")
S_SOUND_CLEAR_PATH = resource_path("Resources/Sound/clear.wav")
S_SOUND_TOUCH_PATH = resource_path("Resources/Sound/touch.wav")
S_SOUND_UNLOCK_PATH = resource_path("Resources/Sound/unlock.wav")
 
 
# Settings Registry
COMPANY_NAME = "<COMPANY_NAME>"
APP_NAME = "<APP_NAME>"
settings_handle = SETTINGS(COMPANY_NAME, APP_NAME)
 
 
class EPaper(int, enum.Enum):
    """!
    @brief Supported paper widths of printer
    """
    WIDTH_58_MM = 58
    WIDTH_80_MM = 80
 
 
class ETheme(str, enum.Enum):
    """!
    @brief Available application themes
    """
    AUTO = "auto"
    LIGHT = "light"
    DARK = "dark"
    CLASSIC = "classic"
    SYSTEM = "system"
 
 
class ELanguages(str, enum.Enum):
    """!
    @brief Available application languages
    """
    ENGLISH = "english"
    GERMAN = "german"
 
 
S_UNIT = "EUR"
S_UNIT_SYMBOL = "€"
S_BREAK_LINE = "\\n"
 
# report defines
S_DATE_PRINT_FORMAT = "%Y/%m/%d %H:%M:%S"
L_PRINT_FILE_HEADER: list[str] = ["Count", "Article Name", "Article Number", "Group", "Total Price", "User", "Date", "Printer"]
L_GROUP = ["Group", "Gruppe"]
L_DEVICE = ["Device", "System"]
 
# Init sections
S_SECTION_PRINTER = "PRINTER"
S_KEY_PRINTER_COM_PORT = "com_port"
S_DEFAULT_COM_PORT = None
S_KEY_PAPER_WIDTH = "paper_width"
I_DEFAULT_PAPER_WIDTH = EPaper.WIDTH_58_MM.value
 
S_SECTION_SETTINGS = "SETTINGS"
S_KEY_SOUND = "sound"
B_DEFAULT_SOUND = True
S_KEY_SHOW_PRICE = "show_price"
B_DEFAULT_SHOW_PRICE = True
S_KEY_PRINT_REPORT = "print_report"
B_DEFAULT_PRINT_REPORT = True
S_KEY_THEME = "darkmode"
E_DEFAULT_THEME = ETheme.AUTO
S_KEY_LANGUAGE = "language"
E_DEFAULT_LANGUAGE = ELanguages.ENGLISH
S_KEY_VERBOSITY = "verbosity"
I_LOG_LEVEL_DEFAULT = logging.WARNING
S_KEY_OUTPUT_PATH = "output_path"
S_DEFAULT_OUTPUT_FOLDER = "BonPrinter"
S_DEFAULT_OUTPUT_PATH = str(Path.home()) + "/" + S_DEFAULT_OUTPUT_FOLDER
S_KEY_UPDATE_VERSION = "update_version"
S_DEFAULT_UPDATE_VERSION = "0.0.0"
S_KEY_LAST_DIR_PATH = "last_dir"
S_DEFAULT_LAST_PATH = "./"
 
 
S_KEY_GEOMETRY = "window_geometry"
S_KEY_STATE = "window_state"
I_DEFAULT_WIN_WIDTH = 720
I_DEFAULT_WIN_HEIGHT = 450
 
S_SECTION_CONFIGURATION = "CONFIGURATION"
S_KEY_USERS = "USERS"
S_KEY_ITEMS = "ITEMS"
 
S_HEADER = "Header"
S_HEADER_1 = "header1"
S_HEADER_2 = "header2"
S_TAX = "Tax"
S_GROUP_1 = "group1"
S_GROUP_2 = "group2"
S_GROUP_3 = "group3"
S_USER_TAX = "user"
S_PRINT_ARTICLE = "print_article"
S_DEFAULT_PRINT_ARTICLE = "True"
S_PRINT_FREE_PRICE = "print_free_price"
S_DEFAULT_PRINT_FREE_PRICE = "True"
S_NAME = "name"
S_PRICE = "price"
S_GROUP = "tax_group"
S_USER_VISIBLE = "user_visible"
S_PRINT = "print"
S_MARK = "mark"
S_BACKGROUND = "bg"
S_PRINTS = "Prints"
S_PW = "pw"
S_DEFAULT_PRICE = "9.00"
LOCKED_USER_PW = "Locked"
S_DEFAULT_USER_PW = LOCKED_USER_PW
RESET_CODE = b""  # code to reset tool
DEFAULT_CODE = "1234"
 
S_SECTION_SALES = "SALES"
I_NUMBER_OF_SALES = 101  # 1 Local + 100 order stuff
F_DEFAULT_SALES = 0.0  # need to be zero to clear sales
 
S_GENERAL = "General"
S_DEVICE = "device"
S_USER_TIMEOUT = "timeout"
S_AUTO_OPEN = "auto_open"
S_FREE_AUTO_LOGOUT = "free_auto_logout"
I_DEFAULT_USER_TIMEOUT = 15
S_DEFAULT_AUTO_OPEN = "True"
S_DEFAULT_FREE_AUTO_LOGOUT = "True"
 
 
class ItemNumber(enum.IntEnum):
    """!
    @brief Item number
    """
    MIN = 30  # 5 x 6
    EXT = 42  # 6 x 7
    MAX = 56  # 7 x 8
 
 
D_ITEM_NUMBER_ROW = {
    ItemNumber.MIN: 6,
    ItemNumber.EXT: 7,
    ItemNumber.MAX: 8
}
 
ITEM_NUMBER_COLUMN_MIN = 5
 
D_ITEM_NUMBER_COLUMN = {
    ItemNumber.MIN: ITEM_NUMBER_COLUMN_MIN,
    ItemNumber.EXT: 6,
    ItemNumber.MAX: 7
}
 
I_ITEM_ARRAY_SIZE = ItemNumber.MAX
I_NUMBER_OF_DISPLAYED_USER = 15
 
I_GROUP_1 = 1
I_GROUP_2 = 2
I_GROUP_3 = 3
 
 
class EUser(str, enum.Enum):
    """!
    @brief Present users.
    """
    B = "B"
    USER = "Smart\nCard"
    LOCAL = "Local"
    FREE = "Free"
    HOST = "Host"
    ADMIN = "Admin"
 
 
L_CONFIG_USER = [EUser.ADMIN, EUser.HOST]
L_SELL_USER = [EUser.LOCAL, EUser.FREE]
L_ORDER_USER = [EUser.B + str(i) for i in range(1, I_NUMBER_OF_SALES)]
L_ALLOWED_USER = L_CONFIG_USER + L_SELL_USER + L_ORDER_USER
 
D_DEFAULT_USER = {
    S_GENERAL: {S_DEVICE: "",
                S_USER_TIMEOUT: str(I_DEFAULT_USER_TIMEOUT),
                S_AUTO_OPEN: str(S_DEFAULT_AUTO_OPEN),
                S_FREE_AUTO_LOGOUT: str(S_DEFAULT_FREE_AUTO_LOGOUT)},
    EUser.ADMIN.value: {S_PW: base64.b64decode(RESET_CODE).decode("utf-8")},
    EUser.HOST.value: {S_PW: LOCKED_USER_PW},
    EUser.LOCAL.value: {S_PW: LOCKED_USER_PW},
    EUser.FREE.value: {S_PW: LOCKED_USER_PW}
}
 
for i in range(0, I_NUMBER_OF_DISPLAYED_USER):
    user_key = f"{EUser.B.value}{i + 1}"
    D_DEFAULT_USER[user_key] = {}
    D_DEFAULT_USER[user_key][S_NAME] = ""
    D_DEFAULT_USER[user_key][S_PW] = S_DEFAULT_USER_PW
 
D_DEFAULT_ITEM = {
    S_HEADER: {S_HEADER_1: "", S_HEADER_2: ""},
    S_TAX: {S_GROUP_1: "19", S_GROUP_2: "19", S_GROUP_3: "0", S_USER_TAX: "0"},
    S_PRINTS: {
        S_PRINT_ARTICLE: S_DEFAULT_PRINT_ARTICLE,
        S_PRINT_FREE_PRICE: S_DEFAULT_PRINT_FREE_PRICE
    },
}
 
for i in range(0, ItemNumber.MAX):
    item_key = str(i + 1)
    D_DEFAULT_ITEM[item_key] = {}
    D_DEFAULT_ITEM[item_key][S_NAME] = ""
    D_DEFAULT_ITEM[item_key][S_PRICE] = S_DEFAULT_PRICE
    D_DEFAULT_ITEM[item_key][S_GROUP] = str(I_GROUP_3)
    # D_DEFAULT_ITEM[item_key][S_USER_VISIBLE] = ""  # not visible in default view
    # D_DEFAULT_ITEM[item_key][S_PRINT] = ""  # not visible in default view
    # D_DEFAULT_ITEM[item_key][S_MARK] = ""  # not visible in default view
    # D_DEFAULT_ITEM[item_key][S_BACKGROUND] = ""  # not visible in default view
 
 
def get_default_item_config(s_deposit_name: Optional[str] = None) -> dict[str, dict[str, str]]:
    """!
    @brief Get default article configuration depend on deposit name
    @param s_deposit_name : name of deposit
    @return default article configuration
    """
    d_item_dict = copy.deepcopy(D_DEFAULT_ITEM)
    return d_item_dict
 
 
def clear_settings() -> None:
    """!
    @brief Clear registry settings to write defaults at next startup
    """
    log.warning("Set default configuration settings")
    handle = get_settings_handle()
    # do not delete group S_SECTION_SALES
    for group in [S_SECTION_PRINTER, S_SECTION_CONFIGURATION, S_SECTION_SETTINGS]:
        handle.beginGroup(group)
        handle.remove("")  # delete group
        handle.endGroup()
 
 
def get_settings_handle() -> SETTINGS:
    """!
    @brief Returns the settings handle
    @return settings handle
    """
    return settings_handle
 
 
def get_registry_value(handle: SETTINGS, s_key: str, b_none_err: bool = True) -> Any:
    """!
    @brief Reads the registry value with given handle and key.
    @param handle : settings handle
    @param s_key : get value for this key
    @param b_none_err : [True] call error if None in setting [False] allowed None as setting
    @return value that is mapped to the given key or raises a KeyError if key not found in handle.
    """
    value = handle.value(s_key, defaultValue=None)
    if b_none_err and (value is None):
        raise KeyError(f"{s_key} not found in group {handle.group()}")
    return value
 
 
def write_sound_settings(b_sound_status: bool) -> None:
    """!
    @brief Writes the sound settings to persistent storage
    @param b_sound_status : sound status
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_SOUND, b_sound_status)
    handle.endGroup()
 
 
def read_sound_settings() -> bool:
    """!
    @brief Reads the sound settings from persistent storage
    @return sound status
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        b_sound = bool(get_registry_value(handle, S_KEY_SOUND) == "true")
        handle.endGroup()
    except BaseException as e:
        log.debug("Sound not found, using default values (%s)", str(e))
        b_sound = B_DEFAULT_SOUND
        handle.endGroup()
    return b_sound
 
 
def write_sales(i_user_pos: int, f_sales: float) -> None:
    """!
    @brief Writes the sales to persistent storage
    @param i_user_pos : user position to write sales
    @param f_sales : sales value to save
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SALES)
    handle.setValue(str(i_user_pos), f_sales)
    handle.endGroup()
 
 
def read_sales() -> list[float]:
    """!
    @brief Reads the sales from persistent storage
    @return sales
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SALES)
    l_sales = []
    for i_user in range(I_NUMBER_OF_SALES):
        try:
            l_sales.append(float(get_registry_value(handle, str(i_user))))
        except KeyError as e:
            log.debug("Sales not found, using default values (%s)", str(e))
            l_sales.append(F_DEFAULT_SALES)
        except BaseException:
            # set sales as warning to save value
            log.warning("Sales of user %s not valid: %s", str(i_user), get_registry_value(handle, str(i_user)))
            l_sales.append(F_DEFAULT_SALES)
    handle.endGroup()
    return l_sales
 
 
def write_user_settings(d_user: dict[str, dict[str, str]]) -> None:
    """!
    @brief Writes the user settings to persistent storage. Passwords are stored encrypted.
           This encryption is carried out via the Windows Data Protection API (DPAPI),
           which enables user and machine-specific encryption.
    @param d_user : user dictionary
    """
    dict_to_write = copy.deepcopy(d_user)
    if platform.system() == 'Windows':
        for user_type, user_data in dict_to_write.items():  # protect password
            if S_PW in user_data:
                s_password = user_data[S_PW]
                s_password_encrypted = win32crypt.CryptProtectData(bytes(s_password, "utf-8")) if len(s_password) > 0 else ""
                dict_to_write[user_type][S_PW] = s_password_encrypted
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_CONFIGURATION)
    handle.setValue(S_KEY_USERS, dict_to_write)
    handle.endGroup()
 
 
def read_user_settings() -> dict[str, Any]:
    """!
    @brief Reads the user settings from persistent storage
    @return user settings
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_CONFIGURATION)
        d_user = get_registry_value(handle, S_KEY_USERS)
        if platform.system() == 'Windows':
            for user_type, user_data in d_user.items():
                if S_PW in user_data:
                    bytes_password_enc = user_data[S_PW]
                    _, bytes_password = win32crypt.CryptUnprotectData(bytes_password_enc) if (len(bytes_password_enc) > 0) else (None, bytes(bytes_password_enc, "utf-8"))
                    d_user[user_type][S_PW] = bytes_password.decode("utf-8")
        handle.endGroup()
    except BaseException as e:
        log.debug("Invalid User settings, using default values (%s)", str(e))
        d_user = D_DEFAULT_USER
        handle.endGroup()
    return d_user if isinstance(d_user, dict) else {}
 
 
def write_articles_settings(d_articles: dict[str, dict[str, str]]) -> None:
    """!
    @brief Writes the articles settings to persistent storage
    @param d_articles : articles dictionary
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_CONFIGURATION)
    handle.setValue(S_KEY_ITEMS, d_articles)
    handle.endGroup()
 
 
def read_articles_settings() -> dict[str, Any]:
    """!
    @brief Reads the articles settings from persistent storage
    @return user settings
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_CONFIGURATION)
        d_articles = get_registry_value(handle, S_KEY_ITEMS)
        handle.endGroup()
    except BaseException as e:
        log.debug("Articles settings not found, using default values (%s)", str(e))
        d_articles = D_DEFAULT_ITEM
        handle.endGroup()
    return d_articles if isinstance(d_articles, dict) else {}
 
 
def write_com_port_settings(s_com_port: str) -> None:
    """!
    @brief Writes the COM port settings to persistent storage
    @param s_com_port : COM port
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_PRINTER)
    handle.setValue(S_KEY_PRINTER_COM_PORT, s_com_port)
    handle.endGroup()
 
 
def read_com_port_settings() -> str | None:
    """!
    @brief Reads the COM port settings from persistent storage
    @return COM port
    """
    handle = get_settings_handle()
    com_port: str | None
    try:
        handle.beginGroup(S_SECTION_PRINTER)
        com_port = get_registry_value(handle, S_KEY_PRINTER_COM_PORT, b_none_err=False)
        if com_port is not None:
            com_port = str(com_port)
        handle.endGroup()
    except BaseException as e:
        log.debug("COM Port settings not found, using default values (%s)", str(e))
        com_port = S_DEFAULT_COM_PORT
        handle.endGroup()
    return com_port
 
 
def write_paper_width_settings(i_paper_width: int) -> None:
    """!
    @brief Writes the paper width settings to persistent storage
    @param i_paper_width : paper width
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_PRINTER)
    handle.setValue(S_KEY_PAPER_WIDTH, i_paper_width)
    handle.endGroup()
 
 
def read_paper_width_settings() -> int:
    """!
    @brief Reads the paper width settings from persistent storage
    @return paper width
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_PRINTER)
        i_paper_width = int(get_registry_value(handle, S_KEY_PAPER_WIDTH))
        handle.endGroup()
    except BaseException as e:
        log.debug("Paper Width settings not found, using default values (%s)", str(e))
        i_paper_width = I_DEFAULT_PAPER_WIDTH
        handle.endGroup()
    return i_paper_width
 
 
def write_output_path_settings(s_output_path: str) -> None:
    """!
    @brief Writes the output path settings to persistent storage
    @param s_output_path : output path
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_PRINTER)
    handle.setValue(S_KEY_OUTPUT_PATH, s_output_path)
    handle.endGroup()
 
 
def read_output_path_settings() -> str:
    """!
    @brief Reads the output path settings from persistent storage
    @return output path
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_PRINTER)
        s_output_path = str(get_registry_value(handle, S_KEY_OUTPUT_PATH))
        handle.endGroup()
    except BaseException as e:
        log.debug("Output path settings not found, using default values (%s)", str(e))
        if not os.path.exists(S_DEFAULT_OUTPUT_PATH):
            os.mkdir(S_DEFAULT_OUTPUT_PATH)
        s_output_path = S_DEFAULT_OUTPUT_PATH
        handle.endGroup()
    return s_output_path
 
 
def write_theme_settings(e_theme: ETheme) -> None:
    """!
    @brief Writes the theme settings to persistent storage
    @param e_theme : current theme
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_THEME, e_theme.value)
    handle.endGroup()
 
 
def read_theme_settings() -> ETheme:
    """!
    @brief Reads the theme settings from persistent storage
    @return Theme settings (enum ETheme)
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        s_theme = get_registry_value(handle, S_KEY_THEME)
        e_theme = ETheme(s_theme)
        handle.endGroup()
    except BaseException as e:
        log.debug("Theme settings not found, using default values (%s)", str(e))
        e_theme = E_DEFAULT_THEME
        handle.endGroup()
    return e_theme
 
 
def write_language(e_language: ELanguages) -> None:
    """!
    @brief Writes the language to persistent storage
    @param e_language : current language
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_LANGUAGE, e_language.value)
    handle.endGroup()
 
 
def read_language() -> ELanguages:
    """!
    @brief Reads the language from persistent storage
    @return Language (enum ELanguages)
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        s_language = get_registry_value(handle, S_KEY_LANGUAGE)
        e_language = ELanguages(s_language)
        handle.endGroup()
    except BaseException as e:
        log.debug("Language not found, using default values (%s)", str(e))
        current_locale, _test = locale.getlocale()  # check keyboard layout
        if current_locale is not None:  # TODO is None if start with EXE
            e_language = ELanguages.GERMAN if current_locale.startswith("de") else E_DEFAULT_LANGUAGE
        else:
            e_language = E_DEFAULT_LANGUAGE
        handle.endGroup()
    return e_language
 
 
def write_verbosity_settings(i_log_level: int) -> None:
    """!
    @brief Writes the verbosity settings to persistent storage
    @param i_log_level : log verbosity
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_VERBOSITY, i_log_level)
    handle.endGroup()
 
 
def read_verbosity_settings() -> int:
    """!
    @brief Reads the verbosity settings from persistent storage
    @return verbosity level
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        i_log_level = int(get_registry_value(handle, S_KEY_VERBOSITY))
        handle.endGroup()
    except BaseException as e:
        log.debug("Verbosity settings not found, using default values (%s)", str(e))
        i_log_level = I_LOG_LEVEL_DEFAULT
        handle.endGroup()
    return i_log_level
 
 
def save_window_state(o_geometry: BYTE_ARRAY, o_state: BYTE_ARRAY) -> None:
    """!
    @brief Saves the window state to persistent storage.
    @param o_geometry : geometry (position, size) of the window as QByteArray
    @param o_state : state (dock widgets etc.) of the window as QByteArray
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_GEOMETRY, o_geometry)
    handle.setValue(S_KEY_STATE, o_state)
    handle.endGroup()
 
 
def read_window_state() -> tuple[BYTE_ARRAY, BYTE_ARRAY]:
    """!
    @brief Reads the window geometry and state from persistent storage.
    @return window geometry and state as QByteArray
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        o_geometry = get_registry_value(handle, S_KEY_GEOMETRY)
        o_state = get_registry_value(handle, S_KEY_STATE)
        handle.endGroup()
    except BaseException as e:
        log.debug("WindowsSettings not found, using default values (%s)", str(e))
        o_geometry = o_state = None
        handle.endGroup()
    return o_geometry, o_state
 
 
def write_update_version(version: str) -> None:
    """!
    @brief Writes the last reminded tool version for update to persistent storage.
    @param version : last reminded version
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_UPDATE_VERSION, version)
    handle.endGroup()
 
 
def read_update_version() -> str:
    """!
    @brief Reads the last reminded tool version from persistent storage
    @return last reminded version
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        version = str(get_registry_value(handle, S_KEY_UPDATE_VERSION))
        handle.endGroup()
    except BaseException as e:
        log.debug("Update version settings not found, using default values (%s)", str(e))
        version = S_DEFAULT_UPDATE_VERSION
        handle.endGroup()
    return version
 
 
def write_last_dir(dir_path: str) -> None:
    """!
    @brief Writes the last directory to persistent storage
    @param dir_path : directory path
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_LAST_DIR_PATH, dir_path)
    handle.endGroup()
 
 
def read_last_dir() -> str:
    """!
    @brief Reads the last directory from persistent storage
    @return directory path
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        dir_path = str(get_registry_value(handle, S_KEY_LAST_DIR_PATH))
        handle.endGroup()
    except BaseException as e:
        log.debug("Last directory settings not found, using default values (%s)", str(e))
        dir_path = S_DEFAULT_LAST_PATH
        handle.endGroup()
    return dir_path
 
 
def write_print_report_settings(b_print_report: bool) -> None:
    """!
    @brief Writes the print report settings to persistent storage
    @param b_print_report : enable print report status
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_PRINT_REPORT, b_print_report)
    handle.endGroup()
 
 
def read_print_report_settings() -> bool:
    """!
    @brief Reads the print report status from persistent storage
    @return print report status
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        b_show_price = bool(get_registry_value(handle, S_KEY_PRINT_REPORT) == "true")
        handle.endGroup()
    except BaseException as e:
        log.debug("Print Report not found, using default values (%s)", str(e))
        b_show_price = B_DEFAULT_PRINT_REPORT
        handle.endGroup()
    return b_show_price
 
 
def write_show_price_settings(b_show_price: bool) -> None:
    """!
    @brief Writes the show price settings to persistent storage
    @param b_show_price : show price status
    """
    handle = get_settings_handle()
    handle.beginGroup(S_SECTION_SETTINGS)
    handle.setValue(S_KEY_SHOW_PRICE, b_show_price)
    handle.endGroup()
 
 
def read_show_price_settings() -> bool:
    """!
    @brief Reads the show price status from persistent storage
    @return show price status
    """
    handle = get_settings_handle()
    try:
        handle.beginGroup(S_SECTION_SETTINGS)
        b_show_price = bool(get_registry_value(handle, S_KEY_SHOW_PRICE) == "true")
        handle.endGroup()
    except BaseException as e:
        log.debug("Show Price not found, using default values (%s)", str(e))
        b_show_price = B_DEFAULT_SHOW_PRICE
        handle.endGroup()
    return b_show_price