# Исходный код pages.users_tab

    """Модуль вкладки 'Пользователи'.

    Содержит класс UsersTab для работы с таблицей пользователей.
    Позволяет управлять пользователями через модальные окна и проверять их состояние.
    """

    import re
    from playwright.sync_api import Page
    from locators.table_locators import TableLocators
    from components_derived.modal_edit_user import EditUserModalWindow
    from components_derived.modal_add_local_user import AddLocalUserModalWindow
    from components_derived.modal_add_AD_user import AddADUserModalWindow
    from data.roles_dict import roles_dict
    from components.toolbar_component import ToolbarComponent
    from components.table_component import TableComponent
    from components.modal_window_component import ModalWindowComponent
    from components.alert_component import AlertComponent
    from pages.base_page import BasePage

    class UsersTab(BasePage):
        """Класс для работы с вкладкой 'Пользователи'.

        Предоставляет методы для взаимодействия с таблицей пользователей,
        модальными окнами и проверки состояния элементов.

        Args:
            page: Экземпляр страницы Playwright.
        """

        def __init__(self, page: Page) -> None:
            """Инициализирует компоненты вкладки 'Пользователи'."""

            super().__init__(page)

            locator_button_1 = self.page.get_by_role("navigation").filter(
                has_text=re.compile("Пользователи")
            ).get_by_role("button").nth(0)
            locator_button_2 = self.page.get_by_role("navigation").filter(
                has_text=re.compile("Пользователи")
            ).get_by_role("button").nth(1)

            self.toolbar = ToolbarComponent(page, "Пользователи")
            self.toolbar.add_tooltip_button(locator_button_1, "edit")
            self.toolbar.add_tooltip_button(locator_button_1, "add_user")
            self.toolbar.add_tooltip_button(locator_button_2, "close")

            self.users_table = TableComponent(page)
            self.modal_windows = {}
            self.alert = AlertComponent(page)

        # Действия:

        def add_modal_window(self, window_type: str, title: str) -> None:
            """Добавляет модальное окно в коллекцию.

            Args:
                window_type: Тип окна ('add_user' или 'edit_user').
                title: Заголовок окна.

            Raises:
                AssertionError: Если тип окна не поддерживается.
            """

            if window_type == "add_local_user":
                self.modal_windows["add_local_user"] = AddLocalUserModalWindow(self.page)
            elif window_type == "add_AD_user":
                self.modal_windows["add_AD_user"] = AddADUserModalWindow(self.page)
            elif window_type == "edit_user":
                self.modal_windows[title] = EditUserModalWindow(self.page, title)
            else:
                assert False, "Unsupported modal window type"

        def add_new_user(self, user_data: dict) -> bool:
            """Добавляет нового пользователя или обрабатывает ошибку при дубликате.

            Args:
                user_data: Данные пользователя (name, role, password).

            Returns:
                bool: True если пользователь успешно добавлен, False если пользователь уже существует.

            Raises:
                AssertionError: Если открылось alert окно отличное от success или error,
                            или если текст alert не соответствует ожидаемому.
            """

            add_user_window = self.get_modal_window("add_local_user")

            auth_type = user_data.get("auth_type")
            if auth_type == "active_directory":
                add_user_window.check_active_directory_checkbox()
                self.add_modal_window("add_AD_user", "")
                add_user_window = self.get_modal_window("add_AD_user")

            add_user_window.new_user(user_data)

            is_added = False
            alert_type = self.alert.get_alert_type()
            if alert_type == "success":
                self.alert.check_alert_presence(' Новый пользователь \n успешно добавлен! ')
                self.alert.check_alert_absence(' Новый пользователь \n успешно добавлен! ')
                is_added = True
            elif alert_type == "error":
                self.alert.check_alert_presence(f' Имя {user_data["name"]} уже \n используется ')
                self.alert.check_alert_absence(f' Имя {user_data["name"]} уже \n используется ')
            else:
                assert False, f"Got unexpected alert type {alert_type}"

            return is_added

        def close_add_AD_user_window(self) -> None:
            """Закрывает окно добавления пользователя."""

            self.close_modal_window("add_AD_user")

        def close_add_AD_user_window_by_toolbar_button(self) -> None:
            """Закрывает окно добавления пользователя через тулбар."""

            self.close_modal_window_by_toolbar_button("add_AD_user")

        def close_add_user_window(self) -> None:
            """Закрывает окно добавления пользователя."""

            self.close_modal_window("add_local_user")

        def close_add_user_window_by_toolbar_button(self) -> None:
            """Закрывает окно добавления пользователя через тулбар."""

            self.close_modal_window_by_toolbar_button("add_local_user")

        def close_edit_user_window(self, title: str) -> None:
            """Закрывает окно редактирования пользователя.

            Args:
                title: Имя пользователя (заголовок окна).
            """

            self.close_modal_window(title)

        def close_edit_user_window_by_toolbar_button(self, title: str) -> None:
            """Закрывает окно редактирования через кнопку в тулбаре.

            Args:
                title: Имя пользователя (заголовок окна).
            """

            self.close_modal_window_by_toolbar_button(title)

        def close_modal_window(self, title: str) -> None:
            """Закрывает модальное окно через кнопку закрытия.

            Args:
                title: Заголовок окна.
            """

            modal_window = self.get_modal_window(title)
            modal_window.close_window()
            self.delete_modal_window(title)

        def close_modal_window_by_toolbar_button(self, title: str) -> None:
            """Закрывает модальное окно через кнопку в тулбаре.

            Args:
                title: Заголовок окна.
            """

            modal_window = self.get_modal_window(title)
            modal_window.close_window_by_toolbar_button()
            self.delete_modal_window(title)

        def delete_modal_window(self, title: str) -> None:
            """Удаляет модальное окно из коллекции.

            Args:
                title: Заголовок окна.

            Raises:
                AssertionError: Если окно не найдено.
            """

            if self.modal_windows.get(title) is None:
                assert False, f"Modal window with title '{title}' not found"
            self.modal_windows[title] = None

        def delete_user(self, user_name: str) -> None:
            """Удаляет пользователя.

            Args:
                user_name: Имя пользователя.

            Raises:
                AssertionError: Если нет сообщения об успешном удалении.
            """

            self.get_modal_window(user_name).delete_user()

            alert_type = self.alert.get_alert_type()
            assert alert_type == "success", f"Expected success alert, but got {alert_type} alert"

            self.alert.check_alert_presence('\nПользователь удалён\n')
            self.alert.check_alert_absence('\nПользователь удалён\n')

        def edit_user(self, user_name: str, user_data: dict) -> None:
            """Редактирует данные пользователя.

            Args:
                user_name: Имя пользователя.
                user_data: Новые данные пользователя.

            Raises:
                AssertionError: Если нет сообщения об успешном обновлении.
            """

            self.get_modal_window(user_name).edit_user(user_data)

            alert_type = self.alert.get_alert_type()
            assert alert_type == "success", f"Expected success alert, but got {alert_type} alert"

            self.alert.check_alert_presence('\nОбновление успешно\n')
            self.alert.check_alert_absence('\nОбновление успешно\n')

        def find_user_in_table(self, name: str, role: str) -> int:
            """Ищет пользователя в таблице.

            Args:
                name: Имя пользователя.
                role: Роль пользователя.

            Returns:
                int: Индекс строки или -1 если не найден.

            Raises:
                AssertionError: Если таблица пуста.
            """

            self.page.wait_for_timeout(1000)

            table_content = self.users_table.read(TableLocators.TABLE_WORK_AREA)
            if len(table_content) == 0:
                assert False, "The contents of the table are missing"

            # Удаляем заголовок
            del table_content[0]

            for row_index, user_info in enumerate(table_content):
                if name in user_info and role in user_info:
                    return row_index
            return -1

        def get_modal_window(self, title: str) -> ModalWindowComponent:
            """Возвращает модальное окно по заголовку.

            Args:
                title: Заголовок окна.

            Returns:
                ModalWindowComponent: Экземпляр модального окна.

            Raises:
                AssertionError: Если окно не найдено.
            """

            modal_window = self.modal_windows.get(title)
            if modal_window is None:
                assert False, f"Modal window with title '{title}' not found"
            return modal_window

        def open_add_user_window(self) -> None:
            """Открывает окно добавления пользователя.

            Raises:
                AssertionError: Если кнопки недоступны или окно не открылось.
            """

            if self.toolbar.is_button_not_present("close"):
                self.toolbar.check_button_visibility("edit")
                self.toolbar.click_button("edit")

            self.toolbar.check_button_visibility("add_user")
            self.toolbar.click_button("add_user")
            self.page.wait_for_timeout(700)

            self.add_modal_window("add_local_user", "")
            self.get_modal_window("add_local_user").check_by_window_title()

        def open_edit_user_page_by_index(self, row_index: int) -> tuple:
            """Открывает окно редактирования по индексу строки.

            Args:
                row_index: Индекс строки в таблице.

            Returns:
                tuple: (имя пользователя, роль).

            Raises:
                AssertionError: Если таблица пуста или индекс вне диапазона.
            """

            self.page.wait_for_timeout(2000)

            tmp_dict = {"admin": "Администратор", "manager": "Контактное лицо",
                       "operator": "Оператор"}
            table_content = self.users_table.read(TableLocators.TABLE_WORK_AREA)

            if len(table_content) == 0:
                assert False, "The contents of the table are missing"

            # Удаляем заголовок
            del table_content[0]

            if row_index >= len(table_content):
                assert False, "Row_index is out of range"

            user_name = table_content[row_index][0]
            for key, val in tmp_dict.items():
                if user_name == val:
                    user_name = key

            role = table_content[row_index][2]

            self.page.locator(TableLocators.TABLE_WORK_AREA).locator(
                "//tbody/tr").nth(row_index).click()
            self.add_modal_window("edit_user", user_name)
            self.get_modal_window(user_name).check_by_window_title()

            return user_name, role

        def open_edit_user_page_by_user(self, user_name: str, role: str) -> None:
            """Открывает окно редактирования по имени и роли.

            Args:
                user_name: Имя пользователя.
                role: Роль пользователя.

            Raises:
                AssertionError: Если пользователь не найден.
            """

            row_index = self.find_user_in_table(user_name, role)
            if row_index == -1:
                assert False, f"User with name {user_name} and role {role} has not been found"

            self.page.locator(TableLocators.TABLE_WORK_AREA).locator("//tbody/tr").nth(row_index).click()
            self.add_modal_window("edit_user", user_name)
            self.get_modal_window(user_name).check_by_window_title()

        def reset_password(self, user_name: str) -> str:
            """Сбрасывает пароль пользователя.

            Args:
                user_name: Имя пользователя.

            Returns:
                str: Новый пароль (если получен).
            """

            new_password = ""
            self.get_modal_window(user_name).reset_password()

            self.alert.check_alert_presence("")
            alert_message = self.alert.get_text()
            if len(alert_message) > 0:
                new_password = re.findall(r'[\d]+', alert_message)[0]

            return new_password

        def transform_to_add_AD_user_window(self):
            """Трансформирует модальное окно добавления локального пользователя
               в окно добавления пользователя Active Directory с помощью нажатия
               чек-бокса Active Directory.
            """

            self.get_modal_window("add_local_user").check_active_directory_checkbox()
            modal_window = self.modal_windows.get("add_AD_user")
            if modal_window is None:
                self.add_modal_window("add_AD_user", "")

        def transform_to_add_user_window(self):
            """Трансформирует модальное окно добавления пользователя Active Directory
               в окно добавления локального пользователя с помощью снятия отметки с
               чек-бокса Active Directory.
            """

            self.get_modal_window("add_AD_user").uncheck_active_directory_checkbox()
            modal_window = self.modal_windows.get("add_local_user")
            if modal_window is None:
                self.add_modal_window("add_local_user", "")

        # Проверки:

        def check_add_AD_user_window_content(self) -> None:
            """Проверяет содержимое окна добавления пользователя через Active Directory."""

            self.get_modal_window("add_AD_user").check_content()

        def check_add_user_window_content(self) -> None:
            """Проверяет содержимое окна добавления локального пользователя."""

            self.get_modal_window("add_local_user").check_content()

        def check_edit_user_window_content(self, user_name: str, role: str) -> None:
            """Проверяет содержимое окна редактирования.

            Args:
                user_name: Имя пользователя.
                role: Роль пользователя.
            """

            edit_user_window = self.get_modal_window(user_name)
            edit_user_window.check_content(user_name, role)

        def check_users_table_content(self, verify: bool = False) -> None:
            """Проверяет содержимое таблицы пользователей.

            Args:
                verify: Проверять соответствие данных из БД. По умолчанию False.

            Raises:
                AssertionError: Если таблица пуста или заголовки неверны.
            """
            self.page.wait_for_timeout(2000)

            expected_headers = ['Имя пользователя', 'Тип авторизации', 'Роль',
                               'E-mail', 'Номер для СМС']
            table_content = self.users_table.read(TableLocators.TABLE_WORK_AREA)

            if len(table_content) == 0:
                assert False, "The contents of the table are missing"

            actual_headers = table_content[0]
            self.check_equals(
                actual_headers,
                expected_headers,
                f"Expected table headers {expected_headers} are not equal {actual_headers}"
            )

            if len(table_content) == 1:
                assert False, "Table body is missing"

            if verify:
                self.verify_users_table_content(table_content)

        def should_be_toolbar(self) -> None:
            """Проверяет наличие тулбара.

            Raises:
                AssertionError: Если тулбар или кнопка редактирования отсутствуют.
            """

            self.toolbar.check_toolbar_presence("Toolbar is missing")
            self.toolbar.check_button_visibility("edit")

        def should_be_toolbar_buttons(self) -> None:
            """Проверяет наличие и функциональность кнопок тулбара.

            Raises:
                AssertionError: Если кнопки недоступны или подсказки неверны.
            """

            self.toolbar.check_button_visibility("edit")
            self.toolbar.check_button_tooltip("edit", "Редактировать")

            self.toolbar.get_button_by_name("edit").click()
            self.toolbar.check_button_visibility("add_user")
            self.toolbar.check_button_visibility("close")
            self.toolbar.check_button_tooltip("add_user", "Добавить")
            self.toolbar.check_button_tooltip("close", "Закрыть")

            self.toolbar.get_button_by_name("close").click()
            self.toolbar.check_button_visibility("edit")

        def should_be_user_in_table(self, name: str, role: str) -> None:
            """Проверяет наличие пользователя в таблице.

            Args:
                name: Имя пользователя.
                role: Роль пользователя.

            Raises:
                AssertionError: Если пользователь не найден.
            """

            found = self.find_user_in_table(name, role)
            if found == -1:
                assert False, f"User with name {name} and role {role} has not been found"

        def should_be_users_table(self) -> None:
            """Проверяет наличие таблицы пользователей.

            Raises:
                AssertionError: Если таблица отсутствует.
            """

            self.users_table.check_visibility(TableLocators.TABLE_WORK_AREA,"Users table is missing")

        def should_not_be_user_in_table(self, name: str, role: str) -> None:
            """Проверяет отсутствие пользователя в таблице.

            Args:
                name: Имя пользователя.
                role: Роль пользователя.

            Raises:
                AssertionError: Если пользователь найден.
            """

            found = self.find_user_in_table(name, role)
            if found != -1:
                assert False, f"User with name {name} and role {role} has been found"

        def verify_users_table_content(self, users_table: list) -> None:
            """Сверяет данные таблицы с данными из БД.

            Args:
                users_table: Данные из таблицы на странице.

            Raises:
                AssertionError: Если данные не соответствуют.
            """

            expected_users_list = []

            query = {
                "id": ["/catalogs/user"],
                "data": {
                    "namePath": True,
                    "children": {"flatten": True}
                }
            }

            response = self.send_post_api_request("e-cmdb/api/query", query)
            response_body = self.get_response_body(response)

            for item in response_body[0]["children"]:
                user_info = []
                user_name = item["name"]

                # НЕ преобразуем имя пользователя - оставляем как есть из БД
                user_info.append(user_name)

                if item["type_auth"] is not None:
                    user_info.append(item["type_auth"])
                else:
                    user_info.append("")

                if item["role"] is not None:
                    role = item["role"]
                    # Убрали вызов .keys()
                    if role in roles_dict:
                        item["role"] = roles_dict[role]
                    user_info.append(item["role"])
                else:
                    user_info.append("")

                if item["email"] is not None:
                    user_info.append(item["email"])
                else:
                    user_info.append("")

                if item["sms_phone"] is not None:
                    user_info.append(item["sms_phone"])
                else:
                    user_info.append("")

                expected_users_list.append(user_info)

            # Удаляем заголовок
            del users_table[0]

            self.check_lists_equals(
                users_table,
                expected_users_list,
                "Actual users list is not equal expected users list on base db"
            )