PyPI - auth-gateway-serverkit - Versions diffs - 0.0.0__py3-none-any.whl - Mend

auth-gateway-serverkit 0.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

auth_gateway_serverkit/__init__.py +0 -0
auth_gateway_serverkit/email.py +54 -0
auth_gateway_serverkit/http_client.py +104 -0
auth_gateway_serverkit/keycloak/__init__.py +3 -0
auth_gateway_serverkit/keycloak/authorization_api.py +88 -0
auth_gateway_serverkit/keycloak/client_api.py +645 -0
auth_gateway_serverkit/keycloak/config.py +25 -0
auth_gateway_serverkit/keycloak/initializer.py +106 -0
auth_gateway_serverkit/keycloak/json_transformer.py +65 -0
auth_gateway_serverkit/keycloak/roles_api.py +85 -0
auth_gateway_serverkit/keycloak/user_api.py +268 -0
auth_gateway_serverkit/logger.py +47 -0
auth_gateway_serverkit/main.py +2 -0
auth_gateway_serverkit/middleware/__init__.py +0 -0
auth_gateway_serverkit/middleware/auth.py +173 -0
auth_gateway_serverkit/middleware/config.py +36 -0
auth_gateway_serverkit/middleware/schemas.py +19 -0
auth_gateway_serverkit/password.py +25 -0
auth_gateway_serverkit/request_handler.py +90 -0
auth_gateway_serverkit/string.py +41 -0
auth_gateway_serverkit-0.0.0.dist-info/METADATA +25 -0
auth_gateway_serverkit-0.0.0.dist-info/RECORD +24 -0
auth_gateway_serverkit-0.0.0.dist-info/WHEEL +5 -0
auth_gateway_serverkit-0.0.0.dist-info/top_level.txt +1 -0

auth_gateway_serverkit/__init__.py ADDED Viewed

File without changes

auth_gateway_serverkit/email.py ADDED Viewed

@@ -0,0 +1,54 @@
+""" Email sending module for user notifications in KalSense."""
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from .logger import init_logger
+logger = init_logger('user.email')
+def send_password_email(
+        app_password,
+        app_email,
+        first_name,
+        user_email,
+        user_name,
+        generated_password
+):
+    try:
+        message = MIMEMultipart("alternative")
+        message["From"] = app_email
+        message["To"] = user_email
+        message["Subject"] = "Welcome to KalSense"
+        html = f"""
+        <html>
+        <body>
+        <p>Hi {first_name},<br>
+        Welcome! Your new user was created with the following details: <br>
+        Your user name is: <b>{user_name}</b><br>
+        Your password is: <b>{generated_password}</b><br>
+        Please change it upon your first login.<br>
+        </p>
+        <p>Best Regards,<br>
+        <i>IT Services Team</i>
+        </p>
+        </body>
+        </html>
+        """
+        part = MIMEText(html, "html")
+        message.attach(part)
+        server = smtplib.SMTP("smtp.gmail.com", 587)
+        server.starttls()
+        server.login(app_email, app_password)
+        text = message.as_string()
+        server.sendmail(app_email, user_email, text)
+        server.quit()
+        logger.info(f"Email sent to {user_email}")
+    except smtplib.SMTPException as e:
+        logger.error(f"Failed to send email to {user_email}, error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Failed to send email to {user_email}, error: {str(e)}")

auth_gateway_serverkit/http_client.py ADDED Viewed

@@ -0,0 +1,104 @@
+""" http client utilities for making asynchronous HTTP requests using httpx. """
+import httpx
+from typing import Optional, Dict
+from .logger import init_logger
+logger = init_logger("utils.requests")
+async def post(
+    url: str,
+    json: Optional[dict] = None,
+    data: Optional[dict] = None,
+    files: Optional[dict] = None,
+    headers: Optional[Dict[str, str]] = None,
+    timeout=20,
+    connect=5
+) -> dict:
+    try:
+        timeout = httpx.Timeout(timeout, connect=connect)
+        async with httpx.AsyncClient(timeout=timeout, headers=headers) as client:
+            if json is not None:
+                response = await client.post(url, json=json)
+            elif files is not None or data is not None:
+                response = await client.post(url, data=data, files=files)
+            else:
+                response = await client.post(url, data=data)
+            response.raise_for_status()
+            return response.json()
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error: {e.response.status_code} - {e.response.text} - URL: {url}")
+        raise
+    except Exception as e:
+        logger.error(f"Request error: {e} - URL: {url}")
+        raise
+async def get(
+    url: str,
+    params: dict = None,
+    headers: Optional[Dict[str, str]] = None,
+    timeout=20,
+    connect=5
+) -> dict:
+    try:
+        timeout = httpx.Timeout(timeout, connect=connect)
+        async with httpx.AsyncClient(headers=headers) as client:
+            response = await client.get(url, params=params, timeout=timeout)
+            response.raise_for_status()
+            return response.json()
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error: {e.response.status_code} - {e.response.text}")
+        raise
+    except Exception as e:
+        logger.error(f"Request error: {e}")
+        raise
+async def delete(
+    url: str,
+    params: Optional[dict] = None,
+    headers: Optional[Dict[str, str]] = None,
+    timeout=20,
+    connect=5
+) -> dict:
+    try:
+        timeout = httpx.Timeout(timeout, connect=connect)
+        async with httpx.AsyncClient(timeout=timeout, headers=headers) as client:
+            response = await client.delete(url, params=params)
+            response.raise_for_status()
+            return response.json()
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error: {e.response.status_code} - {e.response.text} - URL: {url}")
+        raise
+    except Exception as e:
+        logger.error(f"Request error: {e} - URL: {url}")
+        raise
+async def put(
+    url: str,
+    json: Optional[dict] = None,
+    data: Optional[dict] = None,
+    files: Optional[dict] = None,
+    headers: Optional[Dict[str, str]] = None,
+    timeout=20,
+    connect=5
+) -> dict:
+    try:
+        timeout = httpx.Timeout(timeout, connect=connect)
+        async with httpx.AsyncClient(timeout=timeout, headers=headers) as client:
+            if json is not None:
+                response = await client.put(url, json=json)
+            elif files is not None or data is not None:
+                response = await client.put(url, data=data, files=files)
+            else:
+                response = await client.put(url, data=data)
+            response.raise_for_status()
+            return response.json()
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error: {e.response.status_code} - {e.response.text} - URL: {url}")
+        raise
+    except Exception as e:
+        logger.error(f"Request error: {e} - URL: {url}")
+        raise

auth_gateway_serverkit/keycloak/__init__.py ADDED Viewed

@@ -0,0 +1,3 @@
+"""
+"""

auth_gateway_serverkit/keycloak/authorization_api.py ADDED Viewed

@@ -0,0 +1,88 @@
+import aiohttp
+from typing import Dict, Optional
+from .config import settings
+from .client_api import get_admin_token, get_client_uuid
+from ..logger import init_logger
+from .json_transformer import KeycloakConfigTransformer
+logger = init_logger("serverkit.keycloak.authorization")
+class KeycloakAuthorizationAPI:
+    def __init__(self):
+        self.base_url = f"{settings.SERVER_URL}/admin/realms/{settings.REALM}"
+    async def update_authorization_config(self, authorization_config: Dict) -> bool:
+        """Update complete authorization configuration via API"""
+        try:
+            # Get admin token and client UUID
+            admin_token = await get_admin_token()
+            if not admin_token:
+                logger.error("Failed to get admin token")
+                return False
+            client_uuid = await get_client_uuid(admin_token)
+            if not client_uuid:
+                logger.error("Failed to get client UUID")
+                return False
+            # Update authorization settings
+            url = f"{self.base_url}/clients/{client_uuid}/authz/resource-server"
+            headers = {
+                'Authorization': f'Bearer {admin_token}',
+                'Content-Type': 'application/json'
+            }
+            async with aiohttp.ClientSession() as session:
+                async with session.put(url, json=authorization_config, headers=headers) as response:
+                    if response.status == 200:
+                        logger.info("Authorization configuration updated successfully")
+                        return True
+                    else:
+                        error_text = await response.text()
+                        logger.error(f"Failed to update authorization config: {error_text}")
+                        return False
+        except Exception as e:
+            logger.error(f"Error updating authorization configuration: {e}")
+            return False
+    async def sync_configuration(self, config_file_path: str) -> bool:
+        """Load, transform, and sync configuration"""
+        try:
+            # Transform configuration
+            transformer = KeycloakConfigTransformer()
+            keycloak_config = transformer.load_and_transform(config_file_path)
+            # Update via API
+            return await self.update_authorization_config(keycloak_config)
+        except Exception as e:
+            logger.error(f"Error syncing configuration: {e}")
+            return False
+    async def get_current_authorization_config(self) -> Optional[Dict]:
+        """Get current authorization configuration"""
+        try:
+            admin_token = await get_admin_token()
+            client_uuid = await get_client_uuid(admin_token)
+            url = f"{self.base_url}/clients/{client_uuid}/authz/resource-server"
+            headers = {'Authorization': f'Bearer {admin_token}'}
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers) as response:
+                    if response.status == 200:
+                        return await response.json()
+                    else:
+                        logger.error(f"Failed to get current config: {response.status}")
+                        return None
+        except Exception as e:
+            logger.error(f"Error getting current configuration: {e}")
+            return None