mbu-dev-shared-components 2.3.0__tar.gz → 2.4.3__tar.gz

{mbu_dev_shared_components-2.3.0 → mbu_dev_shared_components-2.4.3}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: mbu_dev_shared_components
-Version: 2.3.0
+Version: 2.4.3
 Summary: Shared components to use in RPA projects
 Author-email: MBU <rpa@mbu.aarhus.dk>
+License-Expression: MIT
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
@@ -19,7 +19,11 @@ Requires-Dist: uiautomation
 Requires-Dist: pillow
 Requires-Dist: psutil
 Requires-Dist: docx2pdf
+Requires-Dist: pandas>=2.2.3
 Requires-Dist: rawpy
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-dependency>=0.5.1; extra == "dev"
 Dynamic: license-file
 
 # MBU Dev Shared Components

{mbu_dev_shared_components-2.3.0 → mbu_dev_shared_components-2.4.3}/mbu_dev_shared_components/msoffice365/sharepoint_api/files.py

@@ -29,12 +29,25 @@ Example:
     sp.download_files("FolderName", "C:\\LocalPath")
 """
 
-from pathlib import PurePath
-from typing import Optional, List
 import os
+
+import math
+
+import traceback
+
+from pathlib import PurePath
+
+from io import BytesIO
+
+from typing import Optional, List, Dict, Any
+
+from openpyxl.styles import Font, Alignment
+from openpyxl import load_workbook
+
+import pandas as pd
+
 from office365.runtime.auth.user_credential import UserCredential
 from office365.sharepoint.client_context import ClientContext
-
 from office365.sharepoint.files.file import File
 
 
@@ -136,7 +149,6 @@ class Sharepoint:
                 file_content = File.open_binary(self.ctx, file_url)
                 return file_content.content
             except Exception:
-                import traceback
                 print("Failed to download file:")
                 traceback.print_exc()
                 return None
@@ -249,3 +261,260 @@ class Sharepoint:
                 print(f"File '{file_name}' uploaded successfully to '{folder_url}'.")
             except Exception as e:
                 print(f"Failed to upload file '{file_name}': {e}")
+
+    def append_row_to_sharepoint_excel(
+        self,
+        required_headers: Optional[List[str]] = None,
+        folder_name: str = "",
+        excel_file_name: str = "",
+        sheet_name: str = "",
+        new_row: Dict = None,
+    ) -> None:
+        """
+        • Appends a row to an existing Excel file.
+        • Sorts and formats based on provided parameters.
+        """
+
+        # 1. Pull file
+        binary_file = self.fetch_file_using_open_binary(excel_file_name, folder_name)
+
+        if binary_file is None:
+            raise FileNotFoundError(f"File '{excel_file_name}' not found in folder '{folder_name}'.")
+
+        wb = load_workbook(BytesIO(binary_file))
+
+        if sheet_name not in wb.sheetnames:
+            raise ValueError(f"Sheet '{sheet_name}' not found in '{excel_file_name}'")
+
+        ws = wb[sheet_name]
+
+        # 2. Validate headers
+        if required_headers:
+            current_headers = [cell.value for cell in ws[1]]
+
+            if current_headers != required_headers:
+                raise ValueError(
+                    f"Header mismatch in sheet '{sheet_name}'!\n"
+                    f"Expected: {required_headers}\n"
+                    f"Found:    {current_headers}"
+                )
+
+        # 2.5 Clean up empty rows before appending
+        for row_idx in range(ws.max_row, 1, -1):  # Start from bottom, skip header
+            row_values = [cell.value for cell in ws[row_idx]]
+
+            if all(cell is None for cell in row_values):
+                ws.delete_rows(row_idx)
+
+        # 3. Append new row to sheet
+        ws.append([new_row.get(header.value, "") for header in ws[1]])
+
+        # 4. Save and upload
+        temp_stream = BytesIO()
+
+        wb.save(temp_stream)
+
+        temp_stream.seek(0)
+
+        self.upload_file_from_bytes(temp_stream.getvalue(), excel_file_name, folder_name)
+
+        print(f"✔ Added row + sorted '{sheet_name}' in '{excel_file_name}'.")
+
+    def format_and_sort_excel_file(
+        self,
+        folder_name: str,
+        excel_file_name: str,
+        sheet_name: str,
+        sorting_keys: Optional[List[Dict[str, Any]]] = None,
+        font_config: Optional[Dict[int, Dict[str, Any]]] = None,
+        bold_rows: Optional[List[int]] = None,
+        italic_rows: Optional[List[int]] = None,
+        align_horizontal: str = "center",
+        align_vertical: str = "center",
+        column_widths: Any = "auto",
+        freeze_panes: Optional[str] = None,
+    ):
+        """
+        Sorts and formats an Excel worksheet based on provided styling and sorting rules.
+
+        Params:
+            folder_name: Name of the folder where the file resides
+            excel_file_name: Name of the excel file
+            sheet_name: Name of the sheet that will be sorted
+            sorting_keys: List of dicts like [{"key": "A", "ascending": True, "type": "datetime"}]
+            bold_rows: List of row numbers to bold (defaults to [1])
+            italic_rows: List of row numbers to italicize
+            font_config: Dict of row -> font config (overrides bold/italic)
+            align_horizontal: Horizontal text alignment
+            align_vertical: Vertical text alignment
+            column_widths: "auto" or an int to represent a pixel value
+            freeze_panes: E.g., "A2" to freeze header row
+
+        Returns:
+            Modified worksheet
+        """
+
+        # Step 1 - Fetch the file to update from SharePoint and load it as a workbook
+        # This ensures we don't override any other sheets in the excel file
+        binary_file = self.fetch_file_using_open_binary(excel_file_name, folder_name)
+        if binary_file is None:
+            raise FileNotFoundError(f"File '{excel_file_name}' not found in folder '{folder_name}'.")
+
+        wb = load_workbook(BytesIO(binary_file))
+        if sheet_name not in wb.sheetnames:
+            raise ValueError(f"Sheet '{sheet_name}' not found in '{excel_file_name}'")
+
+        ws = wb[sheet_name]
+
+        # Step 2 - Read data into DataFrame
+        rows = list(ws.iter_rows(values_only=True))
+        header, *data_rows = rows
+        df = pd.DataFrame(data_rows, columns=header)
+
+        # Step 3 – Prepare sorting logic
+        # For each sorting instruction, we:
+        # - Extract the column to sort by (using letter, index, or name)
+        # - Convert the column values to the desired data type if specified (str, int, float, datetime)
+        # - Track which columns to sort and in which order (ascending or descending)
+        #
+        # This ensures the DataFrame is sorted correctly, even when types like dates or numbers need conversion.
+        if sorting_keys:
+            sort_columns = []
+            ascending_flags = []
+
+            for item in sorting_keys:
+                key = item.get("key")
+                ascending = item.get("ascending", True)
+                dtype = item.get("type")
+
+                if isinstance(key, int):
+                    col_name = header[key]
+
+                elif isinstance(key, str) and key.isalpha():
+                    col_name = header[ord(key.upper()) - ord("A")]
+
+                else:
+                    col_name = key
+
+                sort_columns.append(col_name)
+                ascending_flags.append(ascending)
+
+                if dtype == "datetime":
+                    df[col_name] = pd.to_datetime(df[col_name], dayfirst=True, errors="coerce")
+
+                elif dtype == "int":
+                    df[col_name] = pd.to_numeric(df[col_name], errors="coerce", downcast="integer")
+
+                elif dtype == "float":
+                    df[col_name] = pd.to_numeric(df[col_name], errors="coerce", downcast="float")
+
+                elif dtype == "str":
+                    df[col_name] = df[col_name].astype(str)
+
+            # Step 4 – Sort
+            df.sort_values(by=sort_columns, ascending=ascending_flags, inplace=True)
+
+        # Step 5 - Overwrite worksheet
+        ws.delete_rows(1, ws.max_row)
+
+        ws.append(header)
+
+        for _, row in df.iterrows():
+            ws.append(list(row))
+
+        # Step 6 – Adjust column widths and apply wrapping if needed
+        #
+        # If column_widths is "auto":
+        # - Calculate the max content length in each column and set the column width accordingly (+2 for padding)
+        #
+        # If column_widths is a single int:
+        # - Use it as a global max width across all columns
+        # - If content fits, set width based on actual content length
+        # - If content exceeds the max width clamp column width and enable wrap_text for that column's cells
+        #
+        # Then, for wrapped cells, auto-adjust the row height:
+        # - Estimate how many lines the wrapped text would occupy and set row height accordingly to ensure all content is visible
+        if column_widths in (None, "auto"):
+            for col in ws.columns:
+                max_len = max(len(str(cell.value or "")) for cell in col)
+
+                ws.column_dimensions[col[0].column_letter].width = max_len + 2
+
+        elif isinstance(column_widths, int):
+            for col in ws.columns:
+                col_letter = col[0].column_letter
+
+                max_len = max(len(str(cell.value or "")) for cell in col)
+
+                # If content fits, auto-size
+                if max_len + 2 <= column_widths:
+                    ws.column_dimensions[col_letter].width = max_len + 2
+
+                # Else, cap width and enable wrap
+                else:
+                    ws.column_dimensions[col_letter].width = column_widths
+
+                    for cell in col:
+                        cell.alignment = Alignment(wrap_text=True)
+
+            # Here we handle row height
+            for row in ws.iter_rows():
+                max_line_count = 1
+
+                for cell in row:
+                    if cell.value and cell.alignment and cell.alignment.wrap_text:
+                        col_letter = cell.column_letter
+                        col_width = ws.column_dimensions[col_letter].width or 10
+                        chars_per_line = col_width * 1.2
+                        lines = str(cell.value).split("\n")
+                        line_count = sum(math.ceil(len(line) / chars_per_line) for line in lines)
+                        max_line_count = max(max_line_count, line_count)
+
+                ws.row_dimensions[row[0].row].height = max_line_count * 20
+
+        else:
+            raise ValueError(f"Column width provided with incorrect datatype - datatype int expected, instead column width is of datatype {type(column_widths)}")
+
+        # Step 7 - Freeze panes if needed
+        if freeze_panes:
+            ws.freeze_panes = freeze_panes
+
+        # Step 8 – Apply base formatting
+        # For each cell in the worksheet:
+        # - Apply font styling based on either a custom `font_config` (row-specific) or default to bold/italic based on row number (e.g., header rows)
+        # - Set horizontal and vertical alignment for consistent layout
+        # - Disable text wrapping by default (wrapping will be handled later if needed)
+        #
+        # This ensures a clean, uniform look across the sheet while allowing for custom styling where defined.
+        for row_idx, row in enumerate(ws.iter_rows(), start=1):
+            for cell in row:
+                if font_config and row_idx in font_config:
+                    config = font_config[row_idx]
+
+                    cell.font = Font(
+                        name=config.get("name", "Calibri"),
+                        size=config.get("size", 11),
+                        bold=config.get("bold", False),
+                        italic=config.get("italic", False),
+                    )
+
+                else:
+                    cell.font = Font(
+                        bold=row_idx in bold_rows if bold_rows else False,
+                        italic=row_idx in italic_rows if italic_rows else False,
+                    )
+
+                cell.alignment = Alignment(
+                    horizontal=align_horizontal,
+                    vertical=align_vertical,
+                    wrap_text=cell.alignment.wrap_text
+                )
+
+        # Step 9 - Save and re-upload
+        temp_stream = BytesIO()
+
+        wb.save(temp_stream)
+
+        temp_stream.seek(0)
+
+        self.upload_file_from_bytes(temp_stream.getvalue(), excel_file_name, folder_name)

{mbu_dev_shared_components-2.3.0 → mbu_dev_shared_components-2.4.3}/mbu_dev_shared_components/solteqtand/application/appointment.py

@@ -276,6 +276,7 @@ class AppointmentHandler(HandlerBase):
         """
         try:
             self.open_tab("Stamkort")
+            self.open_sub_tab("Behandlingsstatus")
 
             create_booking_button = self.wait_for_control(
                 auto.PaneControl,
@@ -304,6 +305,14 @@ class AppointmentHandler(HandlerBase):
                         case "Stol":
                             child.GetPattern(auto.PatternId.ValuePattern).SetValue(booking_reminder_data["comboBoxChair"])
 
+            # Fill out text booking field
+            text_booking_field_group = manage_booking.GroupControl(AutomationId="GroupBox5")
+            for child in text_booking_field_group.GetChildren():
+                match child.AutomationId:
+                    case "TextBoxBookingText":
+                        if child.GetPattern(auto.PatternId.ValuePattern).Value != booking_reminder_data["textBoxBookingText"]:
+                            child.GetPattern(auto.PatternId.ValuePattern).SetValue(booking_reminder_data["textBoxBookingText"])
+
             # Fill out date and time
             date_and_time_group = manage_booking.GroupControl(AutomationId="GroupBox4")
 

{mbu_dev_shared_components-2.3.0 → mbu_dev_shared_components-2.4.3}/mbu_dev_shared_components/solteqtand/application/base_ui.py

@@ -23,10 +23,12 @@ class BaseUI:
         children = control.GetChildren()
 
         for child in children:
-            if (control_type is None or child.ControlType == control_type) and \
-            (automation_id is None or child.AutomationId == automation_id) and \
-            (name is None or child.Name == name) and \
-            (class_name is None or child.ClassName == class_name):
+            if (
+                (control_type is None or child.ControlType == control_type) and
+                (automation_id is None or child.AutomationId == automation_id) and
+                (name is None or child.Name == name) and
+                (class_name is None or child.ClassName == class_name)
+            ):
                 return child
 
             found = self.find_element_by_property(child, control_type, automation_id, name, class_name)
@@ -96,5 +98,19 @@ class BaseUI:
         raise TimeoutError(f"Control with parameters {search_params} did not disappear within the timeout period.")
 
     def close_window(self, window_to_close: auto.WindowControl) -> None:
-        """Closes specified window by sending CTRL+F4 keystroke."""
-        window_to_close.SendKeys(text="^({F4})")
+        """Closes specified window."""
+        window_name = window_to_close.Name
+        window_to_close.SetFocus()
+        window_to_close.GetWindowPattern().Close()
+
+        # Handle popup when closin main window
+        if window_name.lower().startswith("hovedvindue"):
+
+            pop_up_window = window_to_close.WindowControl(Name="TMT - Afslut")
+            pop_up_window.SetFocus()
+            pop_up_window.ButtonControl(Name="Ja").Click(simulateMove=False, waitTime=0)
+
+            time.sleep(2)
+
+        else:
+            self.app_window = self.wait_for_control(search_params={'AutomationId': 'FormFront'}, control_type=auto.WindowControl)

{mbu_dev_shared_components-2.3.0 → mbu_dev_shared_components-2.4.3}/mbu_dev_shared_components/solteqtand/application/document.py

@@ -5,6 +5,7 @@ import time
 import psutil
 from docx2pdf import convert
 import uiautomation as auto
+from datetime import datetime
 
 from .handler_base import HandlerBase
 
@@ -96,6 +97,8 @@ class DocumentHandler(HandlerBase):
         Under “Print/Flet patienter” → select template → merge → wait for Word to open,
         convert to PDF, kill WINWORD.EXE, then create_document() with the new PDF.
         """
+        folder_path = rf"{os.environ.get('USERPROFILE')}\AppData\Local\Temp\Care\TMTand"
+
         try:
             self.open_tab("Stamkort")
 
@@ -168,7 +171,6 @@ class DocumentHandler(HandlerBase):
             if new_value != metadata['templateName']:
                 raise ValueError(f"Failed to set the correct status. Expected '{metadata['templateName']}', but got '{new_value}'.")
 
-            folder_path = rf"{os.environ.get('USERPROFILE')}\AppData\Local\Temp\Care\TMTand"
             shutil.rmtree(folder_path, ignore_errors=True)
 
             form_mail_merge.PaneControl(AutomationId="ButtonMerge").GetLegacyIAccessiblePattern().DoDefaultAction()

{mbu_dev_shared_components-2.3.0 → mbu_dev_shared_components-2.4.3}/mbu_dev_shared_components/solteqtand/application/edi_portal.py

@@ -28,6 +28,8 @@ class EDIHandler(HandlerBase):
             )
             journalforsendelse_button.Click(simulateMove=False, waitTime=0)
 
+            time.sleep(5)
+
         except Exception as e:
             print(f"Error while opening EDI Portal: {e}")
 
@@ -70,7 +72,7 @@ class EDIHandler(HandlerBase):
             if not next_button:
                 try:
                     next_button = self.wait_for_control(
-                        auto.ButtonControl, {"Name": "patientInformationNextButton"},
+                        auto.ButtonControl, {"AutomationId": "patientInformationNextButton"},
                         search_depth=50,
                         timeout=5
                     )
@@ -97,6 +99,14 @@ class EDIHandler(HandlerBase):
             dict: A dictionary containing the row count and whether the phone number matches.
         """
         try:
+            # Handle Hasle Torv Clinic special case
+            if extern_clinic_data[0]["contractorId"] == "477052" or extern_clinic_data[0]["contractorId"] == "470678":
+                contractor_id = "485055"
+                clinic_phone_number = "86135240"
+            else:
+                contractor_id = extern_clinic_data[0]["contractorId"]
+                clinic_phone_number = extern_clinic_data[0]["phoneNumber"]
+
             self.edi_portal_click_next_button(sleep_time=2)
 
             class_options = [
@@ -120,7 +130,7 @@ class EDIHandler(HandlerBase):
                     raise RuntimeError("Search box not found")
             search_box.SetFocus()
             search_box_value_pattern = search_box.GetPattern(auto.PatternId.ValuePattern)
-            search_box_value_pattern.SetValue(extern_clinic_data[0]["contractorId"])
+            search_box_value_pattern.SetValue(contractor_id)
             search_box.SendKeys("{ENTER}")
 
             time.sleep(sleep_time)
@@ -134,10 +144,14 @@ class EDIHandler(HandlerBase):
             row_count = grid_pattern.RowCount
 
             is_phone_number_match = False
+
+            if grid_pattern.GetItem(1, 0).Name == "Ingen data i tabellen":
+                return {"rowCount": 0, "isPhoneNumberMatch": False}
+
             if row_count > 0:
                 for row in range(row_count):
                     phone_number = grid_pattern.GetItem(row, 4).Name
-                    if phone_number == extern_clinic_data[0]["phoneNumber"]:
+                    if phone_number == clinic_phone_number:
                         is_phone_number_match = True
                         break
             return {"rowCount": row_count, "isPhoneNumberMatch": is_phone_number_match}

{mbu_dev_shared_components-2.3.0 → mbu_dev_shared_components-2.4.3}/mbu_dev_shared_components/solteqtand/application/patient.py

@@ -112,13 +112,14 @@ class PatientHandler(HandlerBase):
             TimeoutError: If the patient window does not close within the expected time.
         """
 
-        title_bar_window = self.app_window.TitleBarControl()
-        title_bar_window.ButtonControl(Name="Luk").Click(simulateMove=False, waitTime=0)
+        self.app_window.SetFocus()
+        self.app_window.GetWindowPattern().Close()
 
         self.app_window = self.wait_for_control_to_disappear(
             auto.WindowControl,
             {'AutomationId': 'FormPatient'},
-            search_depth=2
+            search_depth=2,
+            timeout=30
         )
 
         self.app_window = self.wait_for_control(
@@ -127,6 +128,7 @@ class PatientHandler(HandlerBase):
             search_depth=2,
             timeout=5
         )
+        self.app_window.SetFocus()
 
     def change_status(self, status: str) -> None:
         """