dmart 1.4.40.post6__py3-none-any.whl → 1.4.40.post7__py3-none-any.whl

dmart/sample/spaces/archive/.dm/meta.space.json

@@ -0,0 +1,27 @@
+{
+    "uuid": "4a001e1f-a844-4bb9-a340-7f8eb1a77480",
+    "shortname": "archive",
+    "is_active": true,
+    "displayname": {
+        "en": "archive"
+    },
+    "tags": [],
+    "created_at": "2024-09-02T12:55:00.899747",
+    "updated_at": "2024-09-02T12:55:00.906988",
+    "owner_shortname": "dmart",
+    "root_registration_signature": "",
+    "primary_website": "",
+    "indexing_enabled": false,
+    "capture_misses": false,
+    "check_health": false,
+    "languages": [
+        "english"
+    ],
+    "icon": "",
+    "mirrors": [],
+    "hide_folders": [],
+    "hide_space": true,
+    "active_plugins": [
+    ],
+    "ordinal": 1
+}

dmart/sample/spaces/custom_plugins/dummy/config.json

@@ -0,0 +1,28 @@
+{
+  "shortname": "dummy",
+	"is_active": true,
+	"filters": {
+		"subpaths": [
+			"__ALL__"
+		],
+		"resource_types": [
+			"__ALL__"
+		],
+		"schema_shortnames": [
+			"__ALL__"
+		],
+		"actions": [
+			"query",
+			"view",
+			"update",
+			"create",
+			"delete",
+			"move",
+			"progress_ticket",
+			"lock",
+			"unlock"
+		]
+	},
+	"type": "hook",
+	"listen_time": "after"
+}

dmart/sample/spaces/custom_plugins/dummy/plugin.py

@@ -0,0 +1,6 @@
+from models.core import PluginBase, Event
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        print(f"Reached to the dummy custom plugin, data recieved: {data}")

dmart/sample/spaces/custom_plugins/missed_entry/config.json

@@ -0,0 +1,12 @@
+{
+  "shortname": "missed",
+	"is_active": false,
+	"filters": {
+		"subpaths": ["__ALL__"],
+		"resource_types": ["__ALL__"],
+		"schema_shortnames": ["__ALL__"],
+		"actions": ["view", "query"]
+	},
+	"type": "hook",
+	"listen_time": "before"
+}

dmart/sample/spaces/custom_plugins/missed_entry/plugin.py

@@ -0,0 +1,119 @@
+import json
+import sys
+import aiofiles
+from models.core import ActionType, PluginBase, Event, Space
+from utils.helpers import camel_case
+from utils.redis_services import RedisServices
+from utils.spaces import get_spaces
+from data_adapters.adapter import data_adapter as db
+from models import core
+from models.enums import ContentType, ResourceType
+from utils.settings import settings
+from fastapi.logger import logger
+
+class Plugin(PluginBase):
+
+    def __init__(self) -> None:
+        pass
+
+
+    async def hook(self, data: Event):
+
+        # Type narrowing for PyRight
+        if not isinstance(data.shortname, str) and not isinstance(data.attributes, dict):
+            logger.error(f"invalid data at missed_entry")
+            return
+
+        spaces = await get_spaces()
+        if not Space.parse_raw(spaces[data.space_name]).capture_misses:
+            return
+
+        if data.action_type == ActionType.query and "filter_shortnames" in data.attributes:
+            for shortname in data.attributes["filter_shortnames"]:
+                data.shortname = shortname
+                data.resource_type = data.resource_type or ResourceType.content
+                await self.check_miss(data)
+
+        else:
+            await self.check_miss(data)
+
+        
+
+    async def check_miss(self, data: Event):
+        # Type narrowing for PyRight
+        if not isinstance(data.shortname, str):
+            logger.error(f"data.shortname is None and str is required at missed_entry")
+            return
+
+        class_type = getattr(
+            sys.modules["models.core"], camel_case(core.ResourceType(data.resource_type))
+        )
+        path, filename = db.metapath(data.space_name, data.subpath, data.shortname, class_type)
+        if (path/filename).is_file():
+            return
+
+        if data.subpath[0] == "/":
+            data.subpath = data.subpath.replace("/", "", 1)
+
+        miss_shortname = f"{data.subpath}_{data.shortname}"
+        if len(miss_shortname) > 32:
+            miss_shortname = miss_shortname[:32]
+
+        miss_file = (
+            settings.spaces_folder / 
+            data.space_name / 
+            f"misses/{miss_shortname}.json"
+        )
+        miss_content = None
+        if miss_file.is_file():
+            async with aiofiles.open(miss_file, "r") as file:
+                miss_content = json.loads(await file.read())
+
+        missed_obj_meta = core.Content(
+            shortname=miss_shortname,
+            owner_shortname=data.user_shortname,
+            is_active=True,
+            payload=core.Payload(
+                content_type=ContentType.json,
+                schema_shortname="miss",
+                body=miss_shortname + ".json",
+            ),
+        )
+        async with RedisServices() as redis_services:
+            meta_doc_id, meta_json = redis_services.prepate_meta_doc(
+                data.space_name, "misses", missed_obj_meta
+            )
+            if not miss_content:
+                await db.save(data.space_name, "misses", missed_obj_meta)
+                await redis_services.save_doc(meta_doc_id, meta_json)
+                num_of_requests = 1
+
+            else:
+                num_of_requests = miss_content["num_of_requests"] + 1
+
+            await db.save_payload_from_json(
+                data.space_name,
+                "misses",
+                missed_obj_meta,
+                {
+                    "requested_subpath": data.subpath,
+                    "requested_shortname": data.shortname,
+                    "num_of_requests": num_of_requests,
+                    "actioned": "No",
+                },
+            )
+            payload_dict = {
+                **meta_json,
+                "requested_subpath": data.subpath,
+                "requested_shortname": data.shortname,
+                "num_of_requests": num_of_requests,
+                "actioned": "No"
+                
+            }
+            await redis_services.save_payload_doc(
+                space_name=data.space_name,
+                subpath="misses",
+                meta=missed_obj_meta,
+                payload=payload_dict,
+                resource_type=ResourceType.content
+            )

dmart/sample/spaces/custom_plugins/own_changed_notification/config.json

@@ -0,0 +1,12 @@
+{
+  "shortname": "own_changed_notification",
+	"is_active": true,
+	"filters": {
+		"subpaths": ["__ALL__"],
+		"resource_types": ["__ALL__"],
+		"schema_shortnames": ["__ALL__"],
+		"actions": ["update", "delete"]
+	},
+	"type": "hook",
+	"listen_time": "after"
+}

dmart/sample/spaces/custom_plugins/own_changed_notification/plugin.py

@@ -0,0 +1,65 @@
+import sys
+from models.core import Content, Payload, PluginBase, Event
+from models.enums import ContentType, ResourceType
+from utils.helpers import camel_case
+from data_adapters.adapter import data_adapter as db
+from uuid import uuid4
+from fastapi.logger import logger
+
+
+class Plugin(PluginBase):
+
+    async def hook(self, data: Event):
+       
+        # Type narrowing for PyRight
+        if not isinstance(data.shortname, str):
+            logger.error(f"data.shortname is None and str is required at system_notification_sender")
+            return
+
+        class_type = getattr(
+            sys.modules["models.core"], camel_case(ResourceType(data.resource_type))
+        )
+
+        entry = await db.load(
+            space_name=data.space_name,
+            subpath=data.subpath,
+            shortname=data.shortname,
+            class_type=class_type,
+            user_shortname=data.user_shortname
+        )
+
+        if not entry.owner_shortname or entry.owner_shortname == data.user_shortname:
+            return
+
+        
+        uuid = uuid4()
+        meta_obj = Content(
+            uuid=uuid,
+            shortname=str(uuid)[:8],
+            owner_shortname=data.user_shortname,
+            payload=Payload(
+                content_type=ContentType.json,
+                schema_shortname="notification",
+                body=f"{str(uuid)[:8]}.json"
+            )
+        )
+        await db.save(
+            "personal",
+            f"people/{entry.owner_shortname}/notifications",
+            meta_obj,
+        )
+
+        notification_obj = {
+            "entry_space": data.space_name,
+            "entry_subpath": data.subpath,
+            "entry_shortname": data.shortname,
+            "action_by": data.user_shortname,
+            "action_type": data.action_type,
+            "is_read": "no"
+        }
+        await db.save_payload_from_json(
+            "personal",
+            f"people/{entry.owner_shortname}/notifications",
+            meta_obj,
+            notification_obj,  # type: ignore
+        )

dmart/sample/spaces/custom_plugins/reports_stats/config.json

@@ -0,0 +1,14 @@
+{
+  "shortname": "reports_stats",
+  "is_active": false,
+  "filters": {
+    "subpaths": [
+      "reports"
+    ],
+    "resource_types": ["__ALL__"],
+    "schema_shortnames": ["__ALL__"],
+    "actions": ["query"]
+  },
+  "listen_time": "before",
+  "type": "hook"
+}

dmart/sample/spaces/custom_plugins/reports_stats/plugin.py

@@ -0,0 +1,82 @@
+from os import scandir
+from re import sub
+from models.core import PluginBase, Event
+from utils.access_control import access_control
+from data_adapters.adapter import data_adapter as db
+from models.core import Content
+from models.api import Query
+from utils.repository import get_last_updated_entry, serve_query, internal_sys_update_model
+from utils.settings import settings
+
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        if data.subpath[0] == "/":
+            data.subpath = data.subpath[1:]
+        reports_path = (
+            settings.spaces_folder
+            / data.space_name
+            / data.subpath
+        )
+
+        reports_iterator = scandir(reports_path)
+        for report_entry in reports_iterator:
+            if not report_entry.is_file():
+                continue
+
+            shortname, _ = report_entry.name.split(".")
+            subpath, class_type = "reports", Content
+
+            try:
+                report_meta = await db.load(
+                    space_name=data.space_name,
+                    subpath=subpath,
+                    shortname=shortname,  # type: ignore
+                    class_type=class_type,
+                    user_shortname=data.user_shortname,
+                )
+
+                report_payload = await db.load_resource_payload(
+                    space_name=data.space_name,
+                    subpath=subpath,
+                    filename=report_meta.payload.body,  # type: ignore
+                    class_type=class_type,
+                )
+            except Exception:
+                continue
+            
+            report_payload["query"]["search"] = sub(
+                r"\$\w*", "", report_payload["query"]["search"]
+            )
+            
+            report_query = Query(**report_payload["query"])
+            report_query.limit = 0
+            redis_query_policies = await access_control.get_user_query_policies(
+                data.user_shortname, report_query.space_name, report_query.subpath
+            )
+            total, records = await serve_query(
+                report_query, data.user_shortname, redis_query_policies
+            )
+            report_last_updated_entry = await get_last_updated_entry(
+                data.space_name,
+                report_payload["query"]["filter_schema_names"],
+                False,
+                data.user_shortname,
+            )
+
+            report_updates: dict = {
+                "number_of_records": total
+            }
+            if report_last_updated_entry:
+                report_updates["last_updated"] = str(
+                    report_last_updated_entry.attributes["updated_at"]
+                )
+
+            await internal_sys_update_model(
+                data.space_name,
+                "reports",
+                report_meta,
+                report_updates
+            )
+

dmart/sample/spaces/custom_plugins/system_notification_sender/config.json

@@ -0,0 +1,22 @@
+{
+  "shortname": "system_notification_sender",
+  "is_active": false,
+  "filters": {
+    "subpaths": ["__ALL__"],
+    "resource_types": ["__ALL__"],
+    "schema_shortnames": ["__ALL__"],
+    "actions": [
+      "progress_ticket",
+      "view",
+      "create",
+      "update",
+      "delete",
+      "attach",
+      "move"
+    ]
+  },
+  "type": "hook",
+  "listen_time": "after",
+  "created_at": "2022-08-11T11:27:28.866048",
+  "updated_at": "2022-08-11T11:27:28.866052"
+}

dmart/sample/spaces/custom_plugins/system_notification_sender/notification.py

@@ -0,0 +1,268 @@
+import json
+import requests
+from uuid import uuid4
+from api.user.service import send_sms
+from api.user.router import MANAGEMENT_SPACE, USERS_SUBPATH
+from models.core import Notification, Locator, Translation, User
+from models.enums import NotificationType
+from utils.db import save
+from re import sub as res_sub
+from firebase_admin import credentials, messaging, initialize_app
+from utils.helpers import divide_chunks, flatten_dict, lang_code
+from utils.redis_services import RedisServices
+from utils.settings import settings
+from utils.regex import FILENAME
+import os
+from pathlib import Path
+import utils.db as db
+from fastapi.logger import logger
+
+
+async def send_notification(
+    notification_dict: dict,
+    receivers: set,
+    entry: dict = {},
+):
+    notification_required_keys = [
+        "displayname",
+        "description",
+        "priority",
+        "types",
+    ]
+    if not all(key in notification_dict for key in notification_required_keys):
+        raise Exception(
+            "One or more of the Main keys 'displayname', 'description', or 'priority' are missing"
+        )
+    if isinstance(notification_dict["displayname"], Translation):
+        notification_dict["displayname"] = notification_dict["displayname"].dict()
+    if isinstance(notification_dict["description"], Translation):
+        notification_dict["description"] = notification_dict["description"].dict()
+
+    for locale in ["ar", "en", "ku"]:
+        notification_dict["displayname"][locale] = translate_message_vars(
+            notification_dict["displayname"][locale], entry, locale
+        )
+        notification_dict["description"][locale] = translate_message_vars(
+            notification_dict["description"][locale], entry, locale
+        )
+
+    for receiver in receivers:
+        if "web" in notification_dict["types"]:
+            try:
+                if not notification_dict.get("push_only", False):
+                    await store_notification(notification_dict, receiver, entry)
+
+                # Send push notification
+                requests.post(
+                    url=f"{settings.websocket_url}/send-message/{receiver}",
+                    data=json.dumps(
+                        {
+                            "title": notification_dict["displayname"],
+                            "description": notification_dict["description"],
+                        }
+                    ),
+                )
+            except Exception as e:
+                logger.error(
+                    "Notification",
+                    extra={
+                        "props": {"title": "FAIL at store_notification", "message": e}
+                    },
+                )
+        user = None
+        if "mobile" in notification_dict["types"]:
+            try:
+                user = await db.load(
+                    space_name=MANAGEMENT_SPACE,
+                    subpath=USERS_SUBPATH,
+                    shortname=receiver,
+                    class_type=User,
+                    user_shortname="dmart",
+                )
+                await send_notification_firebase(user, notification_dict, entry)
+            except Exception as e:
+                logger.error(
+                    "Notification",
+                    extra={
+                        "props": {
+                            "title": "FAIL at send_notification_firebase",
+                            "message": e,
+                        }
+                    },
+                )
+        if "sms" in notification_dict["types"]:
+            try:
+                user = (
+                    user
+                    if user
+                    else await db.load(
+                        space_name=MANAGEMENT_SPACE,
+                        subpath=USERS_SUBPATH,
+                        shortname=receiver,
+                        class_type=User,
+                        user_shortname="dmart",
+                    )
+                )
+                user_lang_code = lang_code(user.language)
+                await send_sms(
+                    user.msisdn or "",
+                    notification_dict["displayname"][user_lang_code],
+                )
+            except Exception as e:
+                logger.error(
+                    "Notification",
+                    extra={"props": {"title": "FAIL at send_sms", "message": e}},
+                )
+
+
+def translate_message_vars(message: str, entry: dict, locale: str):
+    entry_dict = flatten_dict(entry)
+    for field, value in entry_dict.items():
+        if type(value) == dict and locale in value:
+            value = value[locale]
+        if field in ["created_at", "updated_at"]:
+            message = message.replace(
+                f"{{{field}}}", str(value.strftime("%Y-%m-%d %H:%M:%S"))
+            )
+        else:
+            message = message.replace(f"{{{field}}}", str(value))
+
+    return res_sub(r"\{\w*.*\}", "", message)
+
+
+async def store_notification(
+    notification_dict: dict, receiver_shortname: str, entry: dict = {}
+):
+    if notification_dict["payload"]["schema_shortname"] == "admin_notification_request":
+        notification_type = NotificationType.admin
+    else:
+        notification_type = NotificationType.system
+
+    entry_locator = None
+    if entry:
+        entry_locator = Locator(
+            space_name=entry["space_name"],
+            type=entry["resource_type"],
+            schema_shortname=entry["payload"]["schema_shortname"],
+            subpath=entry["subpath"],
+            shortname=entry["shortname"],
+        )
+
+    uuid = uuid4()
+    notification_obj = Notification(
+        uuid=uuid,
+        shortname=str(uuid)[:8],
+        is_active=True,
+        displayname=notification_dict["displayname"],
+        description=notification_dict["description"],
+        owner_shortname=notification_dict["owner_shortname"],
+        type=notification_type,
+        is_read=False,
+        priority=notification_dict["priority"],
+        entry=entry_locator,
+    )
+
+    await save(
+        space_name="personal",
+        subpath=f"people/{receiver_shortname}/notifications",
+        meta=notification_obj,
+    )
+
+    async with await RedisServices() as redis:
+        await redis.save_meta_doc(
+            "personal",
+            f"people/{receiver_shortname}/notifications",
+            notification_obj,
+        )
+
+
+firebase_app = None
+
+
+def init_firbase_app():
+    global firebase_app
+    firebase_cred = credentials.Certificate(settings.google_application_credentials)
+    firebase_app = initialize_app(firebase_cred, name="[DEFAULT]")
+
+
+async def send_notification_firebase(user: User, data, entry):
+    users_fcm_tokens = {}
+
+    firebase_token, msisdn = user.firebase_token, user.msisdn
+
+    lang = lang_code(user.language)
+    # if lang not in users_fcm_tokens:
+    users_fcm_tokens[lang] = {}
+    users_fcm_tokens[lang][msisdn] = firebase_token
+
+    images: dict = {}
+    images_folder = Path(
+        f"{settings.spaces_folder}/{settings.management_space}/{data['subpath']}/.dm/{data['shortname']}/attachments.media"
+    )
+
+    if images_folder.is_dir():
+        images_files = os.scandir(images_folder)
+        for image_file in images_files:
+            match = FILENAME.search(str(image_file.name))
+            if not match or not image_file.is_file():
+                continue
+
+            images[
+                image_file.name.split("_")[0]
+            ] = f"{settings.listening_host}/public/payload/media/{settings.management_space}/{data['subpath']}/{data['shortname']}/{image_file.name}"
+
+    for lang, fcm_token_per_lang in users_fcm_tokens.items():
+        res = send_multiple_notifications(
+            tokens=list(fcm_token_per_lang.values()),
+            title=data.get("displayname", {}).get(lang, ""),
+            body=data.get("description", {}).get(lang, ""),
+            image=images.get(lang, ""),
+            data={
+                **data.get("deep_link"),
+                "id": entry.get("shortname"),
+                "space_name": entry.get("space_name"),
+                "subpath": entry.get("subpath"),
+            },
+        )
+
+
+def send_multiple_notifications(
+    tokens: list, title: str, body: str, data: dict, image: str, sound="default"
+) -> list:
+    if not firebase_app:
+        init_firbase_app()
+    alert = messaging.ApsAlert(title=title, body=body)
+    aps = messaging.Aps(alert=alert, sound="default", content_available=True)
+    apns = messaging.APNSConfig(
+        payload=messaging.APNSPayload(aps),
+        fcm_options=messaging.APNSFCMOptions(image=image),
+    )
+    android_notification_settings = messaging.AndroidNotification(
+        priority="high", channel_id="FCM_CHANNEL_ID", visibility="public", image=image
+    )
+    android_config = messaging.AndroidConfig(
+        priority="high", notification=android_notification_settings
+    )
+    web_push = messaging.WebpushConfig(headers={"image": image})
+    # Firebase sends message to max of 500 registration tokens.
+    tokens_chunks = divide_chunks(tokens, 500)
+    failed_tokens = []
+    for tokens in tokens_chunks:
+        message = messaging.MulticastMessage(
+            notification=messaging.Notification(title=title, body=body),
+            tokens=tokens,
+            data=data,
+            apns=apns,
+            android=android_config,
+            webpush=web_push,
+        )
+        response = messaging.send_multicast(message)
+
+        if response.failure_count > 0:
+            responses = response.responses
+            for idx, resp in enumerate(responses):
+                if not resp.success:
+                    # The order of responses corresponds to the order of the registration tokens.
+                    failed_tokens.append(tokens[idx])
+
+    return failed_tokens