config.py

Go to the documentation of this file.

"""!
********************************************************************************
@file   config.py
@brief  configuration settings
********************************************************************************
"""
 
import logging
import os
import configparser as cfg
from configparser import ConfigParser, DuplicateSectionError, DuplicateOptionError
import codecs
from collections import OrderedDict
from typing import Any, TYPE_CHECKING
from datetime import datetime
 
from Source.version import __title__
from Source.Util.app_data import read_user_settings, write_user_settings, read_articles_settings, write_articles_settings, \
    ItemNumber, EUser, D_DEFAULT_USER, D_DEFAULT_ITEM, S_GENERAL, DEFAULT_CODE, L_ALLOWED_USER, \
    S_DEVICE, S_USER_TIMEOUT, S_AUTO_OPEN, S_FREE_AUTO_LOGOUT, S_NAME, S_PW, S_PRINTS, S_PRINT_ARTICLE, S_PRINT_FREE_PRICE, \
    I_GROUP_1, I_GROUP_2, I_GROUP_3, S_TAX, S_USER_TAX, S_GROUP_1, S_GROUP_2, S_GROUP_3, S_HEADER, S_HEADER_1, S_HEADER_2, \
    S_GROUP, S_PRICE, S_BREAK_LINE, S_USER_VISIBLE, S_PRINT, S_MARK, S_BACKGROUND
if TYPE_CHECKING:
    from Source.Controller.main_window import MainWindow
 
S_ITEM_FILE = "articles.ini"
S_ITEM_TEMP_FILE = "_temp_articles.ini"
S_USER_FILE = "user.ini"
S_USER_TEMP_FILE = "_temp_user.ini"
 
log = logging.getLogger(__title__)
 
 
def is_float(value: Any) -> bool:
    """!
    @brief Check if string can convert to float.
    @param value : value to check
    @return status if string can convert to float
    """
    try:
        float(value)
        b_float = True
    except (TypeError, ValueError):
        b_float = False
    return b_float
 
 
def is_int(value: Any) -> bool:
    """!
    @brief Check if string can convert to integer.
    @param value : value to check
    @return status if string can convert to integer
    """
    try:
        int(value)
        b_int = True
    except (TypeError, ValueError):
        b_int = False
    return b_int
 
 
def get_dict_float(d_dict: dict[str, dict[str, str]], s_section: str, s_key: str) -> float:
    """!
    @brief Get floating value in dictionary.
    @param d_dict : dictionary
    @param s_section : section
    @param s_key : key
    @return get floating value from dictionary. 0 if not present
    """
    f_float = 0.0
    if s_section in d_dict:
        value = d_dict[s_section].get(s_key)
        if value is not None:
            if is_float(value):
                f_float = float(value)
    return f_float
 
 
def get_dict_int(d_dict: dict[str, dict[str, str]], s_section: str, s_key: str) -> int:
    """!
    @brief Get integer value in dictionary.
    @param d_dict : dictionary
    @param s_section : section
    @param s_key : key
    @return get integer value from dictionary. 0 if not present
    """
    i_int = 0
    if s_section in d_dict:
        value = d_dict[s_section].get(s_key)
        if value is not None:
            if is_int(value):
                i_int = int(value)
    return i_int
 
 
def get_dict_value(d_dict: dict[str, dict[str, str]], s_section: str, s_key: str) -> str:
    """!
    @brief Get value from dictionary.
    @param d_dict : dictionary
    @param s_section : section
    @param s_key : key
    @return get integer value from dictionary. Nothing if not present
    """
    if s_section in d_dict and s_key in d_dict[s_section]:
        value = str(d_dict[s_section][s_key])
    else:
        value = ""
    return value
 
 
class Config:
    """!
    @brief Class Configuration: Read/Write configuration data (user or articles)
    @param ui : main window object
    """
 
    def __init__(self, ui: "MainWindow") -> None:
        self.ui = ui
        self.b_smartcard_id_present = False
        self.d_user = sort_dict(read_user_settings(), D_DEFAULT_USER)
        self.d_item = sort_dict(read_articles_settings(), D_DEFAULT_ITEM)
        self.item_number_size = ItemNumber.MIN
        self.update_extended_article_status(prevent_resize=True)
 
    def update_extended_article_status(self, prevent_resize: bool = False) -> None:
        """!
        @brief Update extended article status.
        @param prevent_resize : prevent resize
        """
        item_number_size = ItemNumber.MIN
        for i in range(ItemNumber.MAX, ItemNumber.MIN, -1):
            i_item_number = i
            s_item_name = self.get_item_button_name(i_item_number)
            if s_item_name != "":
                if i_item_number > ItemNumber.EXT:
                    item_number_size = ItemNumber.MAX
                    break
                if i_item_number > ItemNumber.MIN:
                    item_number_size = ItemNumber.EXT
                    break
        if self.item_number_size != item_number_size:
            self.item_number_size = item_number_size
            if not prevent_resize:
                self.ui.model.c_monitor.resize_window()  # resize only if extended view changed
 
    def get_device_name(self) -> str:
        """!
        @brief Get smart card user status.
        @return start card user activation status
        """
        origin_device_name = get_dict_value(self.d_user, S_GENERAL, S_DEVICE)
        if not origin_device_name.isalnum():  # only letter and numbers allowed for file name
            device_name = ""
        else:
            device_name = origin_device_name
        return device_name
 
    def get_logout_time(self) -> float:
        """!
        @brief Get timeout for inactive user.
        @return logout timeout
        """
        return get_dict_float(self.d_user, S_GENERAL, S_USER_TIMEOUT)
 
    def get_auto_open(self) -> bool:
        """!
        @brief Get drawer auto open status.
        @return cash drawer auto open status
        """
        s_select = get_dict_value(self.d_user, S_GENERAL, S_AUTO_OPEN)
        return not bool(s_select == "False")
 
    def get_free_auto_logout(self) -> bool:
        """!
        @brief Get free user auto logout status.
        @return free user auto logout status
        """
        s_select = get_dict_value(self.d_user, S_GENERAL, S_FREE_AUTO_LOGOUT)
        return not bool(s_select == "False")
 
    def get_user_name(self, user: str) -> str:
        """!
        @brief Get name of user (only for order staff).
        @param user : get name of this user
        @return user name
        """
        return get_dict_value(self.d_user, user, S_NAME)
 
    def get_user_pw(self, user: str) -> str:
        """!
        @brief Get password of user.
        @param user : get password of this user
        @return password of user
        """
        return get_dict_value(self.d_user, user, S_PW)
 
    def get_header1(self) -> str:
        """!
        @brief Get first bon header
        @return first bon header string
        """
        return get_dict_value(self.d_item, S_HEADER, S_HEADER_1)
 
    def get_header2(self) -> str:
        """!
        @brief Get second bon header
        @return second bon header string
        """
        return get_dict_value(self.d_item, S_HEADER, S_HEADER_2)
 
    def get_group_tax(self, i_group: int) -> float:
        """!
        @brief Get tax value from group
        @param i_group : get tax of this group (1-3)
        @return tax value of group
        """
        if i_group == I_GROUP_1:
            s_group = S_GROUP_1
        elif i_group == I_GROUP_2:
            s_group = S_GROUP_2
        else:
            s_group = S_GROUP_3
        return get_dict_float(self.d_item, S_TAX, s_group)
 
    def get_user_tax(self) -> float:
        """!
        @brief Get user involvement
        @return user involvement
        """
        return get_dict_float(self.d_item, S_TAX, S_USER_TAX)
 
    def get_print_article_status(self) -> bool:
        """!
        @brief Get article print status
        @return article print status
        """
        s_select = get_dict_value(self.d_item, S_PRINTS, S_PRINT_ARTICLE)
        return not bool(s_select == "False")
 
    def get_print_free_price_status(self) -> bool:
        """!
        @brief Get print free user price status
        @return print free price status
        """
        s_select = get_dict_value(self.d_item, S_PRINTS, S_PRINT_FREE_PRICE)
        return not bool(s_select == "False")
 
    def get_item_name(self, i_item_number: int) -> str:
        """!
        @brief Get item name
        @param i_item_number : item number (1-30)
        @return name of item
        """
        item_name = get_dict_value(self.d_item, str(i_item_number), S_NAME).replace(S_BREAK_LINE, "")
        return item_name
 
    def get_item_button_name(self, i_item_number: int) -> str:
        """!
        @brief Get item name for button. (with new lines)
        @param i_item_number : item number (1-30)
        @return name of item ("" for not present user)
        """
        if i_item_number > ItemNumber.MAX:
            i_item_number -= ItemNumber.MAX
        return get_dict_value(self.d_item, str(i_item_number), S_NAME).replace(S_BREAK_LINE, "\n")
 
    def get_item_price(self, i_item_number: int) -> float:
        """!
        @brief Get item price
        @param i_item_number : item number (1-30)
        @return price of item
        """
        f_price = get_dict_float(self.d_item, str(i_item_number), S_PRICE)
        return f_price
 
    def get_item_group(self, i_item_number: int) -> int:
        """!
        @brief Get item group
        @param i_item_number : item number (1-30)
        @return group of item
        """
        i_group = get_dict_int(self.d_item, str(i_item_number), S_GROUP)
        if i_group not in [I_GROUP_1, I_GROUP_2, I_GROUP_3]:
            i_group = I_GROUP_3
        return i_group
 
    def get_item_visible_user(self, i_item_number: int) -> EUser | None:
        """!
        @brief Get visible user for item
        @param i_item_number : item number (1-30)
        @return visible user for item
        """
        s_user = get_dict_value(self.d_item, str(i_item_number), S_USER_VISIBLE)
        user_values = [user.value for user in EUser]
        if s_user in user_values:
            e_user = EUser(s_user)
        else:
            e_user = None
        return e_user
 
    def get_item_print_status(self, i_item_number: int) -> bool:
        """!
        @brief Get item print status
        @param i_item_number : item number (1-30)
        @return print status of item
        """
        s_select = get_dict_value(self.d_item, str(i_item_number), S_PRINT)
        return not bool(s_select == "False")
 
    def get_item_mark_status(self, i_item_number: int) -> bool:
        """!
        @brief Get item mark status
        @param i_item_number : item number (1-30)
        @return mark status of item
        """
        s_select = get_dict_value(self.d_item, str(i_item_number), S_MARK)
        return bool(s_select == "True")
 
    def get_item_background(self, i_item_number: int) -> str:
        """!
        @brief Get item background
        @param i_item_number : item number (1-30)
        @return mark status of item
        """
        background = get_dict_value(self.d_item, str(i_item_number), S_BACKGROUND)
        return background
 
    def store_user_data(self) -> None:
        """!
        @brief Store actual user data
        """
        write_user_settings(self.d_user)
 
    def read_user_file(self, s_file: str, b_remove_file: bool = False) -> bool:
        """!
        @brief Read user file configuration and save in settings.
        @param s_file : file top read
        @param b_remove_file : [True] = delete file; [False] = don't delete file
        @return status if data was imported
        """
        log.debug("Import edited or new user file: %s", s_file)
        config_data = self.handle_config_data_read(s_file)
        b_set_data = False
        self.ui.unblock_ui()  # unlock before set status to show status message
        if config_data is not None:
            d_read_user_dict = config_data
            if any(value in d_read_user_dict for value in L_ALLOWED_USER):
                b_set_data = True
            else:
                b_set_data = self.ui.confirm_dialog(["Import file?", "Datei importieren?"],
                                                    l_optional_text=[f"This file does not contain any user data:\n{s_file}",
                                                                     f"Diese Datei enthält keine Benutzer Daten:\n{s_file}"])
            if b_set_data:
                if (not self.ui.model.c_auth.check_user_login(EUser.ADMIN)) and (EUser.ADMIN.value in d_read_user_dict):
                    del d_read_user_dict[EUser.ADMIN.value]  # delete if other user write Admin PW to edit file
                if EUser.ADMIN.value not in d_read_user_dict:
                    if EUser.ADMIN.value in self.d_user:
                        d_read_user_dict[EUser.ADMIN.value] = self.d_user[EUser.ADMIN.value]  # restore admin pw if not present
                    else:
                        self.ui.set_status("No Admin data to restore", True)  # state not possible
                self.d_user = d_read_user_dict.copy()
            # default Admin PW if not valid
            if EUser.ADMIN.value not in self.d_user:
                self.d_user[EUser.ADMIN.value] = D_DEFAULT_USER[EUser.ADMIN.value].copy()
                self.d_user[EUser.ADMIN.value][S_PW] = DEFAULT_CODE
                self.ui.set_status([f"No Admin data. Password is set to default: {DEFAULT_CODE}",
                                    f"Keine Admin Daten. Passwort wurde zurückgesetzt: {DEFAULT_CODE}"], True)
            if S_PW not in self.d_user[EUser.ADMIN.value]:
                self.d_user[EUser.ADMIN.value][S_PW] = DEFAULT_CODE
                self.ui.set_status([f"No Admin Password data. Password is set to default: {DEFAULT_CODE}",
                                    f"Kein Admin Passwort. Passwort wurde zurückgesetzt: {DEFAULT_CODE}"], True)
            if not self.d_user[EUser.ADMIN.value][S_PW].isdigit() and self.d_user[EUser.ADMIN.value][S_PW] != "":
                self.d_user[EUser.ADMIN.value][S_PW] = DEFAULT_CODE
                self.ui.set_status([f"Admin password is invalid. Password is set to default: {DEFAULT_CODE}",
                                    f"Admin Passwort ist ungültig. Passwort wurde zurückgesetzt: {DEFAULT_CODE}"], True)
            if not self.ui.test_mode:
                self.store_user_data()
            if b_remove_file:
                os.remove(s_file)
            self.ui.set_status(["User configuration changed", "Benutzer Konfiguration wurde geändert"])
        else:
            if b_remove_file:
                b_edit = self.ui.confirm_dialog(["Invalid. Edit again?", "Ungültig. Erneut bearbeiten?"])
                if b_edit:
                    self.ui.edit_user_in_notepad(s_file)
                else:
                    self.ui.set_status(["Unable to read user configuration with duplicate users",
                                        "Benutzerkonfiguration mit doppelten Benutzern kann nicht gelesen werden"], True)
            else:
                self.ui.set_status(["Unable to import user configuration with duplicate users",
                                    "Importieren der Benutzerkonfiguration mit doppelten Benutzern nicht möglich"], True)
        return b_set_data
 
    def read_item_file(self, s_file: str, b_remove_file: bool = False) -> bool:
        """!
        @brief Read articles file configuration and save in settings.
        @param s_file : file top read
        @param b_remove_file : [True] = delete file; [False] = don't delete file
        @return status if data was imported
        """
        log.debug("Import edited or new articles file: %s", s_file)
        config_data = self.handle_config_data_read(s_file)
        b_set_data = False
        self.ui.unblock_ui()  # unlock before set status to show status message
        if config_data is not None:
            l_possible_articles = [str(i) for i in range(1, ItemNumber.MAX + 1)]
            if any(value in config_data for value in l_possible_articles):
                b_set_data = True
            else:
                b_set_data = self.ui.confirm_dialog(["Import file?", "Datei importieren?"],
                                                    l_optional_text=[f"This file does not contain any articles data:\n{s_file}",
                                                                     f"Diese Datei enthält keine Artikel Daten:\n{s_file}"])
            if b_set_data:
                self.d_item = config_data
                self.update_extended_article_status()
                if not self.ui.test_mode:
                    write_articles_settings(self.d_item)
                if b_remove_file:
                    os.remove(s_file)
                # update header in printer
                self.ui.model.c_printer.set_header(self.get_header1(),
                                                   self.get_header2())
                self.ui.set_status(["Articles configuration changed", "Artikel Konfiguration wurde geändert"])
        else:
            if b_remove_file:
                b_edit = self.ui.confirm_dialog(["Invalid. Edit again?", "Ungültig. Erneut bearbeiten?"])
                if b_edit:
                    self.ui.edit_items_in_notepad(s_file)
                else:
                    self.ui.set_status(["Unable to read articles configuration with duplicate numbers",
                                        "Artikelkonfiguration mit doppelten Positionen kann nicht gelesen werden"], True)
            else:
                self.ui.set_status(["Unable to import articles configuration with duplicate numbers",
                                    "Importieren der Artikelkonfiguration mit doppelten Positionen nicht möglich"], True)
        if b_set_data:
            self.ui.update_screen()
        return b_set_data
 
    def handle_config_data_read(self, s_file: str) -> dict[str, Any] | None:
        """!
        @brief Try to read config data to handle duplicate items.
        @param s_file : file to read
        @return config data from file
        """
        try:
            d_data = read_data_from_config_file(s_file)
        except (DuplicateSectionError, DuplicateOptionError) as e:
            log.debug(e)
            d_data = None
        return d_data
 
 
def sort_dict(d_dict_to_sort: dict[str, Any], d_order_reference: dict[str, Any]) -> dict[str, Any]:
    """!
    @brief Sort dictionary.
    @param d_dict_to_sort : dictionary to sort
    @param d_order_reference : reference dictionary to sort in this order
    @return return sorted dictionary
    """
    sorted_dict = OrderedDict()
    unsorted_dict = OrderedDict()
 
    for key, _order in d_order_reference.items():
        if key in d_dict_to_sort:
            value = d_dict_to_sort[key]
 
            if isinstance(value, dict):
                sorted_dict[key] = sort_dict(value, d_order_reference[key])
            else:
                sorted_dict[key] = value
 
    # insert unsorted values at the end
    for key, value in d_dict_to_sort.items():
        if key not in d_order_reference:
            if isinstance(value, dict):
                unsorted_dict[key] = sort_dict(value, {})
            else:
                unsorted_dict[key] = value
 
    sorted_dict.update(unsorted_dict)
    return sorted_dict
 
 
def read_data_from_config_file(s_file_name: str) -> dict[str, dict[str, str | list[str]]]:
    """!
    @brief Read data from configuration file.
    @param s_file_name : file to read
    @return return configuration of the file
    """
    d_data: dict[str, dict[str, str | list[str]]] = {}
    parser = ConfigParser()
    with codecs.open(s_file_name, mode="r", encoding="utf-8") as file:
        parser.read_file(file)
    for s_section in parser.sections():
        d_data[s_section] = {}
        for key, value in parser.items(s_section):
            b_list_key = False
            if b_list_key and value.startswith('[') and value.endswith(']'):  # read UID as list if possible
                s_entries = value[1:-1].split(", ")
                l_entries = [s_char.strip('\'\"') for s_char in s_entries]
                d_data[s_section][key] = l_entries
            else:
                d_data[s_section][key] = value
    return d_data
 
 
def write_config_to_file(s_file_name: str, d_dict: dict[str, Any]) -> None:
    """!
    @brief Write configuration to file.
    @param s_file_name : write to this file
    @param d_dict : dictionary to write
    """
    parser = cfg.ConfigParser()
    for s_ini_section in d_dict:
        parser.add_section(s_ini_section)
        for s_ini_key in d_dict[s_ini_section]:
            s_ini_value = d_dict[s_ini_section][s_ini_key]
            if isinstance(s_ini_value, list):
                s_ini_value = ', '.join(f'"{item}"' for item in s_ini_value)
                s_ini_value = f"[{s_ini_value}]"
            parser.set(s_ini_section, s_ini_key, s_ini_value)
    with open(s_file_name, mode="w", encoding="utf-8") as o_cfg_file:
        parser.write(o_cfg_file)