Report Class Reference

Report class to log and create sales articles. More...

Public Member Functions
None	__init__ (self, "MainWindow" ui)
bool	check_sales_exist (self)
	Check if sales in log file or settings exist.
bool	check_setting_sales_exist (self)
	Write printed articles to log file.
None	clear_print_items (self)
	clear items to hold in storage before print out
None	clear_setting_log (self)
	Clear sales in settings.
tuple[bool, list[ItemReport], list[str]]	combine_files (self, list[str] l_files, Optional[list[list[list[str]]|None]] l_fix_data=None)
	Combine Reports to create single report from multiple other data.
None	create_report (self, Optional[list[str]] l_files=None, bool b_combine=False, bool b_clear_report=False, Optional[dict[str, dict[str, str]]] d_item=None, bool b_startup_check=False, Optional[str] s_path=None, bool b_open_folder=False)
	Create report or show only status report.
tuple[bool, list[ItemReport], list[str]]	get_items_from_print_file (self, str s_file_name=S_PRINT_FILE, bool b_combine=False, Optional[list[list[str]]] fix_data=None)
	Get items from printouts from log file.
str	get_report_text (self, list[str] l_files, list[ItemReport] l_data, datetime time, bool b_combine=False, bool b_clear_report=False, Optional[str] user_report=None)
	Create summary report text of printed articles.
str	group_items (self, dict[int, dict[str, Any]] d_dict, bool b_print_values=True, bool b_total_values=False)
	Create summary report text of printed articles.
list[list[str]]	read_data_from_print_file (self, str s_file_name=S_PRINT_FILE)
	Read printouts from log file.
None	write_data_to_file (self, list[list[Any]] l_items)
	Write printouts to log file.
None	write_data_to_print_file (self, list[Item] l_items, int i_user_pos, float f_price, str|None s_com_port)
	Write printed articles to log file.

Public Attributes
bool	b_log_modified = False
bool	b_log_valid_verified = True
dict	d_combine_data = {}
dict	d_printed_articles = {}
list	l_bar_items = [0] * I_ITEM_ARRAY_SIZE
list	l_group_values = []
list	l_marked_items = [False] * I_ITEM_ARRAY_SIZE
	l_sales = read_sales()
list	l_table_position = [None] * I_ITEM_ARRAY_SIZE
str|None	out_folder = None
str	s_report_text = ""
str	s_report_user = ""
str	s_total_sum = ""
	ui = ui

Detailed Description

Report class to log and create sales articles.

Parameters

ui	: main window object

Definition at line 96 of file report.py.

Constructor & Destructor Documentation

__init__()

None __init__	(		self,
		"MainWindow"	ui )

Definition at line 102 of file report.py.

    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()
 

Member Function Documentation

check_sales_exist()

bool check_sales_exist

(

self

)

Check if sales in log file or settings exist.

Returns

[True] sales exist; [False] sales not exist

Definition at line 135 of file report.py.

    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
 

check_setting_sales_exist()

bool check_setting_sales_exist

(

self

)

Write printed articles to log file.

Returns

[True] sales exist; [False] sales not exist

Definition at line 124 of file report.py.

    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
 

clear_print_items()

None clear_print_items

(

self

)

clear items to hold in storage before print out

Definition at line 158 of file report.py.

    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
 

clear_setting_log()

None clear_setting_log

(

self

)

Clear sales in settings.

Definition at line 510 of file report.py.

    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)
 

combine_files()

tuple[bool, list[ItemReport], list[str]] combine_files	(		self,
		list[str]	l_files,
		Optional[list[list[list[str]] | None]]	l_fix_data = None )

Combine Reports to create single report from multiple other data.

Parameters

l_files	: list of files to combine
l_fix_data	: use this fix data and do not read from file

Returns

readable status of file, items of files and header of first file

Definition at line 518 of file report.py.

    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
 

create_report()

None create_report	(		self,
		Optional[list[str]]	l_files = None,
		bool	b_combine = False,
		bool	b_clear_report = False,
		Optional[dict[str, dict[str, str]]]	d_item = None,
		bool	b_startup_check = False,
		Optional[str]	s_path = None,
		bool	b_open_folder = False )

Create report or show only status report.

Parameters

l_files	: list of files to create report
b_combine	: [True] create combined report; [False] create single report
b_clear_report	: [True] create report and clear log; [False] show only status of printed articles
d_item	: item configuration data
b_startup_check	: [True] only check reports, do not open; [False] open file
s_path	: path to write report
b_open_folder	: open output folder in explorer status

Definition at line 192 of file report.py.

                      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
 

get_items_from_print_file()

tuple[bool, list[ItemReport], list[str]] get_items_from_print_file	(		self,
		str	s_file_name = S_PRINT_FILE,
		bool	b_combine = False,
		Optional[list[list[str]]]	fix_data = None )

Get items from printouts from log file.

Parameters

s_file_name	: file to read
b_combine	: status if combine reports to extend local user with device name
fix_data	: use this fix data and do not read from file

Returns

return printed items

Definition at line 539 of file report.py.

                                  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
 

get_report_text()

str get_report_text	(		self,
		list[str]	l_files,
		list[ItemReport]	l_data,
		datetime	time,
		bool	b_combine = False,
		bool	b_clear_report = False,
		Optional[str]	user_report = None )

Create summary report text of printed articles.

Parameters

l_files	: file to save total data for combined report
l_data	: list of printed articles
time	: actual time stamp for report
b_combine	: [True] create combined report; [False] create single report
b_clear_report	: [True] create report text and clear printed sales in settings; [False] create status text
user_report	: create report for this user; None: create for all user

Returns

return report text

Definition at line 333 of file report.py.

    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
 

group_items()

str group_items	(		self,
		dict[int, dict[str, Any]]	d_dict,
		bool	b_print_values = True,
		bool	b_total_values = False )

Create summary report text of printed articles.

Parameters

d_dict	: dictionary with printed articles
b_print_values	: status if print values (not only articles)
b_total_values	: status if group total items to save in global data

Returns

return sorted group text

Definition at line 306 of file report.py.

    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
 

read_data_from_print_file()

list[list[str]] read_data_from_print_file	(		self,
		str	s_file_name = S_PRINT_FILE )

Read printouts from log file.

Parameters

s_file_name

: file to read

Returns

return printed items

Definition at line 588 of file report.py.

    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
 

write_data_to_file()

None write_data_to_file	(		self,
		list[list[Any]]	l_items )

Write printouts to log file.

Parameters

l_items

: articles to write to log file

Definition at line 602 of file report.py.

    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)

write_data_to_print_file()

None write_data_to_print_file	(		self,
		list[Item]	l_items,
		int	i_user_pos,
		float	f_price,
		str | None	s_com_port )

Write printed articles to log file.

Parameters

l_items	: list of printed articles
i_user_pos	: user (position) that print this items
f_price	: price of printed items
s_com_port	: COM port (write to print log without printer is possible)

Definition at line 165 of file report.py.

    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)
 

Member Data Documentation

b_log_modified

bool b_log_modified = False

Definition at line 113 of file report.py.

b_log_valid_verified

bool b_log_valid_verified = True

Definition at line 117 of file report.py.

d_combine_data

dict d_combine_data = {}

Definition at line 116 of file report.py.

d_printed_articles

dict d_printed_articles = {}

Definition at line 115 of file report.py.

l_bar_items

list l_bar_items = [0] * I_ITEM_ARRAY_SIZE

Definition at line 104 of file report.py.

l_group_values

list l_group_values = []

Definition at line 114 of file report.py.

l_marked_items

list l_marked_items = [False] * I_ITEM_ARRAY_SIZE

Definition at line 105 of file report.py.

l_sales

l_sales = read_sales()

Definition at line 120 of file report.py.

l_table_position

list l_table_position = [None] * I_ITEM_ARRAY_SIZE

Definition at line 108 of file report.py.

out_folder

str | None out_folder = None

Definition at line 112 of file report.py.

s_report_text

str s_report_text = ""

Definition at line 109 of file report.py.

s_report_user

str s_report_user = ""

Definition at line 110 of file report.py.

s_total_sum

str s_total_sum = ""

Definition at line 111 of file report.py.

ui

ui = ui

Definition at line 103 of file report.py.

---

The documentation for this class was generated from the following file:

• report.py