medicentrev3-auth 1.0.0__tar.gz

medicentrev3_auth-1.0.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: medicentrev3-auth
+Version: 1.0.0
+Summary: Authentication and navigation module for MedicentreV3 automation
+Author-email: Denis Ndiritu <denis@hanmak.co.ke>
+License: MIT
+Project-URL: Homepage, https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: selenium>=4.0.0
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: webdriver-manager>=3.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+
+# MedicentreV3 Authentication Package
+
+A reusable Python package for MedicentreV3 authentication and navigation.
+
+## Installation
+
+```bash
+# Install from GitHub
+pip install git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+# For development
+pip install -e git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+## Updating the Package
+
+When updates are available, users should upgrade using:
+
+```bash
+# Upgrade to latest version
+pip install --upgrade git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+# Or reinstall (force latest)
+pip install --force-reinstall git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+```
+
+**Important**: Always use `--upgrade` or `--force-reinstall` when updating from GitHub to ensure you get the latest changes.

medicentrev3_auth-1.0.0/README.md

@@ -0,0 +1,26 @@
+# MedicentreV3 Authentication Package
+
+A reusable Python package for MedicentreV3 authentication and navigation.
+
+## Installation
+
+```bash
+# Install from GitHub
+pip install git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+# For development
+pip install -e git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+## Updating the Package
+
+When updates are available, users should upgrade using:
+
+```bash
+# Upgrade to latest version
+pip install --upgrade git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+# Or reinstall (force latest)
+pip install --force-reinstall git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+```
+
+**Important**: Always use `--upgrade` or `--force-reinstall` when updating from GitHub to ensure you get the latest changes.

medicentrev3_auth-1.0.0/medicentrev3_auth/__init__.py

@@ -0,0 +1,18 @@
+"""
+MedicentreV3 Authentication Package
+
+Provides reusable login, navigation, and session handling
+for MedicentreV3 IHMIS automation.
+"""
+
+from .auth import (
+    MedicentreAuth,
+    create_auth_session,
+    quick_login,
+)
+
+__all__ = [
+    "MedicentreAuth",
+    "create_auth_session",
+    "quick_login",
+]

medicentrev3_auth-1.0.0/medicentrev3_auth/auth.py

@@ -0,0 +1,890 @@
+"""
+MedicentreV3 Authentication & Navigation Module
+===============================================
+
+A reusable module for MedicentreV3 login and navigation that can be imported
+into multiple automation scripts.
+
+Features:
+1. Handles MedicentreV3 login flow (facility code, branch selection, credentials)
+2. Provides flexible navigation to modules and panels
+3. Manages WebDriver setup and teardown
+4. Includes error handling and screenshot capabilities
+5. Supports environment variables and configuration
+
+Usage:
+    from medicentre_auth import MedicentreAuth
+    
+    # Create auth instance
+    auth = MedicentreAuth(headless=False)
+    
+    # Setup and login
+    if auth.setup_and_login():
+        # Navigate to a module panel
+        if auth.navigate_to('procurement', 'suppliers'):
+            # Your module-specific automation here
+            pass
+        # Always logout when done
+        auth.logout()
+
+Configuration:
+    Set environment variables in .env file:
+    MEDICENTRE_BASE_URL=https://medicentrev3.hanmak.co.ke
+    MEDICENTRE_ACCESS_CODE=your_access_code
+    MEDICENTRE_BRANCH=your_branch_name
+    MEDICENTRE_USERNAME=your_username
+    MEDICENTRE_PASSWORD=your_password
+"""
+
+import os
+import sys
+import time
+import logging
+from datetime import datetime
+from typing import Dict, Optional, List, Tuple, Union
+from pathlib import Path
+
+# Selenium imports
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait, Select
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import (
+    TimeoutException,
+    NoSuchElementException,
+    ElementNotInteractableException
+)
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.action_chains import ActionChains
+from selenium.webdriver.common.keys import Keys
+from webdriver_manager.chrome import ChromeDriverManager
+
+# Environment configuration
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure module logger
+logger = logging.getLogger(__name__)
+
+
+class MedicentreAuth:
+    """Reusable authentication and navigation module for MedicentreV3."""
+    
+    def __init__(self, headless: bool = False, base_dir: str = "."):
+        """
+        Initialize the authentication module.
+        
+        Args:
+            headless: Run browser in headless mode (default: False)
+            base_dir: Base directory for logs and screenshots (default: current directory)
+        """
+        self.driver = None
+        self.wait = None
+        self.headless = headless
+        self.base_dir = base_dir
+        
+        # Configuration from environment
+        self.base_url = os.getenv('MEDICENTRE_BASE_URL', 'https://medicentrev3.hanmak.co.ke')
+        self.accesscode = os.getenv('MEDICENTRE_ACCESS_CODE', '')
+        self.branch = os.getenv('MEDICENTRE_BRANCH', '')
+        self.username = os.getenv('MEDICENTRE_USERNAME', '')
+        self.password = os.getenv('MEDICENTRE_PASSWORD', '')
+        
+        # Create directories if they don't exist
+        self._setup_directories()
+        
+        # Common page elements
+        self.elements = {
+            # Login page elements
+            'access_code': (By.ID, 'hospCode'),
+            'proceed_button': (By.ID, 'btnProceed'),
+            'branch_select': (By.ID, 'CompanyBranchID'),
+            'login_username': (By.ID, 'userName'),
+            'login_password': (By.ID, 'userPassword'),
+            'login_button': (By.ID, 'btnLogin'),
+            
+            # Navigation elements
+            'billing_module': (By.XPATH, "//a[normalize-space()='Billing']"),
+            'clinical_module': (By.XPATH, "//a[normalize-space()='Clinical']"),
+            'cds_tools_module': (By.XPATH, "//a[normalize-space()='CDS Tools']"),
+            'maternity_module': (By.XPATH, "//a[normalize-space()='Maternity']"),
+            'dialysis_module': (By.XPATH, "//a[normalize-space()='Dialysis']"),
+            'procurement_module': (By.XPATH, "//a[normalize-space()='Procurement']"),
+            'inventory_module': (By.XPATH, "//a[@href='#'][normalize-space()='Inventory']"),
+            'accounts_module': (By.XPATH, "//a[normalize-space()='Accounts']"),
+            'human_resource_module': (By.XPATH, "//a[normalize-space()='Human Resource']"),
+            'security_module': (By.XPATH, "//a[normalize-space()='Security']"),
+            'configuration_module': (By.XPATH, "//a[normalize-space()='Configuration']"),
+            'morgue_module': (By.XPATH, "//a[normalize-space()='Morgue']"),
+            'communication_module': (By.XPATH, "//a[normalize-space()='Communication']"),
+            
+            # Module PANELS
+            # Procurement panels
+            'procurement.suppliers': (By.XPATH, "//a[normalize-space()='Suppliers']"),
+            'procurement.supplier_bills': (By.XPATH, "//a[normalize-space()='Supplier Bills(A/P Invoices)']"),
+            'procurement.purchase_requisition_note': (By.XPATH, "//a[normalize-space()='Purchase Requisition Note']"),
+            'procurement.purchase_orders': (By.XPATH, "//a[normalize-space()='Purchase Orders']"),
+            'procurement.goods_received_notes': (By.XPATH, "//a[normalize-space()='Goods Received Notes']"),
+            'procurement.ap_payment_vouchers': (By.XPATH, "//a[normalize-space()='A/P Payment Vouchers']"),
+            'procurement.supplier_prepayments': (By.XPATH, "//a[normalize-space()='Supplier Prepayments']"),
+            
+            # Inventory panels
+            'inventory.inventory': (By.XPATH, "//a[@href='/Inventory/Inventory']"),
+            'inventory.unit_of_measure': (By.XPATH, "//a[normalize-space()='Unit Of Measure']"),
+            
+            # Accounts panels
+            'accounts.ledger_accounts': (By.XPATH, "//a[normalize-space()='Ledger Accounts']"),
+            'accounts.payment_modes': (By.XPATH, "//a[normalize-space()='Payment Modes']"),
+            'accounts.banks': (By.XPATH, "//a[contains(text(),'Banks')]"),
+            'accounts.schemes': (By.XPATH, "//a[contains(text(),'Schemes')]"),
+            'accounts.taxes': (By.XPATH, "//a[normalize-space()='Taxes']"),
+            
+            # Human Resource panels
+            'human_resource.consultants': (By.XPATH, "//a[normalize-space()='Consultants']"),
+            'human_resource.employees': (By.XPATH, "//a[normalize-space()='Employees']"),
+            'human_resource.tax_ranges': (By.XPATH, "//a[normalize-space()='PAYE Tax Ranges']"),
+            
+            # Security panels
+            'security.user_roles': (By.XPATH, "//a[normalize-space()='User Roles']"),
+            'security.privileges': (By.XPATH, "//a[normalize-space()='Privileges']"),
+            'security.system_users': (By.XPATH, "//a[normalize-space()='System Users']"),
+            
+            # Configuration panels
+            'configuration.services': (By.XPATH, "//a[normalize-space()='Services']"),
+            'configuration.rooms': (By.XPATH, "//a[normalize-space()='Rooms']"),
+            'configuration.ward_beds': (By.XPATH, "//a[normalize-space()='Ward Beds']"),
+            'configuration.departments': (By.XPATH, "//a[normalize-space()='Departments']"),
+            'configuration.storage_locations': (By.XPATH, "//a[normalize-space()='Storage Location']"),
+            'configuration.medical_clinics': (By.XPATH, "//a[normalize-space()='Medical Clinics']"),
+            
+            # Dashboard verification
+            'dashboard_element': (By.XPATH, "//h5[normalize-space()='My Appointments']"),
+            
+            # User menu/logout
+            'user_menu': (By.XPATH, f"//a[@title='User: {self.username}']"),
+            'logout_button': (By.XPATH, "//a[normalize-space()='Logout']"),
+        }
+        
+        # Module aliases for easier access (optional but useful)
+        self.module_aliases = {
+            # Short names for modules
+            'proc': 'procurement',
+            'inv': 'inventory',
+            'acc': 'accounts',
+            'hr': 'human_resource',
+            'sec': 'security',
+            'config': 'configuration',
+            
+            # Panel shortcuts
+            'supp': 'suppliers',
+            'bills': 'supplier_bills',
+            'prn': 'purchase_requisition_note',
+            'po': 'purchase_orders',
+            'grn': 'goods_received_notes',
+            'ap': 'ap_payment_vouchers',
+            'prepay': 'supplier_prepayments',
+            'uom': 'unit_of_measure',
+            'ledger': 'ledger_accounts',
+            'paymodes': 'payment_modes',
+            'tax': 'taxes',
+            'consult': 'consultants',
+            'emp': 'employees',
+            'taxrange': 'tax_ranges',
+            'roles': 'user_roles',
+            'priv': 'privileges',
+            'sysusers': 'system_users',
+            'serv': 'services',
+            'room': 'rooms',
+            'beds': 'ward_beds',
+            'dept': 'departments',
+            'storage': 'storage_locations',
+            'clinics': 'medical_clinics',
+        }
+        
+        # Validate environment on initialization
+        self._validate_environment()
+    
+    def _setup_directories(self):
+        """Create necessary directories for logs and screenshots."""
+        directories = [
+            os.path.join(self.base_dir, 'logs'),
+            os.path.join(self.base_dir, 'screenshots'),
+            os.path.join(self.base_dir, 'auth_logs')
+        ]
+        
+        for directory in directories:
+            if not os.path.exists(directory):
+                os.makedirs(directory)
+                logger.info(f"Created directory: {directory}")
+    
+    def _validate_environment(self):
+        """Validate that all required environment variables are set."""
+        missing_vars = []
+        
+        if not self.accesscode:
+            missing_vars.append('MEDICENTRE_ACCESS_CODE')
+        if not self.branch:
+            missing_vars.append('MEDICENTRE_BRANCH')
+        if not self.username:
+            missing_vars.append('MEDICENTRE_USERNAME')
+        if not self.password:
+            missing_vars.append('MEDICENTRE_PASSWORD')
+        
+        if missing_vars:
+            error_msg = f"Missing required environment variables: {', '.join(missing_vars)}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        logger.info("Environment validation passed")
+    
+    def setup_driver(self) -> bool:
+        """
+        Setup Chrome WebDriver with appropriate options.
+        
+        Returns:
+            bool: True if setup successful, False otherwise
+        """
+        logger.info("Setting up Chrome WebDriver")
+        
+        try:
+            chrome_options = Options()
+            
+            if self.headless:
+                chrome_options.add_argument('--headless=new')
+            
+            chrome_options.add_argument('--no-sandbox')
+            chrome_options.add_argument('--disable-dev-shm-usage')
+            chrome_options.add_argument('--disable-gpu')
+            chrome_options.add_argument('--disable-notifications')
+            chrome_options.add_argument('--disable-popup-blocking')
+            chrome_options.add_argument('--start-maximized')
+
+            prefs = {
+                "credentials_enable_service": False,
+                "profile.password_manager_enabled": False,
+                "profile.password_manager_leak_detection": False
+            }
+            chrome_options.add_experimental_option("prefs", prefs)
+            
+            # Add preferences for better stability
+            chrome_options.add_experimental_option('excludeSwitches', ['enable-logging'])
+            chrome_options.add_experimental_option('prefs', {
+                'credentials_enable_service': False,
+                'profile.password_manager_enabled': False,
+                'profile.default_content_setting_values.notifications': 2
+            })
+            
+            # Use webdriver-manager to handle ChromeDriver
+            service = Service(ChromeDriverManager().install())
+            self.driver = webdriver.Chrome(service=service, options=chrome_options)
+            
+            # Set window size
+            self.driver.maximize_window()
+            logger.info("Browser window maximized to full screen")
+            
+            self.wait = WebDriverWait(self.driver, 30)
+            
+            logger.info("WebDriver setup completed successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to setup WebDriver: {e}")
+            return False
+    
+    def save_screenshot(self, screenshot_name: str, subdirectory: str = "auth") -> str:
+        """
+        Save screenshot to screenshots folder.
+        
+        Args:
+            screenshot_name: Name of the screenshot file
+            subdirectory: Subdirectory within screenshots (default: "auth")
+            
+        Returns:
+            str: Path to the saved screenshot
+        """
+        # Create subdirectory path
+        screenshot_dir = os.path.join(self.base_dir, 'screenshots', subdirectory)
+        if not os.path.exists(screenshot_dir):
+            os.makedirs(screenshot_dir)
+        
+        # Create timestamped filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = os.path.join(screenshot_dir, f"{screenshot_name}_{timestamp}.png")
+        
+        try:
+            self.driver.save_screenshot(filename)
+            logger.info(f"Saved screenshot: {filename}")
+            return filename
+        except Exception as e:
+            logger.error(f"Failed to save screenshot: {e}")
+            return ""
+    
+    def select_branch_on_login(self) -> bool:
+        """
+        Select branch on login page.
+        
+        Returns:
+            bool: True if branch selected or not required, False if failed
+        """
+        logger.info(f"Selecting branch: {self.branch}")
+        
+        try:
+            # Wait for branch select element
+            branch_element = self.wait.until(
+                EC.presence_of_element_located(self.elements['branch_select'])
+            )
+            
+            # Check if it's a select element
+            if branch_element.tag_name.lower() == 'select':
+                select_obj = Select(branch_element)
+                
+                # Get all options
+                options = select_obj.options
+                available_branches = [opt.text.strip() for opt in options if opt.text.strip()]
+                logger.info(f"Available branches: {', '.join(available_branches)}")
+                
+                # Try to select the branch
+                try:
+                    select_obj.select_by_visible_text(self.branch)
+                    logger.info(f"Selected branch: {self.branch}")
+                    
+                    # Verify selection
+                    selected_option = select_obj.first_selected_option.text.strip()
+                    if selected_option == self.branch:
+                        logger.info(f"Branch selection verified: {selected_option}")
+                        return True
+                    else:
+                        logger.warning(f"Selected '{selected_option}' instead of '{self.branch}'")
+                        return True  # Still return True as something was selected
+                        
+                except Exception as select_error:
+                    logger.warning(f"Exact branch match failed: {select_error}")
+                    
+                    # Try case-insensitive match
+                    for option in options:
+                        if option.text and self.branch.lower() in option.text.lower():
+                            select_obj.select_by_visible_text(option.text)
+                            logger.info(f"Selected branch (partial match): {option.text}")
+                            return True
+                    
+                    # Select first available branch as fallback
+                    for option in options:
+                        if option.text.strip():
+                            select_obj.select_by_visible_text(option.text)
+                            logger.warning(f"Selected first available branch: {option.text}")
+                            return True
+                    
+                    logger.error("No selectable branch options found")
+                    return False
+            else:
+                logger.warning("Branch element is not a select dropdown")
+                # Try to click or send keys
+                branch_element.click()
+                branch_element.send_keys(self.branch)
+                logger.info(f"Set branch to: {self.branch}")
+                return True
+                
+        except TimeoutException:
+            logger.warning("Branch select element not found - system may not require branch selection")
+            return True  # Assume success if branch not required
+            
+        except Exception as e:
+            logger.error(f"Error during branch selection: {e}")
+            return False
+    
+    def verify_login_success(self) -> bool:
+        """
+        Verify if login was successful.
+        
+        Returns:
+            bool: True if login successful, False otherwise
+        """
+        logger.info("Verifying login success")
+        
+        try:
+            # Wait for dashboard or user menu
+            time.sleep(3)
+            
+            # Check multiple indicators of successful login
+            success_indicators = [
+                (self.elements['dashboard_element'], "Dashboard found"),
+                (By.XPATH, "//h5[normalize-space()='My Appointments']"),
+                (By.XPATH, "//h5[normalize-space()='Todo List']"),
+            ]
+            
+            for element_locator, message in success_indicators:
+                try:
+                    element = self.driver.find_element(*element_locator)
+                    if element.is_displayed():
+                        logger.info(f"Login successful: {message}")
+                        return True
+                except:
+                    continue
+            
+            # Check URL for dashboard or main page
+            current_url = self.driver.current_url.lower()
+            if 'https://medicentrev3.hanmak.co.ke' in current_url:
+                logger.info("Login successful - dashboard URL detected")
+                return True
+            
+            # Check for absence of login form
+            try:
+                self.driver.find_element(*self.elements['login_username'])
+                logger.error("Login failed - still on login page")
+                return False
+            except:
+                logger.info("Login successful - login form no longer present")
+                return True
+                
+        except Exception as e:
+            logger.error(f"Error verifying login: {e}")
+            return False
+    
+    def login(self) -> bool:
+        """
+        Login to MedicentreV3 system.
+        
+        Returns:
+            bool: True if login successful, False otherwise
+        """
+        logger.info(f"Attempting to login to {self.base_url}")
+        
+        try:
+            # Navigate to login page
+            self.driver.get(self.base_url)
+            logger.info(f"Navigated to {self.base_url}")
+            time.sleep(2)
+            
+            # Take screenshot of login page
+            self.save_screenshot("login_page")
+            
+            # Step 1: Enter facility code
+            accesscode_field = self.wait.until(
+                EC.presence_of_element_located(self.elements['access_code'])
+            )
+            accesscode_field.clear()
+            accesscode_field.send_keys(self.accesscode)
+            logger.info("Entered facility access code")
+            
+            # Step 2: Click proceed button
+            proceed_button = self.driver.find_element(*self.elements['proceed_button'])
+            proceed_button.click()
+            logger.info("Clicked proceed button")
+            time.sleep(2)
+            
+            # Step 3: Select branch (if required)
+            branch_selected = self.select_branch_on_login()
+            if not branch_selected:
+                logger.warning("Branch selection may have failed, continuing...")
+            
+            # Step 4: Enter username
+            username_field = self.wait.until(
+                EC.presence_of_element_located(self.elements['login_username'])
+            )
+            username_field.clear()
+            username_field.send_keys(self.username)
+            logger.info("Entered username")
+            
+            # Step 5: Enter password
+            password_field = self.driver.find_element(*self.elements['login_password'])
+            password_field.clear()
+            password_field.send_keys(self.password)
+            logger.info("Entered password")
+            
+            # Step 6: Click login button
+            login_button = self.driver.find_element(*self.elements['login_button'])
+            login_button.click()
+            logger.info("Clicked login button")
+            
+            # Step 7: Verify login success
+            login_success = self.verify_login_success()
+            
+            if login_success:
+                self.save_screenshot("after_login")
+            
+            return login_success
+            
+        except Exception as e:
+            logger.error(f"Login failed with error: {e}")
+            self.save_screenshot("login_error")
+            return False
+    
+    def logout(self) -> bool:
+        """
+        Logout from MedicentreV3 system.
+        
+        Returns:
+            bool: True if logout successful, False otherwise
+        """
+        logger.info("Attempting to logout")
+        
+        try:
+            # Try to find and click user menu
+            try:
+                user_menu = self.driver.find_element(*self.elements['user_menu'])
+                user_menu.click()
+                time.sleep(1)
+            except:
+                logger.warning("User menu not found, trying direct logout")
+            
+            # Try to find and click logout button
+            try:
+                logout_button = self.driver.find_element(*self.elements['logout_button'])
+                logout_button.click()
+                logger.info("Clicked logout button")
+                time.sleep(2)
+                return True
+            except:
+                # If logout button not found, navigate to logout URL directly
+                logout_url = f"{self.base_url}/Account/LogOut"
+                self.driver.get(logout_url)
+                logger.info(f"Navigated to logout URL: {logout_url}")
+                time.sleep(2)
+                return True
+                
+        except Exception as e:
+            logger.error(f"Logout failed with error: {e}")
+            return False
+    
+    def navigate_to(self, module: str, panel: str = None) -> bool:
+        """
+        Navigate to a module or module panel.
+        
+        Args:
+            module: Main module name (e.g., 'procurement', 'accounts', 'configuration')
+            panel: Optional panel name (e.g., 'suppliers', 'ledger_accounts', 'rooms')
+                  If None, just clicks the main module
+        
+        Returns:
+            bool: True if navigation successful, False otherwise
+        """
+        # Resolve aliases
+        module = self.module_aliases.get(module, module)
+        if panel:
+            panel = self.module_aliases.get(panel, panel)
+        
+        logger.info(f"Navigating to {' -> '.join(filter(None, [module, panel]))}")
+        
+        try:
+            # Step 1: Click the main module menu
+            menu_key = f"{module}_menu"
+            if menu_key not in self.elements:
+                # Try alternative naming
+                menu_key = f"{module}_module"
+                if menu_key not in self.elements:
+                    logger.error(f"Module '{module}' not found. Available modules: {[k for k in self.elements.keys() if k.endswith('_menu')]}")
+                    return False
+            
+            menu_element = self.wait.until(
+                EC.element_to_be_clickable(self.elements[menu_key])
+            )
+            
+            # Click the menu
+            menu_element.click()
+            logger.info(f"Clicked {module} menu")
+            time.sleep(1)  # Wait for dropdown to appear if applicable
+            
+            # Step 2: If panel is specified, click it
+            if panel:
+                # First check if panel exists in elements with module.panel format
+                panel_key = f"{module}.{panel}"
+                if panel_key in self.elements:
+                    panel_element = self.wait.until(
+                        EC.element_to_be_clickable(self.elements[panel_key])
+                    )
+                    panel_element.click()
+                    logger.info(f"Clicked {panel} panel")
+                else:
+                    # Try alternative panel naming
+                    panel_key = f"{panel}_panel"
+                    if panel_key in self.elements:
+                        panel_element = self.wait.until(
+                            EC.element_to_be_clickable(self.elements[panel_key])
+                        )
+                        panel_element.click()
+                        logger.info(f"Clicked {panel} panel")
+                    else:
+                        logger.error(f"Panel '{panel}' not found for module '{module}'")
+                        return False
+            
+            # Step 3: Wait for page to load
+            time.sleep(2)
+            
+            # Step 4: Take screenshot
+            screenshot_name = f"{module}_{panel}" if panel else f"{module}"
+            self.save_screenshot(screenshot_name, "navigation")
+            
+            # Step 5: Verify navigation (optional but recommended)
+            if self._verify_navigation(module, panel):
+                logger.info(f"Successfully navigated to {' -> '.join(filter(None, [module, panel]))}")
+                return True
+            else:
+                logger.warning(f"Navigation may not have completed as expected")
+                return True  # Still return True as we likely reached some page
+            
+        except Exception as e:
+            logger.error(f"Failed to navigate to {' -> '.join(filter(None, [module, panel]))}: {e}")
+            self.save_screenshot(f"nav_error_{module}_{panel if panel else ''}", "errors")
+            return False
+    
+    def _verify_navigation(self, module: str, panel: str = None) -> bool:
+        """
+        Verify that navigation was successful.
+        
+        Args:
+            module: Module name
+            panel: Panel name (optional)
+            
+        Returns:
+            bool: True if navigation appears successful
+        """
+        try:
+            # Check URL for module/panel indicators
+            current_url = self.driver.current_url.lower()
+            
+            # Check page title or headers
+            try:
+                page_title = self.driver.title
+                if page_title and page_title.strip():
+                    logger.debug(f"Page title: {page_title}")
+            except:
+                pass
+            
+            # Check for common page elements
+            try:
+                # Look for h1, h2, or h3 headers
+                headers = self.driver.find_elements(By.TAG_NAME, 'h1') + \
+                         self.driver.find_elements(By.TAG_NAME, 'h2') + \
+                         self.driver.find_elements(By.TAG_NAME, 'h3')
+                
+                for header in headers[:3]:  # Check first 3 headers
+                    if header.text.strip():
+                        logger.debug(f"Found header: {header.text.strip()}")
+                        break
+            except:
+                pass
+            
+            return True
+            
+        except Exception as e:
+            logger.warning(f"Navigation verification failed: {e}")
+            return False
+    
+    def navigate_to_url(self, url: str) -> bool:
+        """
+        Navigate to a specific URL.
+        
+        Args:
+            url: URL to navigate to
+            
+        Returns:
+            bool: True if navigation successful, False otherwise
+        """
+        logger.info(f"Navigating to URL: {url}")
+        
+        try:
+            self.driver.get(url)
+            time.sleep(2)
+            logger.info(f"Successfully navigated to {url}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to navigate to {url}: {e}")
+            return False
+    
+    def get_current_url(self) -> str:
+        """
+        Get the current URL.
+        
+        Returns:
+            str: Current URL
+        """
+        return self.driver.current_url if self.driver else ""
+    
+    def get_page_title(self) -> str:
+        """
+        Get the current page title.
+        
+        Returns:
+            str: Page title
+        """
+        return self.driver.title if self.driver else ""
+    
+    def is_element_present(self, locator: Tuple[str, str], timeout: int = 5) -> bool:
+        """
+        Check if an element is present on the page.
+        
+        Args:
+            locator: Element locator tuple (By, value)
+            timeout: Time to wait for element (default: 5 seconds)
+            
+        Returns:
+            bool: True if element is present, False otherwise
+        """
+        try:
+            WebDriverWait(self.driver, timeout).until(
+                EC.presence_of_element_located(locator)
+            )
+            return True
+        except:
+            return False
+    
+    def wait_for_element(self, locator: Tuple[str, str], timeout: int = 30) -> bool:
+        """
+        Wait for an element to be present and visible.
+        
+        Args:
+            locator: Element locator tuple (By, value)
+            timeout: Time to wait for element (default: 30 seconds)
+            
+        Returns:
+            bool: True if element found and visible, False otherwise
+        """
+        try:
+            element = WebDriverWait(self.driver, timeout).until(
+                EC.visibility_of_element_located(locator)
+            )
+            return element is not None
+        except Exception as e:
+            logger.warning(f"Element not found within {timeout} seconds: {e}")
+            return False
+    
+    def click_element(self, locator: Tuple[str, str]) -> bool:
+        """
+        Click on an element.
+        
+        Args:
+            locator: Element locator tuple (By, value)
+            
+        Returns:
+            bool: True if click successful, False otherwise
+        """
+        try:
+            element = self.wait.until(
+                EC.element_to_be_clickable(locator)
+            )
+            element.click()
+            return True
+        except Exception as e:
+            logger.error(f"Failed to click element: {e}")
+            return False
+    
+    def find_element(self, locator: Tuple[str, str], timeout: int = 10):
+        """
+        Find an element on the page.
+        
+        Args:
+            locator: Element locator tuple (By, value)
+            timeout: Time to wait for element (default: 10 seconds)
+            
+        Returns:
+            WebElement if found, None otherwise
+        """
+        try:
+            return WebDriverWait(self.driver, timeout).until(
+                EC.presence_of_element_located(locator)
+            )
+        except:
+            return None
+    
+    def find_elements(self, locator: Tuple[str, str], timeout: int = 10):
+        """
+        Find multiple elements on the page.
+        
+        Args:
+            locator: Element locator tuple (By, value)
+            timeout: Time to wait for elements (default: 10 seconds)
+            
+        Returns:
+            List of WebElements if found, empty list otherwise
+        """
+        try:
+            WebDriverWait(self.driver, timeout).until(
+                EC.presence_of_element_located(locator)
+            )
+            return self.driver.find_elements(*locator)
+        except:
+            return []
+    
+    def add_element(self, name: str, locator: Tuple[str, str]):
+        """
+        Add a new element to the elements dictionary.
+        Useful for adding custom elements for specific scripts.
+        
+        Args:
+            name: Element name/key
+            locator: Element locator tuple (By, value)
+        """
+        self.elements[name] = locator
+        logger.info(f"Added element: {name}")
+    
+    def setup_and_login(self) -> bool:
+        """
+        Setup WebDriver and login in one call.
+        
+        Returns:
+            bool: True if both setup and login successful, False otherwise
+        """
+        if not self.setup_driver():
+            logger.error("Failed to setup WebDriver")
+            return False
+        
+        if not self.login():
+            logger.error("Failed to login")
+            self.quit_driver()
+            return False
+        
+        return True
+    
+    def quit_driver(self):
+        """Quit the WebDriver."""
+        if self.driver:
+            self.driver.quit()
+            logger.info("WebDriver quit")
+    
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - automatically logout and quit driver."""
+        try:
+            self.logout()
+        except:
+            pass
+        finally:
+            self.quit_driver()
+
+
+# Convenience functions for common operations
+def create_auth_session(headless: bool = False, base_dir: str = ".") -> MedicentreAuth:
+    """
+    Create a new MedicentreAuth session.
+    
+    Args:
+        headless: Run browser in headless mode
+        base_dir: Base directory for logs and screenshots
+        
+    Returns:
+        MedicentreAuth: Authentication session object
+    """
+    return MedicentreAuth(headless=headless, base_dir=base_dir)
+
+
+def quick_login(headless: bool = False, base_dir: str = ".") -> Optional[MedicentreAuth]:
+    """
+    Quick login function that returns a logged-in session.
+    
+    Args:
+        headless: Run browser in headless mode
+        base_dir: Base directory for logs and screenshots
+        
+    Returns:
+        MedicentreAuth: Logged-in session or None if failed
+    """
+    auth = MedicentreAuth(headless=headless, base_dir=base_dir)
+    if auth.setup_and_login():
+        return auth
+    return None

medicentrev3_auth-1.0.0/medicentrev3_auth.egg-info/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: medicentrev3-auth
+Version: 1.0.0
+Summary: Authentication and navigation module for MedicentreV3 automation
+Author-email: Denis Ndiritu <denis@hanmak.co.ke>
+License: MIT
+Project-URL: Homepage, https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: selenium>=4.0.0
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: webdriver-manager>=3.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+
+# MedicentreV3 Authentication Package
+
+A reusable Python package for MedicentreV3 authentication and navigation.
+
+## Installation
+
+```bash
+# Install from GitHub
+pip install git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+# For development
+pip install -e git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+## Updating the Package
+
+When updates are available, users should upgrade using:
+
+```bash
+# Upgrade to latest version
+pip install --upgrade git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+
+# Or reinstall (force latest)
+pip install --force-reinstall git+https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package.git
+```
+
+**Important**: Always use `--upgrade` or `--force-reinstall` when updating from GitHub to ensure you get the latest changes.

medicentrev3_auth-1.0.0/medicentrev3_auth.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+setup.py
+medicentrev3_auth/__init__.py
+medicentrev3_auth/auth.py
+medicentrev3_auth.egg-info/PKG-INFO
+medicentrev3_auth.egg-info/SOURCES.txt
+medicentrev3_auth.egg-info/dependency_links.txt
+medicentrev3_auth.egg-info/requires.txt
+medicentrev3_auth.egg-info/top_level.txt

medicentrev3_auth-1.0.0/medicentrev3_auth.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

medicentrev3_auth-1.0.0/medicentrev3_auth.egg-info/requires.txt

@@ -0,0 +1,9 @@
+selenium>=4.0.0
+python-dotenv>=0.19.0
+webdriver-manager>=3.8.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=22.0.0
+flake8>=5.0.0

medicentrev3_auth-1.0.0/medicentrev3_auth.egg-info/top_level.txt

@@ -0,0 +1 @@
+medicentrev3_auth

medicentrev3_auth-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "medicentrev3-auth"
+version = "1.0.0"
+description = "Authentication and navigation module for MedicentreV3 automation"
+readme = "README.md"
+authors = [
+    {name = "Denis Ndiritu", email = "denis@hanmak.co.ke"}
+]
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "selenium>=4.0.0",
+    "python-dotenv>=0.19.0",
+    "webdriver-manager>=3.8.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=22.0.0",
+    "flake8>=5.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/Hanmak-Technologies-Automation-Project/medicentrev3-authentication-package"

medicentrev3_auth-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

medicentrev3_auth-1.0.0/setup.py

@@ -0,0 +1,5 @@
+# setup.py
+from setuptools import setup, find_packages
+
+if __name__ == "__main__":
+    setup()