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

    """Модуль вкладки 'Сеансы/Текущие'.

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

    from playwright.sync_api import Page, Locator
    from locators.table_locators import TableLocators
    from locators.button_locators import ButtonLocators
    from elements.tooltip_button_element import TooltipButton
    from data.roles_dict import roles_dict
    from data.environment import host
    from components.toolbar_component import ToolbarComponent
    from components.table_component import TableComponent
    from components.confirm_component import ConfirmComponent
    from pages.base_page import BasePage

    class CurrentSessionsTab(BasePage):
        """Класс для работы с вкладкой 'Сеансы/Текущие'.

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

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

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

            super().__init__(page)

            self.toolbar = ToolbarComponent(page, "Сеансы")
            self.sessions_table = TableComponent(page)

            self.delete_session_confirm = ConfirmComponent(page, " Отмена ", " Удалить ")

        # Действия:

        def get_rows_count(self) -> int:
            """Возвращает количество строк в таблице (без заголовка).

            Returns:
                int: Количество строк с данными.

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

            return self.sessions_table.get_rows_count(TableLocators.TABLE_WORK_AREA)

        def get_delete_session_button_from_row(self, row_index: int) -> TooltipButton:
            """Возвращает кнопку удаления сеанса для указанной строки.

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

            Returns:
                TooltipButton: Кнопка с подсказкой.

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

            row_locator = self.sessions_table.get_row_locator(
                TableLocators.TABLE_WORK_AREA,
                row_index
            )
            assert isinstance(row_locator, Locator), f"Row with index {row_index} is missing"

            button_locator = row_locator.locator(ButtonLocators.BUTTON_DELETE_SESSION)
            return TooltipButton(self.page, button_locator, "delete_session_button")

        def get_session_token(self) -> str:
            """Возвращает токен текущего пользователя.

            Args:

            Returns:
                str: Токен текущего пользователя

            Raises:
            """
            return host.get_access_token()

        def find_session_in_table(self, token: str) -> int:
            """Ищет сеанс пользователя в таблице по выданному ему токену.

            Args:
                token (str): Токен пользователя

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

            Raises:
                AssertionError: Если таблица пуста.
            """
            table_content = self.sessions_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, session_info in enumerate(table_content):
                if token in session_info:
                    return row_index
            return -1

        def delete_session_by_token(self, token: str) -> None:
            """Удаляет сеанс по токену.

            Args:
                token (str): Токен сеанс для удаления

            Raises:
                AssertionError: Если сеанс не найден или удаление не удалось.
            """
            row_index = self.find_session_in_table(token)
            if row_index == -1:
                raise AssertionError(f"Session with token {token} not found")

            self.delete_session_by_index(row_index)

        def delete_session_by_index(self, row_index: int) -> None:
            """Удаляет сеанс по индексу строки.

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

            Raises:
                AssertionError: Если удаление не удалось.
            """
            try:
                # Находим кнопку удаления сеанса и нажимаем на нее
                delete_session_button = self.get_delete_session_button_from_row(row_index)
                delete_session_button.click()
                self.page.wait_for_timeout(1000)

                # Подтверждаем удаление
                self.delete_session_confirm.click_allow_button()

                # Ждем обновления таблицы
                self.page.wait_for_timeout(1000)

            except Exception as e:
                raise AssertionError(f"Failed to delete session at index {row_index}: {e}")

        def scroll_sessions_table_up(self) -> None:
            """Прокручивает таблицу сеансов вверх."""

            self.sessions_table.scroll_up(TableLocators.TABLE_SCROLL_CONTAINER)

        def scroll_sessions_table_down(self) -> None:
            """Прокручивает таблицу сеансов вниз."""

            self.sessions_table.scroll_down(TableLocators.TABLE_SCROLL_CONTAINER)

        # Проверки:

        def check_delete_session_confirm_window(self):
            """ Проверяет контент и возможность горизонтального скроллинга окна подтверждения удаления сеанс. """

            # Поиск в таблице сеанс сроки для текущего пользователя
            session_token = self.get_session_token()
            row_index = self.find_session_in_table(session_token)
            if row_index == -1:
                assert False, "Session for this token has not been found"

            # Найти кнопку удаления сеанса и нажать на нее
            delete_session_button = self.get_delete_session_button_from_row(row_index)
            delete_session_button.click()

            # Проверка открытия окна подтверждения с заголовком "Удаление"
            title = "Удаление"
            self.delete_session_confirm.check_title(
                title,
                f"Confirmation dialog window text '{title}' is missing"
            )

            # Проверка текста в окне подтверждения
            confirm_message = f"Удалить сеанс {session_token}?"
            self.delete_session_confirm.check_text(
                confirm_message,
                "Confirmation dialog window text does not match what is expected"
            )

            # Проверка наличия и видимости кнопки "Отмена"
            self.delete_session_confirm.should_be_cancel_button()

            # Проверка наличия и видимости кнопки "Удалить"
            self.delete_session_confirm.should_be_allow_button()

            # Проверка текста на кнопках
            self.delete_session_confirm.check_cancel_button_text(" Отмена ")
            self.delete_session_confirm.check_allow_button_text(" Удалить ")

            # Проверка горизонтального скроллинга
            is_scrollable_horizontally = self.delete_session_confirm.check_window_horizontal_scrolling()
            assert is_scrollable_horizontally, "Should be horizontal scrolling"

            self.delete_session_confirm.scroll_window_right()
            self.page.wait_for_timeout(3000)
            self.delete_session_confirm.scroll_window_left()
            self.page.wait_for_timeout(2000)

            # Нажать кнопку "Отмена"
            self.delete_session_confirm.click_cancel_button()

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

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

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

            expected_headers = [
                'ID сеанса',
                'ID пользователя',
                'Время жизни',
                'Роль',
                'Адрес'
            ]

            table_content = self.sessions_table.read(TableLocators.TABLE_WORK_AREA)
            len_table_content = len(table_content)

            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_sessions_table_content(table_content)

            for index in range(len_table_content - 1):
                self.should_be_delete_button_on_sessions_table_row(index, "Удалить")

        def check_sessions_table_verticall_scrolling(self) -> bool:
            """Проверяет возможность вертикальной прокрутки таблицы.

            Returns:
                bool: True если прокрутка возможна, иначе False.
            """

            return self.sessions_table.is_scrollable_vertically(
                TableLocators.TABLE_SCROLL_CONTAINER
            )

        def check_sessions_table_first_row_visibility(self) -> None:
            """Проверяет видимость первой строки таблицы.

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

            self.sessions_table.check_first_row_visibility(TableLocators.TABLE_WORK_AREA)

        def check_sessions_table_last_row_visibility(self) -> None:
            """Проверяет видимость последней строки таблицы.

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

            self.sessions_table.check_last_row_visibility(TableLocators.TABLE_WORK_AREA)

        def check_sessions_table_row_highlighting(self, row_index: int) -> None:
            """Проверяет выделение указанной строки таблицы.

            Args:
                row_index: Индекс проверяемой строки.

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

            self.sessions_table.check_row_highlighting(
                TableLocators.TABLE_WORK_AREA,
                row_index
            )

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

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

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

        def should_be_sessions_table(self) -> None:
            """Проверяет наличие таблицы сеансов.

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

            self.sessions_table.check_visibility(
                TableLocators.TABLE_WORK_AREA,
                "Sessions table is missing"
            )

        def should_be_delete_button_on_sessions_table_row(
            self,
            row_index: int,
            tooltip: str
        ) -> None:
            """Проверяет наличие кнопки удаления в строке таблицы.

            Args:
                row_index: Индекс проверяемой строки.
                tooltip: Ожидаемый текст подсказки.

            Raises:
                AssertionError: Если кнопка отсутствует или подсказка неверна.
            """
            delete_button = self.get_delete_session_button_from_row(row_index)

            # Ожидаем исчезновения предыдущих подсказок перед проверкой
            delete_button.wait_for_tooltip_to_disappear()

            delete_button.check_visibility(
                f"Delete session button is missing on {row_index} row"
            )
            delete_button.check_tooltip_with_text(tooltip)

            # Ожидаем исчезновения подсказки после проверки
            delete_button.wait_for_tooltip_to_disappear()

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

            Args:
                token (str): Токен пользователя

            Raises:
                AssertionError: Если сеанс не найден.
            """
            found = self.find_session_in_table(token)
            if found == -1:
                assert False, "Session for this token has not been found"

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

            Args:
                token (str): Токен пользователя

            Raises:
                AssertionError: Если сеанс найден.
            """
            found = self.find_session_in_table(token)
            if found != -1:
                assert False, "Session for this token has been found"

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

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

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

            expected_sessions_list = []

            # Отправка запроса к бэкенду для получения информации о сеансах
            response = self.send_get_api_request("e-nms/auth/sessions")
            response_body = self.get_response_body(response)

            for item in response_body:
                session_info = []
                session_info.append(item["id"])
                session_info.append(item["userId"])

                # Временно неподдерживаемое поле: время жизни сеанса
                session_info.append("")

                roles = []
                for role in item["roles"]:
                    if role in roles_dict.keys():
                        roles.append(roles_dict[role])

                session_info.append(",".join(roles))
                session_info.append(item["ip"])

                expected_sessions_list.append(session_info)

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

            self.check_lists_equals(
                sessions_table,
                expected_sessions_list,
                "Actual sessions list is not equal expected users list on base db"
            )