mbu-dev-shared-components 2.4.2__tar.gz → 2.4.4__tar.gz

{mbu_dev_shared_components-2.4.2 → mbu_dev_shared_components-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbu_dev_shared_components
-Version: 2.4.2
+Version: 2.4.4
 Summary: Shared components to use in RPA projects
 Author-email: MBU <rpa@mbu.aarhus.dk>
 License-Expression: MIT
@@ -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.4.2 → mbu_dev_shared_components-2.4.4}/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.4.2 → mbu_dev_shared_components-2.4.4}/mbu_dev_shared_components/solteqtand/application/base_ui.py

@@ -99,11 +99,18 @@ class BaseUI:
 
     def close_window(self, window_to_close: auto.WindowControl) -> None:
         """Closes specified window."""
+        window_name = window_to_close.Name
         window_to_close.SetFocus()
         window_to_close.GetWindowPattern().Close()
 
-        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)
+        # Handle popup when closin main window
+        if window_name.lower().startswith("hovedvindue"):
 
-        time.sleep(2)
+            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.4.2 → mbu_dev_shared_components-2.4.4}/mbu_dev_shared_components/solteqtand/application/document.py

@@ -97,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")
 
@@ -169,8 +171,8 @@ 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)
+            if os.path.exists(folder_path):
+                shutil.rmtree(folder_path, ignore_errors=True)
 
             form_mail_merge.PaneControl(AutomationId="ButtonMerge").GetLegacyIAccessiblePattern().DoDefaultAction()
 
@@ -229,7 +231,8 @@ class DocumentHandler(HandlerBase):
             print(f"Error while creating document from template: {e}")
             raise
         finally:
-            shutil.rmtree(folder_path, ignore_errors=True)
+            if os.path.exists(folder_path):
+                shutil.rmtree(folder_path, ignore_errors=True)
 
     def send_discharge_document_digitalpost(self, metadata: dict) -> None:
         """

mbu_dev_shared_components-2.4.4/mbu_dev_shared_components/tests/go_tests/go_integration_tests.py

@@ -0,0 +1,278 @@
+"""
+Integration tests for the GetOrganized API.
+
+These tests validate the following key functionalities:
+1. Authentication success using CPR lookup
+2. Contact lookup returns correct citizen profile
+3. Retrieval of metadata for a specific case (Borgermappe)
+4. Case lookup using case properties
+5. Document metadata retrieval
+6. Document search (legacy and modern search APIs)
+
+Expected to run daily to ensure API stability and data consistency.
+
+Required environment variables:
+- GO_API_ENDPOINT:        Base URL for GetOrganized API
+- GO_API_USERNAME:        API username for authentication
+- GO_API_PASSWORD:        API password
+- DADJ_FULL_NAME:         Full name of test citizen
+- DADJ_SSN:               CPR number of test citizen
+- DADJ_GO_ID:             Internal ID of test citizen in GO
+- DADJ_BORGERMAPPE_SAGS_ID: Case ID of the test citizen's "Borgermappe"
+"""
+
+import os
+import xml.etree.ElementTree as ET
+import requests
+import pytest
+
+from mbu_dev_shared_components.getorganized import contacts
+from mbu_dev_shared_components.getorganized import cases
+from mbu_dev_shared_components.getorganized import documents
+from mbu_dev_shared_components.getorganized import objects
+
+
+# -------------------------------
+# Helper to load environment vars safely
+# -------------------------------
+def _get_cfg(key: str) -> str:
+    val = os.getenv(key)
+
+    if not val:
+        pytest.skip(f"env var '{key}' not set → skipping integration test")
+
+    return val
+
+
+@pytest.fixture(scope="module")
+def go_env():
+    """
+    Loads required environment variables for the GetOrganized API tests.
+    Skips tests if any required variable is missing.
+    """
+
+    return {
+        "endpoint": _get_cfg("GO_API_ENDPOINT"),
+        "username": _get_cfg("GO_API_USERNAME"),
+        "password": _get_cfg("GO_API_PASSWORD"),
+        "full_name": _get_cfg("DADJ_FULL_NAME"),
+        "ssn": _get_cfg("DADJ_SSN"),
+        "go_id": _get_cfg("DADJ_GO_ID"),
+        "case_id": _get_cfg("DADJ_BORGERMAPPE_SAGS_ID"),
+    }
+
+
+def test_authentication_success(go_env):
+    """
+    Ensures valid credentials can access the API without 401/403.
+    """
+
+    resp = contacts.contact_lookup(
+        person_ssn=go_env["ssn"],
+        api_endpoint=f"{go_env['endpoint']}/_goapi/contacts/readitem",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    assert resp.status_code != 401
+    assert resp.status_code != 403
+    assert resp.ok
+
+
+def test_contact_lookup_returns_expected_name(go_env):
+    """
+    Verifies that contact lookup returns correct full name, ID, and CPR.
+    """
+
+    resp = contacts.contact_lookup(
+        person_ssn=go_env["ssn"],
+        api_endpoint=f"{go_env['endpoint']}/_goapi/contacts/readitem",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    assert resp.ok
+
+    data = resp.json()
+
+    assert data["FullName"] == go_env["full_name"]
+    assert data["ID"] == go_env["go_id"]
+    assert data["CPR"] == go_env["ssn"]
+
+
+def test_case_metadata_structure(go_env):
+    """
+    Validates the metadata structure of a known 'Borgermappe' case.
+    """
+
+    resp = cases.get_case_metadata(
+        api_endpoint=f"{go_env['endpoint']}/_goapi/Cases/Metadata/{go_env['case_id']}",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    assert resp.ok
+
+    # Extract XML metadata and parse attributes
+    resp_metadata_xml = resp.json().get("Metadata")
+
+    assert resp_metadata_xml
+
+    data = ET.fromstring(resp_metadata_xml).attrib
+
+    assert data["ows_CaseID"] == go_env["case_id"]
+
+    assert data["ows_CaseCategory"] == "Borgermappe"
+
+    assert data["ows_CCMContactData"] == f"{go_env['full_name']};#{go_env['go_id']};#{go_env['ssn']};#;#"
+
+    assert data["ows_CCMContactData_CPR"] == go_env["ssn"]
+
+
+def test_find_case_by_case_properties(go_env):
+    """
+    Searches for a case using known properties of the test citizen.
+    """
+
+    case_data_json = objects.CaseDataJson()
+
+    case_data = case_data_json.search_citizen_folder_data_json(
+        case_type_prefix="BOR",
+        person_full_name=go_env["full_name"],
+        person_id=go_env["go_id"],
+        person_ssn=go_env["ssn"]
+    )
+
+    resp = cases.find_case_by_case_properties(
+        case_data=case_data,
+        api_endpoint=f"{go_env['endpoint']}/_goapi/Cases/FindByCaseProperties",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    assert resp.ok
+
+    data = resp.json().get("CasesInfo")
+
+    assert isinstance(data, list)
+
+    assert len(data) == 1
+
+    assert data[0].get("CaseID") == go_env["case_id"]
+
+
+def test_get_document_metadata(go_env):
+    """
+    Fetches metadata for a known document tied to the test citizen.
+    """
+    document_id = 14583373  # ID must be valid for test profile
+
+    resp = documents.get_document_metadata(
+        api_endpoint=f"{go_env['endpoint']}/_goapi/Documents/Metadata/{document_id}",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    assert resp.ok
+
+    data = ET.fromstring(resp.json().get("Metadata")).attrib
+
+    assert "ows_Title" in data
+
+
+def test_search_documents(go_env):
+    """
+    Performs a legacy document search using full name + CPR.
+    """
+
+    search_term = f"{go_env['full_name']} {go_env['ssn']}"
+
+    resp = documents.search_documents(
+        search_term=search_term,
+        api_endpoint=f"{go_env['endpoint']}/_goapi/Search/Results",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    assert resp.ok
+
+    results = resp.json().get("Rows").get("Results")
+    total_rows = resp.json().get("TotalRows")
+
+    assert isinstance(results, list)
+
+    if total_rows == 0:
+        assert len(results) == 0
+
+    else:
+        assert len(results) == total_rows
+
+        for doc in results:
+            assert "title" in doc
+            assert "created" in doc
+            assert "caseid" in doc
+
+
+def _validate_modern_search_response(resp: requests.Response):
+    """
+    Helper: Validates structure of modern search response.
+    """
+
+    assert resp.ok
+
+    json_data = resp.json()
+
+    results = json_data.get("results", {}).get("Results", [])
+
+    total_rows = json_data.get("totalRows")
+
+    assert isinstance(results, list)
+
+    if total_rows == 0:
+        assert len(results) == 0
+
+    else:
+        assert len(results) == total_rows
+        for doc in results:
+
+            assert "title" in doc
+            assert "created" in doc
+            assert "caseid" in doc
+
+
+def test_modern_search(go_env):
+    """
+    Runs two modern searches: one without date filter, one with date filter.
+    """
+
+    search_term = f"{go_env['full_name']} {go_env['ssn']}"
+
+    # Search 1: All-time
+    resp_1 = documents.modern_search(
+        page_index=0,
+        search_term=search_term,
+        start_date=None,
+        end_date=None,
+        only_items=False,
+        case_type_prefix="BOR",
+        api_endpoint=f"{go_env['endpoint']}/_goapi/search/ExecuteModernSearch",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    # Search 2: Specific March 2025 range
+    resp_2 = documents.modern_search(
+        page_index=0,
+        search_term=search_term,
+        start_date="2025-03-01",
+        end_date="2025-03-31",
+        only_items=False,
+        case_type_prefix="BOR",
+        api_endpoint=f"{go_env['endpoint']}/_goapi/search/ExecuteModernSearch",
+        api_username=go_env["username"],
+        api_password=go_env["password"],
+    )
+
+    _validate_modern_search_response(resp_1)
+
+    _validate_modern_search_response(resp_2)

mbu_dev_shared_components-2.4.4/mbu_dev_shared_components/tests/go_tests/objects_tests.py

@@ -0,0 +1,124 @@
+"""
+Unit tests for data structure creation methods in CaseDataJson.
+These are pure functions that return formatted dictionaries, used in API requests.
+
+Should run on pull requests to ensure the data structure is correct.
+"""
+
+import pytest
+from mbu_dev_shared_components.getorganized.objects import CaseDataJson
+
+
+@pytest.fixture
+def case_data_handler():
+    """
+    Fixture to provide an instance of CaseDataJson for testing.
+    """
+    return CaseDataJson()
+
+
+def test_search_citizen_folder_data_json(case_data_handler: CaseDataJson):
+    """
+    Ensure that the search_citizen_folder_data_json method correctly builds
+    a search structure for a citizen's full data and filters by 'Borgermappe' case category.
+    """
+
+    result = case_data_handler.search_citizen_folder_data_json(
+        case_type_prefix="BOR",
+        person_full_name="Test Person",
+        person_id="12345",
+        person_ssn="0101011234"
+    )
+
+    assert result["LogicalOperator"] == "AND"
+    assert result["ExcludeDeletedCases"] == "True"
+    assert result["ReturnCasesNumber"] == "1"
+
+    assert {
+        "InternalName": "ows_CCMContactData",
+        "Value": "Test Person;#12345;#0101011234;#;#",
+        "DataType": "Text",
+        "ComparisonType": "Equal",
+        "IsMultiValue": "False"
+    } in result["FieldProperties"]
+
+    assert {
+        "InternalName": "ows_CaseCategory",
+        "Value": "Borgermappe",
+        "DataType": "Text",
+        "ComparisonType": "Equal",
+        "IsMultiValue": "False"
+    } in result["FieldProperties"]
+
+
+def test_generic_search_case_data_json_with_name_and_extra_field(case_data_handler: CaseDataJson):
+    """
+    Ensure that generic_search_case_data_json assembles a correct structure when using:
+    - a custom case_type_prefix,
+    - a non-default number of return cases,
+    - full citizen data,
+    - and extra field properties.
+    """
+
+    field_properties = {
+        "ows_Title": "Lønbilag"
+    }
+
+    result = case_data_handler.generic_search_case_data_json(
+        case_type_prefix="PER",
+        person_full_name="Test Person",
+        person_id="12345",
+        person_ssn="0101011234",
+        include_name=True,
+        returned_cases_number="5",
+        field_properties=field_properties
+    )
+
+    assert result["CaseTypePrefixes"] == ["PER"]
+
+    assert {
+        "InternalName": "ows_CCMContactData",
+        "Value": "Test Person;#12345;#0101011234;#;#",
+        "DataType": "Text",
+        "ComparisonType": "Equal",
+        "IsMultiValue": "False"
+    } in result["FieldProperties"]
+
+    assert result["ReturnCasesNumber"] == "5"
+
+    assert {
+        "InternalName": "ows_Title",
+        "Value": "Lønbilag",
+        "DataType": "Text",
+        "ComparisonType": "Equal",
+        "IsMultiValue": "False"
+    } in result["FieldProperties"]
+
+
+def test_generic_search_case_data_json_without_name(case_data_handler: CaseDataJson):
+    """
+    Ensure that generic_search_case_data_json builds correct contact data when include_name=False,
+    and only includes one field (ows_CCMContactData) by default when no additional fields are passed.
+    """
+
+    result = case_data_handler.generic_search_case_data_json(
+        case_type_prefix="BOR",
+        person_full_name="Daniel Tester",
+        person_id="12345",
+        person_ssn="0101011234",
+        include_name=False
+    )
+
+    assert result["CaseTypePrefixes"] == ["BOR"]
+
+    assert {
+        "InternalName": "ows_CCMContactData",
+        "Value": ";#12345;#0101011234;#;#",
+        "DataType": "Text",
+        "ComparisonType": "Equal",
+        "IsMultiValue": "False"
+    } in result["FieldProperties"]
+
+    assert result["ReturnCasesNumber"] == "1"
+
+    assert len(result["FieldProperties"]) == 1

mbu_dev_shared_components-2.4.4/mbu_dev_shared_components/tests/msoffice_tests/msoffice_integration_tests.py

@@ -0,0 +1,188 @@
+"""
+Integration tests for verifying Microsoft Office Excel functionality through SharePoint.
+
+Tests included:
+1. `test_list_files_from_sharepoint_folder`:
+   - Verifies that a known test Excel file exists in the SharePoint folder.
+
+2. `test_append_row_to_excel`:
+   - Appends a row to a specific sheet in the Excel file.
+   - Verifies the row was successfully added.
+
+3. `test_format_and_sort_excel_file`:
+   - Sorts the Excel sheet by date/time (descending).
+   - Applies formatting (bold headers, auto column widths).
+   - Verifies that sorting has changed the order.
+
+Important constants:
+- FOLDER_NAME = "MSOffice tests"
+- FILE_NAME = "Test_Append_Rows.xlsx"
+- SHEET_NAME = "Upload logs"
+- HEADERS = ["Upload date", "Upload time"]
+
+Requires environment variables:
+- MSOFFICE_USERNAME
+- MSOFFICE_PASSWORD
+"""
+
+import os
+import datetime
+
+from io import BytesIO
+
+import pytest
+import openpyxl
+
+from mbu_dev_shared_components.msoffice365.sharepoint_api.files import Sharepoint
+
+FOLDER_NAME = "MSOffice tests"
+CURRENT_DATE = datetime.datetime.now().strftime("%d-%m-%Y")
+CURRENT_TIME = datetime.datetime.now().strftime("%H:%M")
+
+
+@pytest.fixture(scope="module")
+def sharepoint_api():
+    """
+    Authenticates with SharePoint and returns a Sharepoint API instance.
+    Skips test if required environment variables are missing.
+    """
+
+    def _get_cfg(key: str) -> str:
+        val = os.getenv(key)
+
+        if not val:
+            pytest.skip(f"env var '{key}' not set → skipping integration test")
+
+        return val
+
+    username = _get_cfg("MSOFFICE_USERNAME")
+    password = _get_cfg("MSOFFICE_PASSWORD")
+
+    site_url = "https://aarhuskommune.sharepoint.com"
+    site_name = "MBURPA"
+    document_library = "Delte dokumenter"
+
+    sp = Sharepoint(
+        username=username,
+        password=password,
+        site_url=site_url,
+        site_name=site_name,
+        document_library=document_library
+    )
+
+    assert sp.ctx is not None, "SharePoint authentication failed"
+
+    return sp
+
+
+@pytest.mark.dependency(name="list_files")
+def test_list_files_from_sharepoint_folder(sharepoint_api: Sharepoint):
+    """
+    Test 1: Check that the expected Excel file exists in the SharePoint folder.
+    """
+
+    files = sharepoint_api.fetch_files_list(FOLDER_NAME)
+
+    file_names = [f["Name"] for f in files]
+
+    assert "Test_Append_Rows.xlsx" in file_names
+
+
+@pytest.mark.dependency(name="append_row", depends=["list_files"])
+def test_append_row_to_excel(sharepoint_api: Sharepoint):
+    """
+    Test 2: Append a row to the Excel file and verify it was added correctly.
+    """
+
+    file_name = "Test_Append_Rows.xlsx"
+
+    sheet_name = "Upload logs"
+
+    headers = ["Upload date", "Upload time"]
+
+    data = {
+        "Upload date": CURRENT_DATE,
+        "Upload time": CURRENT_TIME
+    }
+
+    # Append the row to the SharePoint-hosted Excel file
+    sharepoint_api.append_row_to_sharepoint_excel(
+        required_headers=headers,
+        folder_name=FOLDER_NAME,
+        excel_file_name=file_name,
+        sheet_name=sheet_name,
+        new_row=data,
+    )
+
+    # Fetch the updated file and check that the last row matches the new data
+    binary_file = sharepoint_api.fetch_file_using_open_binary(file_name, FOLDER_NAME)
+
+    wb = openpyxl.load_workbook(BytesIO(binary_file))
+
+    ws = wb[sheet_name]
+
+    newest_row = list(ws.iter_rows(values_only=True))[-1]
+
+    assert newest_row[0] == CURRENT_DATE
+    assert newest_row[1] == CURRENT_TIME
+
+
+@pytest.mark.dependency(depends=["append_row"])
+def test_format_and_sort_excel_file(sharepoint_api: Sharepoint):
+    """
+    Test 3: Format and sort the Excel file by date and time.
+    Ensures that sorting changes the order and formatting is applied.
+    """
+
+    file_name = "Test_Append_Rows.xlsx"
+
+    sheet_name = "Upload logs"
+
+    # Download the file before sorting to capture original row order
+    test_file = sharepoint_api.fetch_file_using_open_binary(file_name, FOLDER_NAME)
+
+    wb = openpyxl.load_workbook(BytesIO(test_file))
+
+    ws = wb[sheet_name]
+
+    all_rows = list(ws.iter_rows(values_only=True))
+
+    top_before = all_rows[1]      # First data row
+
+    bottom_before = all_rows[-1]  # Last data row
+
+    # Sort by first two columns (date, time) in descending order
+    sorting_keys = [
+        {"key": "A", "ascending": False, "type": "str"},
+        {"key": "B", "ascending": False, "type": "str"},
+    ]
+
+    # Apply sorting and formatting
+    sharepoint_api.format_and_sort_excel_file(
+        folder_name=FOLDER_NAME,
+        excel_file_name=file_name,
+        sheet_name=sheet_name,
+        sorting_keys=sorting_keys,
+        bold_rows=[1],
+        column_widths="auto",
+    )
+
+    # Re-fetch the file after sorting and verify order has changed
+    test_file = sharepoint_api.fetch_file_using_open_binary(file_name, FOLDER_NAME)
+
+    wb = openpyxl.load_workbook(BytesIO(test_file))
+
+    ws = wb[sheet_name]
+
+    all_rows = list(ws.iter_rows(values_only=True))
+
+    top_after = all_rows[1]
+
+    bottom_after = all_rows[-1]
+
+    # Check that sorting actually changed the row order
+    assert top_before != top_after
+    assert bottom_before != bottom_after
+
+    # Check that the top row after sorting is the one just added
+    assert top_after[0] == CURRENT_DATE

{mbu_dev_shared_components-2.4.2 → mbu_dev_shared_components-2.4.4}/mbu_dev_shared_components.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbu_dev_shared_components
-Version: 2.4.2
+Version: 2.4.4
 Summary: Shared components to use in RPA projects
 Author-email: MBU <rpa@mbu.aarhus.dk>
 License-Expression: MIT
@@ -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.4.2 → mbu_dev_shared_components-2.4.4}/mbu_dev_shared_components.egg-info/SOURCES.txt

@@ -49,6 +49,9 @@ mbu_dev_shared_components/solteqtand/application/journal_note.py
 mbu_dev_shared_components/solteqtand/application/patient.py
 mbu_dev_shared_components/solteqtand/database/__init__.py
 mbu_dev_shared_components/solteqtand/database/db_handler.py
+mbu_dev_shared_components/tests/go_tests/go_integration_tests.py
+mbu_dev_shared_components/tests/go_tests/objects_tests.py
+mbu_dev_shared_components/tests/msoffice_tests/msoffice_integration_tests.py
 mbu_dev_shared_components/utils/__init__.py
 mbu_dev_shared_components/utils/db_stored_procedure_executor.py
 mbu_dev_shared_components/utils/fernet_encryptor.py

{mbu_dev_shared_components-2.4.2 → mbu_dev_shared_components-2.4.4}/mbu_dev_shared_components.egg-info/requires.txt

@@ -8,4 +8,9 @@ uiautomation
 pillow
 psutil
 docx2pdf
+pandas>=2.2.3
 rawpy
+
+[dev]
+pytest>=7.0
+pytest-dependency>=0.5.1

{mbu_dev_shared_components-2.4.2 → mbu_dev_shared_components-2.4.4}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mbu_dev_shared_components"
-version = "2.4.2"  # Specify the version manually here
+version = "2.4.4"  # Specify the version manually here
 authors = [
   { name="MBU", email="rpa@mbu.aarhus.dk" },
 ]
@@ -31,5 +31,12 @@ dependencies = [
   "pillow",
   "psutil",
   "docx2pdf",
+  "pandas >= 2.2.3",
   "rawpy",
 ]
+
+[project.optional-dependencies]
+dev = [
+  "pytest >= 7.0",
+  "pytest-dependency >= 0.5.1"
+]