playwrite/db/bip_users_dao.py

"""
BIPUsers DAO - Data access object for user authentication and management
"""
from typing import Optional, Dict, Any, List
from db.connection import get_connection


class BIPUsersDAO:
    """Data access object for BIPUsers table"""

    def authenticate(self, username: str, password: str) -> Optional[Dict[str, Any]]:
        """
        Authenticate a user with username and password

        Args:
            username: The username to authenticate
            password: The password to verify

        Returns:
            Dict with user info if authentication successful, None otherwise
            Returns: {id, username, user_type}
        """
        sql = """
        SELECT [ID], [UserName], [UserType]
        FROM [dbo].[BIPUsers]
        WHERE [UserName] = ? AND [Password] = ?
        """
        with get_connection() as db:
            results = db.execute_query(sql, (username, password))
            if results:
                return {
                    'id': results[0]['ID'],
                    'username': results[0]['UserName'],
                    'user_type': results[0]['UserType']
                }
        return None

    def get_all_users(self) -> List[Dict[str, Any]]:
        """
        Get all users from the database

        Returns:
            List of user dictionaries: [{id, username, user_type, create_time}]
        """
        sql = """
        SELECT [ID], [UserName], [UserType], [CreateTime]
        FROM [dbo].[BIPUsers]
        ORDER BY [UserName]
        """
        with get_connection() as db:
            results = db.execute_query(sql)
            return [
                {
                    'id': row['ID'],
                    'username': row['UserName'],
                    'user_type': row['UserType'],
                    'create_time': row['CreateTime']
                }
                for row in results
            ]

    def create_user(self, username: str, password: str, user_type: str) -> bool:
        """
        Create a new user

        Args:
            username: The username (must be unique)
            password: The password (plain text for internal tool)
            user_type: User type ('Admin', 'User', or 'Guest')

        Returns:
            True if successful, False otherwise
        """
        sql = """
        INSERT INTO [dbo].[BIPUsers] ([UserName], [Password], [UserType])
        VALUES (?, ?, ?)
        """
        try:
            with get_connection() as db:
                db.execute_update(sql, (username, password, user_type))
                return True
        except Exception as e:
            print(f"Error creating user: {e}")
            return False

    def update_user_type(self, username: str, user_type: str) -> bool:
        """
        Update a user's type

        Args:
            username: The username to update
            user_type: New user type ('Admin', 'User', or 'Guest')

        Returns:
            True if successful, False otherwise
        """
        sql = """
        UPDATE [dbo].[BIPUsers]
        SET [UserType] = ?
        WHERE [UserName] = ?
        """
        try:
            with get_connection() as db:
                db.execute_update(sql, (user_type, username))
                return True
        except Exception as e:
            print(f"Error updating user type: {e}")
            return False

    def update_password(self, username: str, new_password: str) -> bool:
        """
        Update a user's password

        Args:
            username: The username to update
            new_password: The new password (plain text for internal tool)

        Returns:
            True if successful, False otherwise
        """
        sql = """
        UPDATE [dbo].[BIPUsers]
        SET [Password] = ?
        WHERE [UserName] = ?
        """
        try:
            with get_connection() as db:
                db.execute_update(sql, (new_password, username))
                return True
        except Exception as e:
            print(f"Error updating password: {e}")
            return False

    def delete_user(self, username: str) -> bool:
        """
        Delete a user

        Args:
            username: The username to delete

        Returns:
            True if successful, False otherwise
        """
        sql = """
        DELETE FROM [dbo].[BIPUsers]
        WHERE [UserName] = ?
        """
        try:
            with get_connection() as db:
                db.execute_update(sql, (username,))
                return True
        except Exception as e:
            print(f"Error deleting user: {e}")
            return False

    def user_exists(self, username: str) -> bool:
        """
        Check if a username already exists

        Args:
            username: The username to check

        Returns:
            True if username exists, False otherwise
        """
        sql = """
        SELECT COUNT(*) as count FROM [dbo].[BIPUsers]
        WHERE [UserName] = ?
        """
        with get_connection() as db:
            results = db.execute_query(sql, (username,))
            return results[0]['count'] > 0 if results else False