dmart 1.4.40.post8__py3-none-any.whl

dmart/utils/settings.py

@@ -0,0 +1,212 @@
+""" Application Settings """
+
+import json
+import os
+import random
+import re
+import string
+import secrets
+from venv import logger
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pathlib import Path
+
+def get_env_file():
+    env_file = os.getenv("BACKEND_ENV")
+
+    if env_file and os.path.exists(env_file):
+        return env_file
+    
+    if not env_file or env_file == "config.env":
+        if os.path.exists("config.env"):
+            return "config.env"
+
+        dmart_home = Path.home() / ".dmart"
+        home_config = dmart_home / "config.env"
+        
+        if not home_config.exists():
+            if not (os.path.exists(".git") or os.path.exists("setup.py")):
+                try:
+                    dmart_home.mkdir(parents=True, exist_ok=True)
+                    (dmart_home / "logs").mkdir(parents=True, exist_ok=True)
+                    (dmart_home / "spaces").mkdir(parents=True, exist_ok=True)
+                    (dmart_home / "spaces" / "custom_plugins").mkdir(parents=True, exist_ok=True)
+                    
+                    jwt_secret = secrets.token_urlsafe(32)
+                    
+                    config_content = f"""# dmart configuration
+JWT_SECRET="{jwt_secret}"
+JWT_ALGORITHM="HS256"
+LOG_FILE="{dmart_home / 'logs' / 'dmart.ljson.log'}"
+WS_LOG_FILE="{dmart_home / 'logs' / 'websocket.ljson.log'}"
+
+# Database configuration
+ACTIVE_DATA_DB="file"
+SPACES_FOLDER="{dmart_home / 'spaces'}"
+DATABASE_DRIVER="sqlite+pysqlite"
+DATABASE_NAME="{dmart_home / 'dmart.db'}"
+
+# Server configuration
+LISTENING_HOST="0.0.0.0"
+LISTENING_PORT=8282
+"""
+                    home_config.write_text(config_content)
+                except Exception:
+                    pass
+        
+        if home_config.exists():
+            return str(home_config)
+
+    return env_file or "config.env"
+
+class Settings(BaseSettings):
+    """Main settings class"""
+
+    app_url: str = ""
+    cxb_url: str = "/cxb"
+    public_app_url: str = ""
+    app_name: str = "dmart"
+    websocket_url: str = "" #"http://127.0.0.1:8484"
+    websocket_port: int = 8484
+    base_path: str = ""
+    debug_enabled: bool = True
+    log_handlers: list[str] = ['file']
+    log_file: str = "../logs/dmart.ljson.log"
+    ws_log_file: str = "../logs/websocket.ljson.log"
+    jwt_secret: str = "".join(random.sample(string.ascii_letters + string.digits,12))
+    jwt_algorithm: str = "HS256"
+    jwt_access_expires: int = 30 * 86400  # 30 days
+    listening_host: str = "0.0.0.0"
+    listening_port: int = 8282
+    redis_host: str = "127.0.0.1"
+    redis_password: str = ""
+    redis_port: int = 6379
+    redis_pool_max_connections: int = 20
+    max_sessions_per_user: int = 5
+    management_space: str = "management"
+    users_subpath: str = "users"
+    spaces_folder: Path = Path("../sample/spaces/")
+    lock_period: int = 300
+    auto_uuid_rule: str = "auto"  # Used to generate a shortname from UUID
+    google_application_credentials: str = ""
+    is_registrable: bool = True
+    is_otp_for_create_required: bool = True
+    social_login_allowed: bool = True
+    all_spaces_mw: str = (
+        "__all_spaces__"  # magic word used in access control refers to any space
+    )
+    all_subpaths_mw: str = (
+        "__all_subpaths__"  # used in access control refers to all subpaths
+    )
+    current_user_mw: str = (
+        "__current_user__"  # used in access control refers to current logged-in user
+    )
+    root_subpath_mw : str = "__root__"
+    email_sender: str = "dmart@dmart.com"
+
+    otp_token_ttl: int = 60 * 5
+    allow_otp_resend_after: int = 60
+    comms_api: str = ""
+    send_sms_otp_api: str = ""
+    smpp_auth_key: str = ""
+    send_email_otp_api: str = ""
+    send_sms_api: str = ""
+    send_email_api: str = ""
+    mock_smtp_api: bool = True
+    files_query: str = "scandir"
+    mock_smpp_api: bool = True
+    mock_otp_code: str = "123456"
+    invitation_link: str = ""
+    ldap_url: str = "ldap://"
+    ldap_admin_dn: str = ""
+    ldap_root_dn: str = ""
+    ldap_pass: str = ""
+    max_query_limit: int = 10000
+    session_inactivity_ttl: int = 0 # Set initially to 0 to disable session timeout. Possible value : 60 * 60 * 24 * 7  # 7 days
+    request_timeout: int = 35 # In seconds the time of dmart requests.
+    jq_timeout: int = 2 # secs
+    is_sha_required: bool = False
+    logout_on_pwd_change: bool = True
+    url_shorter_expires: int = 60 * 60 * 48  # 48 hours
+
+    google_client_id: str = ""
+    google_client_secret: str = ""
+    apple_client_id: str = ""
+    apple_client_secret: str = ""
+
+    facebook_client_id: str = ""
+    facebook_client_secret: str = ""
+    
+    enable_channel_auth: bool = False
+    channels: list = []
+    store_payload_string: bool = True
+
+    active_operational_db: str = "redis"  # allowed values: redis, manticore
+    active_data_db: str = "file"  # allowed values: file, sql
+
+    database_driver: str = 'sqlite+pysqlite'
+    database_username: str = 'postgres'
+    database_password: str = ''
+    database_host: str = 'localhost'
+    database_port: int = 5432
+    database_name: str = 'dmart'
+    database_pool_size: int = 2
+    database_max_overflow: int = 2
+    database_pool_timeout: int = 30
+    database_pool_recycle: int = 30
+
+    hide_stack_trace: bool = False
+    max_failed_login_attempts: int = 5
+
+
+    model_config = SettingsConfigDict(
+        env_file=get_env_file(),
+        env_file_encoding="utf-8"
+    )
+    
+    def load_config_files(self) -> None:
+        channels_config_file = Path(__file__).resolve().parent.parent / 'config/channels.json'
+        if channels_config_file.exists():
+            try:
+                with open(channels_config_file, 'r') as file:
+                    self.channels = json.load(file)
+                
+                # Compile the patterns for better performance
+                for idx, channel in enumerate(self.channels):
+                    compiled_patterns: list[re.Pattern] = []
+                    for pattern in channel.get("allowed_api_patterns", []):
+                        compiled_patterns.append(re.compile(pattern))
+                    self.channels[idx]["allowed_api_patterns"] = compiled_patterns
+                    
+            except Exception as e:
+                logger.error(f"Failed to open the channel config file at {channels_config_file}. Error: {e}")
+
+    raw_allowed_submit_models: str = Field(default="",alias="allowed_submit_models")
+
+    @property
+    def allowed_submit_models(self) -> dict[str, list[str]]:
+        allowed_models_str = self.raw_allowed_submit_models
+        result: dict = {}
+        if allowed_models_str:
+            entries = allowed_models_str.split(",")
+            for entry in entries:
+                entry = entry.strip()
+                if "." in entry:
+                    space, schema = entry.split(".", 1)
+                    if space not in result:
+                        result[space] = []
+                    result[space].append(schema)
+        return result
+
+try:
+    Settings.model_validate(
+        Settings()
+    )
+except Exception as e:
+    logger.error(f"Failed to load settings.\nError: {e}")
+    # sys.exit(1)
+    pass
+
+settings = Settings()
+settings.load_config_files()

dmart/utils/sms_notifier.py

@@ -0,0 +1,21 @@
+from api.user.service import send_sms
+from models.core import NotificationData
+from utils.helpers import lang_code
+from utils.notification import Notifier
+
+
+class SMSNotifier(Notifier):
+    
+    async def send(
+        self, 
+        data: NotificationData
+    ) -> bool:
+        user_lang = lang_code(data.receiver.get("language", "ar"))
+        if "msisdn" not in data.receiver:
+            return False
+        await send_sms(
+            data.receiver["msisdn"], 
+            data.title.__getattribute__(user_lang)
+        )
+        return True
+

dmart/utils/social_sso.py

@@ -0,0 +1,67 @@
+from typing import Any, Optional
+from fastapi_sso.sso.facebook import FacebookSSO
+from fastapi_sso.sso.google import GoogleSSO
+from httpx import AsyncClient
+from utils.settings import settings
+from fastapi_sso.sso.generic import create_provider
+from fastapi_sso.sso.base import OpenID, SSOBase, DiscoveryDocument
+
+
+FACEBOOK_CLIENT_ID = settings.facebook_client_id
+FACEBOOK_CLIENT_SECRET = settings.facebook_client_secret
+
+
+def get_facebook_sso() -> FacebookSSO:
+    return FacebookSSO(
+        FACEBOOK_CLIENT_ID,
+        FACEBOOK_CLIENT_SECRET,
+        redirect_uri=f"{settings.app_url}/user/facebook/callback",
+    )
+
+
+GOOGLE_CLIENT_ID = settings.google_client_id
+GOOGLE_CLIENT_SECRET = settings.google_client_secret
+
+
+def get_google_sso() -> GoogleSSO:
+    return GoogleSSO(
+        GOOGLE_CLIENT_ID,
+        GOOGLE_CLIENT_SECRET,
+        redirect_uri=f"{settings.app_url}/user/google/callback",
+    )
+
+# Apple SSO
+APPLE_CLIENT_ID = settings.apple_client_id # Your Apple Services ID 
+APPLE_CLIENT_SECRET = settings.apple_client_secret
+
+def apple_response_convertor(response: dict[str, Any], client: Optional[AsyncClient] = None) -> OpenID:
+    return OpenID(
+        id=response.get("sub"),
+        email=response.get("email"),
+        first_name=response.get("fullName", []).split(" ")[0],
+        last_name=response.get("fullName", []).split(" ")[-1],
+        picture=response.get("picture"),
+        provider="apple",
+    )
+    
+def get_apple_sso() -> SSOBase:
+    apple_discovery = DiscoveryDocument({
+        "authorization_endpoint":"https://appleid.apple.com/auth/authorize",
+        "token_endpoint":"https://appleid.apple.com/auth/token",
+        #"jwks_uri":"https://appleid.apple.com/auth/keys",
+        "userinfo_endpoint": "http://localhost:9090/me",
+        
+    })
+    AppleProvider: type[SSOBase] = create_provider(
+        name="apple", 
+        discovery_document=apple_discovery,
+        default_scope=["fullName", "email"],
+        response_convertor=apple_response_convertor
+    )
+    
+    return AppleProvider(
+        client_id=APPLE_CLIENT_ID,
+        client_secret=APPLE_CLIENT_SECRET,
+        redirect_uri=f"{settings.app_url}/user/apple/callback",
+        allow_insecure_http=True
+    )

dmart/utils/templates/activation.html.j2

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Email</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  </head>
+  <body style="margin: 0; padding: 0">
+
+    <p>Hi {{name}}</p>
+    <p>MSISDN: {{msisdn}}</p>
+    <p>Username: {{shortname}}</p>
+
+    <p>Welcome, we're happy to see you on board!</p>
+
+    <p>Only Few steps are left to activate your account, please use the below account activation link.</p>
+
+    <p>Activation Link:</p>
+
+    <a href="{{ link }}">{{ link }}</a>
+
+    <p>Regards,</p>
+
+  </body>
+</html>

dmart/utils/templates/reminder.html.j2

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <title>Email</title>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    </head>
+    <body style="margin: 0; padding: 0">
+        <p>Hi {{ name }},</p>
+        <p>We would like to remind you to activate your account. We will be happy to see you on board!</p>
+        <p>Few steps are left to activate your account, please use the below account activation link.</p>
+        <p>Activation Link:</p>
+        {{ link }}
+        <p>Regards,</p>
+    </body>
+</html>

dmart/utils/ticket_sys_utils.py

@@ -0,0 +1,203 @@
+import models.api as api
+from fastapi import status
+from data_adapters.adapter import data_adapter as db
+import models.core as core
+from utils.internal_error_code import InternalErrorCode
+from utils.settings import settings
+from typing import Any
+
+
+async def get_init_state_from_workflow(space_name: str, workflow_shortname: str):
+    payload = await db.load_resource_payload(
+        space_name=space_name,
+        subpath="workflows",
+        filename=workflow_shortname,
+        class_type=core.Content,
+    )
+
+    if payload is None:
+        raise api.Exception(
+            status.HTTP_400_BAD_REQUEST,
+            api.Error(
+                type="request",
+                code=InternalErrorCode.SHORTNAME_ALREADY_EXIST,
+                message="Workflow not found",
+            ),
+        )
+
+    return payload['initial_state'][0]['name']
+
+async def set_init_state_for_record(record: core.Record, space_name: str, logged_in_user: str):
+    workflow_attr = record.attributes
+    workflow_shortname = workflow_attr["workflow_shortname"]
+
+    _user_roles = await db.get_user_roles(logged_in_user)
+    user_roles = _user_roles.keys()
+
+    workflows_data: core.Content = await db.load(
+        space_name=space_name,
+        subpath="workflows",
+        shortname=workflow_shortname,
+        class_type=core.Content,
+        user_shortname=logged_in_user,
+    )
+
+    if workflows_data is not None and workflows_data.payload is not None:
+        workflows_payload: dict[str,Any]
+        if isinstance(workflows_data.payload.body, dict):
+            workflows_payload = workflows_data.payload.body
+        else:
+            payload = await db.load_resource_payload(
+                space_name=space_name,
+                subpath="workflows",
+                filename=str(workflows_data.payload.body),
+                class_type=core.Content,
+            )
+            workflows_payload = payload if payload else {}
+
+        initial_state = None
+
+        for state in workflows_payload["initial_state"]:
+            if initial_state is None and "default" in state["roles"]:
+                initial_state = state["name"]
+            elif [role in user_roles for role in state["roles"]].count(True):
+                initial_state = state["name"]
+                break
+
+        if initial_state is None:
+            raise api.Exception(
+                status.HTTP_400_BAD_REQUEST,
+                api.Error(
+                    type="request",
+                    code=InternalErrorCode.NOT_ALLOWED,
+                    message="The user does not have the required roles to create this ticket",
+                ),
+            )
+
+        record.attributes = {
+            **workflow_attr,
+            "state": initial_state,
+            "is_open": True,
+        }
+        return record
+
+    raise api.Exception(
+        status.HTTP_400_BAD_REQUEST,
+        api.Error(
+            type="request",
+            code=InternalErrorCode.SHORTNAME_ALREADY_EXIST,
+            message="This shortname already exists",
+        ),
+    )
+
+
+async def set_init_state_from_record(
+    ticket: core.Record, logged_in_user, space_name
+):
+    workflow_attr = ticket.attributes
+    workflow_shortname = workflow_attr["workflow_shortname"]
+
+    workflows_data = await db.load(
+        space_name=space_name,
+        subpath="workflows",
+        shortname=workflow_shortname,
+        class_type=core.Content,
+        user_shortname=logged_in_user,
+    )
+
+    if workflows_data is not None and workflows_data.payload is not None:
+        # file: fetch payload from file
+        # sql: payload is already within the entry
+        workflows_payload : dict[str, Any] = {}
+        mypayload = workflows_data.payload.body
+        if settings.active_data_db == "file" and isinstance(mypayload, str):
+            payload = await db.load_resource_payload(
+                space_name=space_name,
+                subpath="workflows",
+                filename=mypayload,
+                class_type=core.Content,
+            )
+            workflows_payload = payload if payload else {}
+        elif isinstance(mypayload, dict):
+                workflows_payload = mypayload
+        else:
+            raise api.Exception(
+                status.HTTP_500_INTERNAL_SERVER_ERROR,
+                api.Error(
+                    type="request",
+                    code=InternalErrorCode.INVALID_DATA,
+                    message=f"Invalid payload data {mypayload}",
+                ),
+            )
+
+
+
+        ticket.attributes = {
+            **workflow_attr,
+            "state": workflows_payload["initial_state"],
+        }
+        return ticket
+
+    raise api.Exception(
+        status.HTTP_400_BAD_REQUEST,
+        api.Error(
+            type="request",
+            code=InternalErrorCode.SHORTNAME_ALREADY_EXIST,
+            message="This shortname already exists",
+        ),
+    )
+
+
+def transite(states, current_state: str, action: str, user_roles):
+    for state in states:
+        if state["state"] == current_state:
+            for next_state in state["next"]:
+                if next_state["action"] == action:
+                    for role in next_state["roles"]:
+                        if role in user_roles:
+                            return {"status": True, "message": next_state["state"]}
+                    return {
+                        "status": False,
+                        "message": f"You don't have the permission to progress this ticket with action {action}",
+                    }
+
+    return {
+        "status": False,
+        "message": f"You can't progress from {current_state} using {action}",
+    }
+
+
+def post_transite(states, next_state: str, resolution: str):
+    for state in states:
+        if state["state"] == next_state:
+            if "resolutions" in state:
+                available_resolutions = [one for one in state["resolutions"]]
+                if len(available_resolutions) == 0:
+                    return {
+                        "status": False,
+                        "message": f"The state {next_state} does not have any resolutions defined",
+                    }
+                else:
+                    if isinstance(available_resolutions[0], str):
+                        if resolution in available_resolutions:
+                            return {"status": True, "message": resolution}
+                    else:
+                        if resolution in [item['key'] for item in available_resolutions]:
+                            return {"status": True, "message": resolution}
+
+                return {
+                    "status": False,
+                    "message": f"The resolution {resolution} provided is not acceptable in state {next_state}",
+                }
+    return {
+        "status": False,
+        "message": f"Cannot fetch the next state {next_state} with resolution {resolution}",
+    }
+
+
+def check_open_state(states, current_state: str):
+    for state in states:
+        if state["state"] == current_state:
+            return "next" in state
+
+    return True

dmart/utils/web_notifier.py

@@ -0,0 +1,29 @@
+from models.core import NotificationData
+from utils.async_request import AsyncRequest
+from utils.notification import Notifier
+from utils.helpers import lang_code
+from utils.settings import settings
+
+
+
+
+class WebNotifier(Notifier):
+    
+    async def send(
+        self, 
+        data: NotificationData
+    ) -> bool:
+        if not settings.websocket_url:
+            return False
+        user_lang = lang_code(data.receiver.get("language", "ar"))
+        async with AsyncRequest() as client:
+            await client.post(
+                f"{settings.websocket_url}/send-message/{data.receiver.get('shortname')}",
+                json={
+                    "title": data.title.__getattribute__(user_lang),
+                    "description": data.body.__getattribute__(user_lang),
+                }
+            )
+        
+        return True
+