robo_appian 0.0.2__py3-none-any.whl

robo_appian/utils/components/InputUtils.py

@@ -0,0 +1,189 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.remote.webelement import WebElement
+
+
+class InputUtils:
+    """
+    Utility class for interacting with input components in Appian UI.
+
+        Usage Example:
+
+        # Set a value in an input field
+        from robo_appian.utils.components.InputUtils import InputUtils
+        InputUtils.setInputValue(wait, "Username", "test_user")
+
+    """
+
+    @staticmethod
+    def findComponent(wait: WebDriverWait, label: str):
+        """
+        Finds an input component by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the input component.
+
+        Returns:
+            The Selenium WebElement for the input component.
+
+        Example:
+            InputUtils.findComponent(wait, "Username")
+
+        """
+        # This method locates an input component that contains a label with the specified text.
+        # It then retrieves the component's ID and uses it to find the actual input element.
+
+        xpath = f".//div/label[text()='{label}']"
+        component: WebElement = wait.until(
+            EC.element_to_be_clickable((By.XPATH, xpath))
+        )
+
+        attribute: str = "for"
+        component_id = component.get_attribute(attribute)  # type: ignore[reportUnknownMemberType]
+        if not component_id:
+            raise ValueError(
+                f"Could not find component using {attribute} attribute for label '{label}'."
+            )
+
+        component = wait.until(EC.element_to_be_clickable((By.ID, component_id)))
+        return component
+
+    @staticmethod
+    def setValueUsingComponent(component: WebElement, value: str):
+        """
+        Sets a value in an input component using the provided component element.
+
+        Parameters:
+            component: The Selenium WebElement for the input component.
+            value: The value to set in the input field.
+
+        Returns:
+            The Selenium WebElement for the input component after setting the value.
+
+        Example:
+            InputUtils.setValueUsingComponent(component, "test_user")
+
+        """
+        # This method assumes that the component is already found and passed as an argument.
+        # It clears the existing value and sets the new value in the input field.
+
+        if not component.is_displayed():
+            raise Exception(
+                f"Component with label '{component.text}' is not displayed."
+            )
+
+        component.clear()
+        component.send_keys(value)
+        return component
+
+    @staticmethod
+    def setValueAndSubmitUsingComponent(component: WebElement, value: str):
+        """
+        Sets a value in an input component and submits it using the provided component element.
+
+        Parameters:
+            component: The Selenium WebElement for the input component.
+            value: The value to set in the input field.
+
+        Returns:
+            The Selenium WebElement for the input component after setting the value and submitting.
+
+        Example:
+            InputUtils.setValueAndSubmitUsingComponent(component, "test_user")
+
+        """
+        # This method assumes that the component is already found and passed as an argument.
+
+        if not component.is_displayed():
+            raise Exception(
+                f"Component with label '{component.text}' is not displayed."
+            )
+
+        component = InputUtils.setValueUsingComponent(component, value)
+        component.send_keys(Keys.ENTER)
+        return component
+
+    @staticmethod
+    def setInputValue(wait: WebDriverWait, label: str, value: str):
+        """
+        Sets a value in an input component identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the input component.
+            value: The value to set in the input field.
+
+        Returns:
+            The Selenium WebElement for the input component after setting the value.
+
+        Example:
+            InputUtils.setInputValue(wait, "Username", "test_user")
+
+        """
+        # This method finds the input component by its label and sets the specified value in it.
+        # It retrieves the component's ID and uses it to find the actual input element.
+
+        component = InputUtils.findComponent(wait, label)
+        InputUtils.setValueUsingComponent(component, value)
+        return component
+
+    @staticmethod
+    def setValueAndSubmit(wait: WebDriverWait, label: str, value: str):
+        """
+        Sets a value in an input component identified by its label and submits it.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the input component.
+            value: The value to set in the input field.
+
+        Returns:
+            The Selenium WebElement for the input component after setting the value and submitting.
+
+        Example:
+            InputUtils.setValueAndSubmit(wait, "Username", "test_user")
+
+        """
+        # This method finds the input component by its label, sets the specified value in it,
+        # and submits the form by sending an ENTER key.
+
+        component = InputUtils.findComponent(wait, label)
+        component = InputUtils.setValueAndSubmitUsingComponent(component, value)
+        return component
+
+    @staticmethod
+    def setSearchInputValue(wait: WebDriverWait, label: str, value: str):
+        """
+        Sets a value in a search-enabled input component identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the search input component.
+            value: The value to set in the search input field.
+
+        Returns:
+            None
+        Example:
+            InputUtils.setSearchInputValue(wait, "Search", "Appian")
+
+        """
+        # This method finds the search-enabled input component by its label, retrieves the aria-controls attribute
+        # and the component ID, clicks on the input to display the search input,
+        # and sets the specified value in the search input field.
+
+        xpath = (
+            f".//div[./div/span[text()='{label}']]/div/div/div/input[@role='combobox']"
+        )
+        search_input_component = wait.until(
+            EC.element_to_be_clickable((By.XPATH, xpath))
+        )
+        aria_controls = search_input_component.get_attribute("aria-controls")  # type: ignore[reportUnknownMemberType]
+        InputUtils.setValueUsingComponent(search_input_component, value)
+
+        xpath = f".//ul[@id='{aria_controls}' and @role='listbox' ]/li[@role='option']/div/div/div/div/div/div/p[text()='{value}'][1]"
+        drop_down_item = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        drop_down_item.click()

robo_appian/utils/components/LabelUtils.py

@@ -0,0 +1,40 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.remote.webdriver import WebDriver
+
+
+class LabelUtils:
+    """
+    Utility class for interacting with label components in Appian UI.
+
+        Usage Example:
+
+        # Find a label component
+        from robo_appian.utils.components.LabelUtils import LabelUtils
+        label_component = LabelUtils.find(wait, "Username")
+
+    """
+
+    @staticmethod
+    def find(wait : WebDriverWait, label: str):
+        """
+        Finds a label component by its text.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the component.
+
+        Returns:
+            The Selenium WebElement for the label component.
+
+        Example:
+            LabelUtils.find(wait, "Username")
+
+        """
+        # This method locates a label component that contains the specified text.
+        # It uses XPath to find the element that matches the text.
+
+        xpath = f".//*[text()='{label}']"
+        component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+        return component

robo_appian/utils/components/LinkUtils.py

@@ -0,0 +1,41 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.remote.webdriver import WebDriver
+
+
+class LinkUtils:
+    
+    """
+    Utility class for interacting with link components in Appian UI.
+
+        Usage Example:
+
+        # Click a link with a specific label
+        from robo_appian.utils.components.LinkUtils import LinkUtils
+        LinkUtils.click(wait, "Learn More")
+
+    """
+
+    @staticmethod
+    def click(wait: WebDriverWait, label: str):
+
+        """
+        Clicks a link identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the link.
+
+        Example:
+            LinkUtils.click(wait, "Learn More")
+        """
+        # This method locates a link that contains a span with the specified label text.
+        # It uses XPath to find the element that matches the text and waits until it is clickable.
+        # The link component is expected to have a structure where the label is within a span inside a paragraph element.
+
+        xpath = f'.//p/span[text()="{label}"]'
+        # component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)) )
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()
+        return component

robo_appian/utils/components/TabUtils.py

@@ -0,0 +1,58 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+
+
+class TabUtils:
+    """
+    Utility class for interacting with tab components in Appian UI.
+
+    Usage Example:
+
+        # Select a tab by its label
+        from robo_appian.utils.components.TabUtils import TabUtils
+        TabUtils.select_tab(wait, "Settings")
+
+        # Find the currently selected tab by its label
+        from robo_appian.utils.components.TabUtils import TabUtils
+        selected_tab = TabUtils.find_selected_tab(wait, "Settings")
+    """
+
+    @staticmethod
+    def find_selected_tab(wait, label):
+        """
+        Finds the currently selected tab by its label.
+
+        Parameters:
+        wait: Selenium WebDriverWait instance.
+            label: The visible text label of the tab.
+
+        Returns:
+            The Selenium WebElement for the selected tab.
+
+        Example:
+            TabUtils.find_selected_tab(wait, "Settings")
+        """
+        # This method locates a tab that is currently selected and contains the specified label.
+
+        xpath = f".//div[./div[./div/div/div/div/div/p/strong[normalize-space(text())='{label}']]/span[text()='Selected Tab.']]/div[@role='link']"
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        return component
+
+    @staticmethod
+    def select_tab(wait, label):
+        """
+        Selects a tab by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the tab to select.
+
+        Example:
+            TabUtils.select_tab(wait, "Settings")
+        """
+        # This method locates a tab that contains a label with the specified text.
+
+        xpath = f".//div[@role='link']/div/div/div/div/div[./p/span[text()='{label}']]"
+        # xpath=f".//div[./div[./div/div/div/div/div/p/strong[normalize-space(text())='{label}']]/span[text()='Selected Tab.']]/div[@role='link']"
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()

robo_appian/utils/components/TableUtils.py

@@ -0,0 +1,187 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.remote.webdriver import WebDriver
+
+
+class TableUtils:
+    """
+    Utility class for interacting with table components in Appian UI.
+
+        Usage Example:
+
+        # Find a table using a column name
+        from robo_appian.utils.components.TableUtils import TableUtils
+        table = TableUtils.findTableUsingColumnName(wait, "Status")
+
+    """
+
+    @staticmethod
+    def findTableUsingColumnName(wait: WebDriverWait, columnName: str):
+        """
+        Finds a table component that contains a column with the specified name.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            columnName: The name of the column to search for in the table.
+
+        Returns:
+            The Selenium WebElement for the table component.
+
+        Example:
+            table = TableUtils.findTableUsingColumnName(wait, "Status")
+
+        """
+        # This method locates a table that contains a header cell with the specified column name.
+        # It uses XPath to find the table element that has a header cell with the specified 'columnName'.
+        # The 'abbr' attribute is used to match the column name, which is a common practice in Appian UI tables.
+
+        # xpath = f".//table[./thead/tr/th[@abbr='{columnName}']]"
+        xpath = f'.//table[./thead/tr/th[@abbr="{columnName}"]]'
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        return component
+
+    @staticmethod
+    def clickOnLinkUsingHoverText(wait, columnName, rowNumber, hoverText):
+        """
+        Clicks on a link in a table cell identified by its column name, row number, and the hover text of the link.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            columnName: The name of the column where the link is located.
+            rowNumber: The row number (0-based index) where the link is located.
+            hoverText: The text that appears when hovering over the link.
+
+        Example:
+            TableUtils.clickOnLinkUsingHoverText(wait, "Status", 2, "View Details")
+
+        """
+
+        # This method locates a link within a specific table cell based on the column name and row number.
+        # It constructs an XPath that targets the table cell containing the link with the specified hover text.
+        # The XPath first identifies the table by the column name, then finds the specific row and cell,
+        # and finally looks for the link with the specified hover text.
+
+        xpath = f".//table[./thead/tr/th[@abbr='{columnName}']]/tbody/tr[@data-dnd-name='row {rowNumber + 1}']/td[not (@data-empty-grid-message)]/div/p/a[./span[text()='{hoverText}']]"
+        # xpath=f".//table[./thead/tr/th/div[text()='{columnName}']][1]/tbody/tr[@data-dnd-name='row {rowNumber}']/td/div/p/a[./span[text()='{hoverText}']]"
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()
+
+    @staticmethod
+    def clickOnButtonUsingHoverText(wait, columnName, rowNumber, hoverText):
+        """
+        Clicks on a button in a table cell identified by its column name, row number, and the hover text of the button.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            columnName: The name of the column where the button is located.
+            rowNumber: The row number (0-based index) where the button is located.
+            hoverText: The text that appears when hovering over the button.
+
+        Example:
+            TableUtils.clickOnButtonUsingHoverText(wait, "Actions", 2, "Delete")
+
+        """
+        # This method locates a button within a specific table cell based on the column name and row number.
+        # It constructs an XPath that targets the table cell containing the button with the specified hover text.
+        # The XPath first identifies the table by the column name, then finds the specific row and cell,
+        # and finally looks for the button with the specified hover text.
+
+        # TODO rowNumber = rowNumber + 1  # Adjusting for 1-based index in XPath
+
+        xpath = f".//table[./thead/tr/th[@abbr='{columnName}']]/tbody/tr[@data-dnd-name='row {rowNumber}']/td[not (@data-empty-grid-message)]"
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()
+
+        xpath = f".//table[./thead/tr/th[@abbr='{columnName}']]/tbody/tr[@data-dnd-name='row {rowNumber}']/td[not (@data-empty-grid-message)]/div/div/button[./span[text()='{hoverText}']]"
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()
+
+    @staticmethod
+    def rowCount(tableObject):
+        """
+        Returns the number of rows in a table, excluding empty grid messages.
+
+        Parameters:
+            tableObject: The Selenium WebElement representing the table.
+
+        Returns:
+            The number of rows in the table.
+
+        Example:
+            count = TableUtils.rowCount(table)
+
+        """
+        # This method counts the number of rows in a table by finding all the table row elements
+        # that do not have the 'data-empty-grid-message' attribute.
+
+        xpath = "./tbody/tr[./td[not (@data-empty-grid-message)]]"
+        rows = tableObject.find_elements(By.XPATH, xpath)
+        return len(rows)
+
+    @staticmethod
+    def findColumNumberUsingColumnName(tableObject, columnName):
+        """
+        Finds the column number in a table based on the column name.
+
+        Parameters:
+            tableObject: The Selenium WebElement representing the table.
+            columnName: The name of the column to find.
+
+        Returns:
+            The index of the column (0-based).
+
+        Example:
+            column_number = TableUtils.findColumNumberUsingColumnName(table, "Status")
+
+        """
+        # This method locates the column header cell with the specified column name
+        # and extracts the column index from its class attribute.
+
+        xpath = f'./thead/tr/th[@scope="col" and @abbr="{columnName}"]'
+        component = tableObject.find_element(By.XPATH, xpath)
+        class_string = component.get_attribute("class")
+        partial_string = "headCell_"
+        words = class_string.split()
+        selected_word = None
+
+        for word in words:
+            if partial_string in word:
+                selected_word = word
+
+        data = selected_word.split("_")
+        return int(data[1])
+
+    @staticmethod
+    def find_component_from_tabele_cell(wait, rowNumber, columnName):
+        """
+        Finds a component within a specific table cell based on the row number and column name.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            rowNumber: The row number (0-based index) where the component is located.
+            columnName: The name of the column where the component is located.
+
+        Returns:
+            The Selenium WebElement for the component within the specified table cell.
+
+        Example:
+            component = TableUtils.find_component_from_tabele_cell(wait, 2, "Status")
+
+        """
+        # This method locates a specific component within a table cell based on the provided row number
+        # and column name. It constructs an XPath that targets the table cell containing the specified column
+        # and row, and then retrieves the component within that cell.
+
+        tableObject = TableUtils.findTableUsingColumnName(wait, columnName)
+        columnNumber = TableUtils.findColumNumberUsingColumnName(
+            tableObject, columnName
+        )
+        # xpath=f'./tbody/tr[@data-dnd-name="row {rowNumber+1}"]/td[not (@data-empty-grid-message)][{columnNumber}]'
+        # component = tableObject.find_elements(By.XPATH, xpath)
+        rowNumber = rowNumber + 1
+        columnNumber = columnNumber + 1
+        xpath = f'.//table[./thead/tr/th[@abbr="{columnName}"]]/tbody/tr[@data-dnd-name="row {rowNumber}"]/td[not (@data-empty-grid-message)][{columnNumber}]/*'
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        # childComponent=component.find_element(By.xpath("./*"))
+        return component

robo_appian/utils/controllers/ComponentDriver.py

@@ -0,0 +1,91 @@
+from robo_appian.utils.components.ComponentUtils import ComponentUtils
+from robo_appian.utils.components.DateUtils import DateUtils
+from robo_appian.utils.components.DropdownUtils import DropdownUtils
+from robo_appian.utils.components.InputUtils import InputUtils
+from robo_appian.utils.components.LabelUtils import LabelUtils
+from robo_appian.utils.components.LinkUtils import LinkUtils
+from robo_appian.utils.components.TabUtils import TabUtils
+
+
+class ComponentDriver:
+    """
+    Utility class for interacting with various components in Appian UI.
+    Usage Example:
+    from robo_appian.utils.controllers.ComponentDriver import ComponentDriver
+    # Set a date value
+    ComponentDriver.execute(wait, "Date", "Set Value", "Start Date", "01/01/2024")
+    """
+
+    @staticmethod
+    def execute(wait : WebDriverWait, type, action, label, value):
+        """
+        Executes an action on a specified component type.
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            type: The type of component (e.g., "Date", "Input Text", "Search Input Text", etc.).
+            action: The action to perform on the component (e.g., "Set Value", "Click", "Select").
+            label: The visible text label of the component.
+            value: The value to set in the component (if applicable).
+        Example:
+            ComponentDriver.execute(wait, "Date", "Set Value", "Start Date", "01/01/2024")
+        """
+        # This method executes an action on a specified component type based on the provided parameters.
+
+        match type:
+
+            case "Date":
+                match action:
+                    case "Set Value":
+                        DateUtils.setDateValue(wait, label, value)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Input Text":
+                match action:
+                    case "Set Value":
+                        InputUtils.setInputValue(wait, label, value)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Search Input Text":
+                match action:
+                    case "Select":
+                        InputUtils.setSearchInputValue(wait, label, value)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Label":
+                match action:
+                    case "Find":
+                        LabelUtils.find(wait, label)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Link":
+                match action:
+                    case "Click":
+                        LinkUtils.click(wait, label)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Drop Down":
+                match action:
+                    case "Select":
+                        DropdownUtils.selectDropdownValue(wait, label, value)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Search Drop Down":
+                match action:
+                    case "Select":
+                        DropdownUtils.selectSearchDropdownValue(wait, label, value)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Button":
+                match action:
+                    case "Click":
+                        ComponentUtils.click_button(wait, label)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case "Tab":
+                match action:
+                    case "Find":
+                        TabUtils.find_selected_tab(wait, label)
+                    case _:
+                        raise ValueError(f"Unsupported action for {type}: {action}")
+            case _:
+                raise ValueError(f"Unsupported component type: {type}")

robo_appian/utils/exceptions/MyCustomError.py

@@ -0,0 +1,6 @@
+class MyCustomError(Exception):
+    """A custom exception for specific error conditions."""
+
+    def __init__(self, message="This is a custom error!"):
+        self.message = message
+        super().__init__(self.message)

robo_appian-0.0.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 dinilmithra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.