report.py

Go to the documentation of this file.

"""!
********************************************************************************
@file   report.py
@brief  read and write print log data and create report
********************************************************************************
"""
 
import os
import csv
import shutil
import logging
import copy
from typing import NamedTuple, Optional, Any, TYPE_CHECKING
from datetime import datetime
 
from Source.version import __title__
from Source.Util.app_data import open_explorer, EUser, I_GROUP_1, I_GROUP_2, I_GROUP_3, S_UNIT, ItemNumber, \
    read_sales, write_sales, L_CONFIG_USER, I_NUMBER_OF_SALES, F_DEFAULT_SALES, I_ITEM_ARRAY_SIZE, \
    S_DATE_PRINT_FORMAT, L_PRINT_FILE_HEADER, L_GROUP, L_DEVICE, S_UNIT_SYMBOL
 
from Source.Model.config import S_ITEM_FILE, write_config_to_file  # pylint: disable=wrong-import-position
from Source.Model.language import L_COMBINED_TITLE, L_REPORT_TITLE, L_REPORT_STATUS_TITLE, L_USER_STATUS_TITLE  # pylint: disable=wrong-import-position
if TYPE_CHECKING:
    from Source.Controller.main_window import MainWindow
 
log = logging.getLogger(__title__)
 
B_POWERSHELL_COPY = False
 
S_PRINT_LOG_NAME = "PrintLog"
 
S_PRINT_FILE = f"{S_PRINT_LOG_NAME}.csv"
 
S_REPORT_NAME = "Report"
S_REPORT_FOLDER_NAME = "PrintReport"
S_COMBINE_FOLDER_NAME = "CombinedReport"
 
 
SALES_KEY = "sales"
SUM_KEY = "sum"
 
D_GROUP_SUMMARY: dict[int, dict[str, Any]] = {I_GROUP_1: {SUM_KEY: 0, SALES_KEY: {}},
                                              I_GROUP_2: {SUM_KEY: 0, SALES_KEY: {}},
                                              I_GROUP_3: {SUM_KEY: 0, SALES_KEY: {}}}
 
 
class Item(NamedTuple):
    """!
    @brief properties of printed article
    """
    amount: int
    name: str
    pos: int
    group: int
    price: str
    price_total: str
    user: str
    date: str
    port: bool  # TODO port in print umbenennen
 
 
class ItemReport(NamedTuple):
    """!
    @brief properties of logged article
    """
    amount: int
    name: str
    pos: int
    group: int
    price: float
    price_total: float
    user: str
    date: datetime
    port: str
 
 
def create_item(count: int, name: str, pos: int, group: int, price: float, price_total: float, user: str | None, date: datetime, port: bool) -> Item:
    """!
    @brief Create Item to write to log
    @param count : number of items
    @param name : name of item
    @param pos : article position
    @param group : group number
    @param price : single article prince
    @param price_total : total article price
    @param user : user name who print the article
    @param date : datetime of item print
    @param port : status if item print or only save (if print use COM port name)
    @return item
    """
    s_datetime = date.strftime(S_DATE_PRINT_FORMAT) if (date is not None) else None
    assert (user is not None), "None user will print"
    return Item(count, name, pos, group, f"{price:.2f}", f"{price_total:.2f}", user, s_datetime, port)
 
 
class Report:
    """!
    @brief Report class to log and create sales articles
    @param ui : main window object
    """
 
    def __init__(self, ui: "MainWindow") -> None:
        self.ui = ui
        self.l_bar_items = [0] * I_ITEM_ARRAY_SIZE
        self.l_marked_items = [False] * I_ITEM_ARRAY_SIZE
        for i in range(ItemNumber.MAX):
            self.l_marked_items[i] = self.ui.model.c_config.get_item_mark_status(i + 1)  # set default mark status
        self.l_table_position: list[int | None] = [None] * I_ITEM_ARRAY_SIZE  # table position of items to delete single selected items
        self.s_report_text: str = ""
        self.s_report_user: str = ""
        self.s_total_sum: str = ""
        self.out_folder: str | None = None
        self.b_log_modified: bool = False
        self.l_group_values: list[list[float]] = []
        self.d_printed_articles: dict[str, int] = {}
        self.d_combine_data: dict[str, float] = {}
        self.b_log_valid_verified = True  # help variable to get info out of function
 
        # sales
        self.l_sales = read_sales()
 
        self.clear_print_items()
 
    def check_setting_sales_exist(self) -> bool:
        """!
        @brief Write printed articles to log file
        @return [True] sales exist; [False] sales not exist
        """
        b_sales_exist = False
        for s_sale in self.l_sales:
            if s_sale != 0:
                b_sales_exist = True
        return b_sales_exist
 
    def check_sales_exist(self) -> bool:
        """!
        @brief Check if sales in log file or settings exist
        @return [True] sales exist; [False] sales not exist
        """
        if self.ui.model.c_auth.b_login_state:
            b_edit_user = self.ui.model.c_auth.check_user_login(L_CONFIG_USER)
            if not b_edit_user:
                user = self.ui.model.c_auth.s_login_user
                if user is not None:
                    i_user_pos = self.ui.model.c_auth.get_user_position()
                    if i_user_pos is None:
                        b_sales_exist = False
                    else:
                        b_sales_exist = bool(self.l_sales[i_user_pos] != 0)  # TODO user mit 0 Euro prints b_sales_exist = True
                else:
                    b_sales_exist = False
            else:
                b_sales_exist = self.check_setting_sales_exist() or os.path.exists(S_PRINT_FILE)
        else:
            b_sales_exist = False
        return b_sales_exist
 
    def clear_print_items(self) -> None:
        """!
        @brief clear items to hold in storage before print out
        """
        self.l_bar_items = [0] * I_ITEM_ARRAY_SIZE
        self.l_table_position = [None] * I_ITEM_ARRAY_SIZE
 
    def write_data_to_print_file(self, l_items: list[Item], i_user_pos: int, f_price: float, s_com_port: str | None) -> None:
        """!
        @brief Write printed articles to log file
        @param l_items : list of printed articles
        @param i_user_pos : user (position) that print this items
        @param f_price : price of printed items
        @param s_com_port : COM port (write to print log without printer is possible)
        """
        b_item = True
        if b_item:  # do not safe EC sales for reference
            self.l_sales[i_user_pos] += f_price
            write_sales(i_user_pos, self.l_sales[i_user_pos])
 
        if s_com_port is None:
            s_com_port = "None"  # to save print information
        l_list = []
        for item in l_items:
            b_print = False
            if item.port or b_print:  # if print out
                port = s_com_port
            else:
                port = "None"
            l_list.append([item.amount, item.name, item.pos, item.group, item.price_total, item.user, item.date, port])
        if not os.path.exists(S_PRINT_FILE):
            self.write_data_to_file([L_PRINT_FILE_HEADER])
        self.write_data_to_file(l_list)
 
    def create_report(self, l_files: Optional[list[str]] = None, b_combine: bool = False, b_clear_report: bool = False, d_item: Optional[dict[str, dict[str, str]]] = None,
                      b_startup_check: bool = False, s_path: Optional[str] = None, b_open_folder: bool = False) -> None:
        """!
        @brief Create report or show only status report
        @param l_files : list of files to create report
        @param b_combine : [True] create combined report; [False] create single report
        @param b_clear_report : [True] create report and clear log; [False] show only status of printed articles
        @param d_item : item configuration data
        @param b_startup_check : [True] only check reports, do not open; [False] open file
        @param s_path : path to write report
        @param b_open_folder : open output folder in explorer status
        """
        now = datetime.now()
        if b_combine:
            s_folder_name = S_COMBINE_FOLDER_NAME
            self.ui.set_status(["Combine report", "Bericht wird kombiniert"])
        else:
            s_folder_name = S_REPORT_FOLDER_NAME
            if not b_startup_check:
                self.ui.set_status(["Create report", "Bericht wird erstellt"])
 
        # collect all CSV files for report
        l_fix_data: list[list[list[str]] | None] | None = None
        if l_files is None:
            self.d_combine_data = {}  # clear data for combined report
            l_files = [S_PRINT_FILE]
        elif b_combine and not b_startup_check:
            self.d_combine_data = {}  # clear data for combined report
            for report_file in sorted(l_files):  # sort files for combine
                self.create_report(l_files=[report_file], b_combine=b_combine, b_clear_report=False, b_startup_check=True)
 
        b_log_data_readable, l_item, l_header = self.combine_files(l_files, l_fix_data=l_fix_data)
 
        if b_combine or b_clear_report:
            user = None
        else:
            if self.ui.model.c_auth.s_login_user in L_CONFIG_USER:
                user = None
            else:
                user = self.ui.model.c_auth.s_login_user
        self.s_report_user = user if (user is not None) else ""
 
        # get report text
        s_text = self.get_report_text(l_files, l_item, now, b_combine=b_combine, b_clear_report=b_clear_report, user_report=user)
 
        self.s_report_text = s_text  # save to global to print out
 
        if not b_log_data_readable:
            self.ui.set_status(["Print Log file not readable", "Protokolldatei nicht lesbar"], True)
        elif not self.b_log_valid_verified:
            self.ui.set_status(["Print Log data not verified", "Protokolldatei nicht verifiziert"], True)
            self.b_log_modified = True
        else:
            self.b_log_modified = False
 
        if (b_clear_report or b_combine) and not b_startup_check:
            device_name = self.ui.model.c_config.get_device_name()
            device_suffix = f"_{device_name}" if (not b_combine and (device_name != "")) else ""
            suffix = now.strftime("%Y-%m-%d_%Hh%Mm%Ss") + device_suffix
 
            s_folder_name = S_COMBINE_FOLDER_NAME if b_combine else S_REPORT_FOLDER_NAME
            if s_path is not None:
                output_path = s_path
            else:
                output_path = self.ui.model.s_output_path
            s_folder = f"{output_path}/{s_folder_name}_{suffix}"
            log.debug("Create folder: %s", s_folder)
 
            # create report folder if not exist
            if not os.path.isdir(s_folder):
                os.makedirs(s_folder)
 
                # create summary report (MarkDown)
                md_report_path = f"{s_folder}/{S_REPORT_NAME}_{suffix}.md"
                log.debug("Open file: %s", md_report_path)
                with open(md_report_path, mode="w", encoding="utf-8") as file:
                    file.write(s_text)
 
                if b_combine or os.path.exists(S_PRINT_FILE):
                    xl_report_path = None
 
                    if not b_combine:
                        csv_print_log_report_path = os.path.join(s_folder, f"{S_PRINT_LOG_NAME}_{suffix}.csv")
 
                        # copy print log (CSV) to report folder
                        shutil.copy(S_PRINT_FILE, csv_print_log_report_path)
 
                        # copy articles configuration to report
                        if d_item is not None:
                            article_configuration_path = f"{s_folder}/{S_ITEM_FILE}"
                            write_config_to_file(article_configuration_path, d_item)
                        else:
                            article_configuration_path = None
 
                        # remove print log (CSV) to clean data for next report
                        self.clear_setting_log()  # TODO wird nur aufgerufen wenn CSV existiert
                        os.remove(S_PRINT_FILE)
 
                if B_POWERSHELL_COPY:
                    # copy folder content to clipboard
                    command = f"powershell Set-Clipboard -LiteralPath {s_folder}"
                    os.system(command)
 
                # save path to open out folder
                self.out_folder = s_folder
                if b_open_folder:
                    open_explorer(s_folder)
            else:
                self.out_folder = None
                self.ui.set_status([f"Folder already exist: {s_folder}",
                                    f"Ordner existiert bereits: {s_folder}"], True)
        else:  # show only status
            self.out_folder = None
 
    def group_items(self, d_dict: dict[int, dict[str, Any]], b_print_values: bool = True, b_total_values: bool = False) -> str:
        """!
        @brief Create summary report text of printed articles.
        @param d_dict : dictionary with printed articles
        @param b_print_values : status if print values (not only articles)
        @param b_total_values : status if group total items to save in global data
        @return return sorted group text
        """
        s_text = ""
        if b_total_values:
            self.l_group_values = []
        for group in [I_GROUP_1, I_GROUP_2, I_GROUP_3]:
            f_sum = d_dict[group][SUM_KEY]
            if (f_sum != 0) or d_dict[group][SALES_KEY]:
                s_text += f"* {self.ui.model.c_language.get_language_text(L_GROUP)} {group}:"
                if b_print_values:
                    s_text += f" {f_sum:.2f} {S_UNIT}  \n"
                else:
                    s_text += "\n"
            tax = self.ui.model.c_config.get_group_tax(group)
            if b_total_values:
                self.l_group_values.append([f_sum, tax])
            for item, count in sorted(d_dict[group][SALES_KEY].items()):
                s_text += f"  {count} x {item}  \n"
        s_text += "\n"
        return s_text
 
    def get_report_text(self, l_files: list[str], l_data: list[ItemReport], time: datetime, b_combine: bool = False, b_clear_report: bool = False, user_report: Optional[str] = None) -> str:
        """!
        @brief Create summary report text of printed articles.
        @param l_files : file to save total data for combined report
        @param l_data : list of printed articles
        @param time : actual time stamp for report
        @param b_combine : [True] create combined report; [False] create single report
        @param b_clear_report : [True] create report text and clear printed sales in settings; [False] create status text
        @param user_report : create report for this user; None: create for all user
        @return return report text
        """
        d_user_item = {}
        d_total_items = copy.deepcopy(D_GROUP_SUMMARY)
        d_free_items = copy.deepcopy(D_GROUP_SUMMARY)
 
        f_ec_sum = 0.0
 
        if b_combine:
            s_title = self.ui.model.c_language.get_language_text(L_COMBINED_TITLE)
        else:
            if b_clear_report:
                s_title = self.ui.model.c_language.get_language_text(L_REPORT_TITLE)
            else:
                if user_report is None:
                    s_title = self.ui.model.c_language.get_language_text(L_REPORT_STATUS_TITLE)
                else:
                    s_title = self.ui.model.c_language.get_language_text(L_USER_STATUS_TITLE)
 
        s_report = f"# {s_title}\n\n"
 
        if l_data:
            min_date = None
            max_date = None
            # sort articles by user and group
            for entry in l_data:
                name = entry.name
                count = entry.amount
                price = entry.price_total
                user = entry.user
                date = entry.date
                printer = entry.port
                b_item = True
                if b_item:
                    if (user_report is None) or (user_report == user):
                        if min_date is None:
                            min_date = date
                        else:
                            min_date = min(min_date, date)
                        if max_date is None:
                            max_date = date
                        else:
                            max_date = max(max_date, date)
                    if entry.group not in [I_GROUP_1, I_GROUP_2]:
                        group = I_GROUP_3  # all other groups are group 3
                    else:
                        group = entry.group
 
                    if user != EUser.FREE:
                        if user not in d_user_item:
                            d_user_item[user] = copy.deepcopy(D_GROUP_SUMMARY)
 
                        # user sum
                        if name in d_user_item[user][group][SALES_KEY]:
                            d_user_item[user][group][SALES_KEY][name] += count
                        else:
                            d_user_item[user][group][SALES_KEY][name] = count
                        d_user_item[user][group][SUM_KEY] += price
 
                        # total sum
                        if name in d_total_items[group][SALES_KEY]:
                            d_total_items[group][SALES_KEY][name] += count
                        else:
                            d_total_items[group][SALES_KEY][name] = count
                        d_total_items[group][SUM_KEY] += price
                    else:
                        if name in d_free_items[group][SALES_KEY]:
                            d_free_items[group][SALES_KEY][name] += count
                        else:
                            d_free_items[group][SALES_KEY][name] = count
                else:
                    f_ec_sum += price
            # date
            s_create_time = time.strftime(S_DATE_PRINT_FORMAT)
            device_name = self.ui.model.c_config.get_device_name()
            if not b_combine and (device_name != ""):
                device_lable = self.ui.model.c_language.get_language_text(L_DEVICE)
                s_report += f"{device_lable}:\t{device_name}  \n"
                if len(l_files) > 1:
                    for file in l_files[1:]:  # ignore first local file
                        s_report += f"{device_lable}:\t{file}  \n"
            s_report += f"{self.ui.model.c_language.get_language_text(['Create', 'Erst.'])}:\t{s_create_time}  \n"
            s_report += f"{self.ui.model.c_language.get_language_text(['From', 'Von'])}: \t{str(min_date).replace('-', '/')}  \n"
            s_report += f"{self.ui.model.c_language.get_language_text(['To', 'Bis'])}: \t{str(max_date).replace('-', '/')}  \n\n"
 
        # Total sales
        if user_report is None:
            s_report += f"## {self.ui.model.c_language.get_language_text(['Total prints', 'Gesamte Ausdrucke'])}\n\n"
            total_sum = d_total_items[I_GROUP_1][SUM_KEY] + d_total_items[I_GROUP_2][SUM_KEY] + d_total_items[I_GROUP_3][SUM_KEY]
            if (not b_combine) and (len(l_files) == 1):
                s_file_name = os.path.basename(l_files[0])
                prefix = f"{S_PRINT_LOG_NAME}_"
                suffix = ".csv"
                if s_file_name.startswith(prefix):
                    s_file_name = s_file_name[len(prefix):]
                if s_file_name.endswith(suffix):
                    s_file_name = s_file_name[:-len(suffix)]
                self.d_combine_data[s_file_name] = total_sum
            s_total_sum = f"{total_sum:.2f}"
            if user_report is None:
                self.s_total_sum = s_total_sum
            s_report += f"{self.ui.model.c_language.get_language_text(['Total sum', 'Gesamtsumme'])}: {s_total_sum} {S_UNIT}\n"
            if f_ec_sum != 0:
                s_report += f"{self.ui.model.c_language.get_language_text(['inc. EC', 'ink. EC'])}: {f_ec_sum:.2f} {S_UNIT}\n"
            s_report += "\n"
            s_total_text = self.group_items(d_total_items, b_total_values=True)
            if len(d_user_item) > 1:  # print total items only if multiple user prints present (prevent double item report)
                s_report += s_total_text
 
        # User sales
        if user_report is None:
            s_report += f"## {self.ui.model.c_language.get_language_text(['Prints per user', 'Ausdrucke pro Benutzer'])}\n\n"
        b_log_invalid = False
        l_checked_user = [False] * I_NUMBER_OF_SALES
        if d_user_item:
            for user in sorted(d_user_item.keys()):
                if (user_report is None) or (user_report == user):
                    user_sales_sum = d_user_item[user][I_GROUP_1][SUM_KEY]\
                        + d_user_item[user][I_GROUP_2][SUM_KEY]\
                        + d_user_item[user][I_GROUP_3][SUM_KEY]
                    s_price = f"{user_sales_sum:.2f}"
                    if user_report is not None:
                        self.s_total_sum = s_price
                    s_report += f"### {user}\n"
                    s_report += f"{self.ui.model.c_language.get_language_text(['Sum', 'Summe'])}: {s_price} {S_UNIT}  \n"
                    user_tax = self.ui.model.c_config.get_user_tax()
                    if (not user.startswith(EUser.LOCAL.value)) and (user_tax != 0):  # do not use check_user_login because local is modifies in combined report with prefix
                        involv = user_sales_sum * (user_tax / 100)
                        to_pay = user_sales_sum - involv
                        s_report += f"{self.ui.model.c_language.get_language_text(['Involv', 'Beteiligung'])}: {involv:.2f} {S_UNIT} ({user_tax} %)  \n"
                        s_report += f"{self.ui.model.c_language.get_language_text(['To Pay', 'zu zahlen'])}: {to_pay:.2f} {S_UNIT}  \n"
                    if (not b_combine) and (len(l_files) == 1):
                        i_user_pos = self.ui.model.c_auth.get_user_position(user)
                        if i_user_pos is not None:
                            if i_user_pos < I_NUMBER_OF_SALES:
                                l_checked_user[i_user_pos] = True
                            s_price_ref = f"{self.l_sales[i_user_pos]:.2f}"
                            if s_price_ref != s_price:
                                b_log_invalid = True
                                s_ref_price = f"{self.l_sales[i_user_pos]:.2f}"
                                s_report += f"  {self.ui.model.c_language.get_language_text(['Log modified! valid', 'Modifiziert! Gültig'])}: {s_ref_price} {S_UNIT}  \n"
                    s_report += self.group_items(d_user_item[user])
 
        b_missing_sales = False
        if not b_combine and (user_report is None):
            # check if vales missing in log
            for i_pos, f_user_sales in enumerate(self.l_sales):
                if not l_checked_user[i_pos]:
                    if f_user_sales != 0:
                        b_missing_sales = True
                        user = self.ui.model.c_auth.get_user_name_from_position(i_pos)
                        s_price = f"{0:.2f}"  # price = 0.00
                        s_ref_price = f"{f_user_sales:.2f}"
                        s_report += f"* {user}: {s_price} {S_UNIT}\n"
                        s_report += f"  {self.ui.model.c_language.get_language_text(['Log modified! valid', 'Modifiziert! Gültig'])}: {s_ref_price} {S_UNIT}  \n"
 
        if user_report is None:
            if d_free_items[I_GROUP_1][SALES_KEY] or d_free_items[I_GROUP_2][SALES_KEY] or d_free_items[I_GROUP_3][SALES_KEY]:
                s_report += f"## {self.ui.model.c_language.get_language_text(['Free Articles', 'Freie Artikel'])}\n\n"
                s_report += self.group_items(d_free_items, b_print_values=False)
        self.d_printed_articles = d_total_items[I_GROUP_1][SALES_KEY] | d_total_items[I_GROUP_2][SALES_KEY] | d_total_items[I_GROUP_3][SALES_KEY]
 
        if b_combine:
            self.b_log_valid_verified = True
        else:
            self.b_log_valid_verified = not b_missing_sales and not b_log_invalid  # save to global to get info out of this function
        return s_report
 
    def clear_setting_log(self) -> None:
        """!
        @brief Clear sales in settings
        """
        for i_user in range(I_NUMBER_OF_SALES):
            self.l_sales[i_user] = F_DEFAULT_SALES  # clear reference check
            write_sales(i_user, F_DEFAULT_SALES)
 
    def combine_files(self, l_files: list[str], l_fix_data: Optional[list[list[list[str]] | None]] = None) -> tuple[bool, list[ItemReport], list[str]]:
        """!
        @brief Combine Reports to create single report from multiple other data.
        @param l_files : list of files to combine
        @param l_fix_data : use this fix data and do not read from file
        @return readable status of file, items of files and header of first file
        """
        l_all_item: list[ItemReport] = []
        l_header: list[str] = []
        b_log_data_readable = False
 
        for i, file in enumerate(l_files):
            fix_data = None if (l_fix_data is None) else l_fix_data[i]
            b_log_data_readable, l_item, l_header = self.get_items_from_print_file(file, bool(len(l_files) > 1), fix_data=fix_data)
            if b_log_data_readable:
                l_all_item += l_item
            else:
                break
 
        return b_log_data_readable, l_all_item, l_header
 
    def get_items_from_print_file(self, s_file_name: str = S_PRINT_FILE, b_combine: bool = False,
                                  fix_data: Optional[list[list[str]]] = None) -> tuple[bool, list[ItemReport], list[str]]:
        """!
        @brief Get items from printouts from log file.
        @param s_file_name : file to read
        @param b_combine : status if combine reports to extend local user with device name
        @param fix_data : use this fix data and do not read from file
        @return return printed items
        """
        s_device_suffix: str | None = None
        if b_combine:
            s_device_suffix = os.path.basename(s_file_name)
            suffix = ".csv"
            if s_device_suffix.endswith(suffix):
                s_device_suffix = s_device_suffix[:-len(suffix)]
            l_device_suffix = s_device_suffix.split("_")
            if len(l_device_suffix) == 4:  # default file name has third position as device name
                s_device_suffix = l_device_suffix[-1]
            else:
                s_device_suffix = None
        try:
            l_header = []
            if fix_data is None:
                l_raw_data = self.read_data_from_print_file(s_file_name)
            else:
                l_raw_data = fix_data
            l_item = []
            for i, row in enumerate(l_raw_data):
                if i != 0:
                    user = row[5]
                    if (s_device_suffix is not None) and (user == EUser.LOCAL):
                        user = f"{user}_{s_device_suffix}"  # rename local user for combined report with multiple devices
                    name = row[1]
                    price_total = float(row[4])
                    amount = int(row[0])
                    item = ItemReport(amount, name, int(row[2]), int(row[3]), 0.0,
                                      price_total, user, datetime.strptime(row[6], S_DATE_PRINT_FORMAT), row[7])
                    l_item.append(item)
                else:
                    l_header = row
        except BaseException:
            l_item = []
            l_header = []
            b_log_data_readable = False
        else:
            b_log_data_readable = True
 
        return b_log_data_readable, l_item, l_header
 
    def read_data_from_print_file(self, s_file_name: str = S_PRINT_FILE) -> list[list[str]]:
        """!
        @brief Read printouts from log file.
        @param s_file_name : file to read
        @return return printed items
        """
        l_item = []
        if os.path.exists(s_file_name):
            with open(s_file_name, mode="r", encoding="utf-8", newline="") as csv_file:
                l_data = csv.reader(csv_file, delimiter=";", quotechar="|")
                for row in l_data:
                    l_item.append(row)
        return l_item
 
    def write_data_to_file(self, l_items: list[list[Any]]) -> None:
        """!
        @brief Write printouts to log file
        @param l_items : articles to write to log file
        """
        with open(S_PRINT_FILE, mode="a+", encoding="utf-8", newline="") as file:
            writer = csv.writer(file, delimiter=";")
            for entry in l_items:
                writer.writerow(entry)