dmart 1.4.17__py3-none-any.whl

plugins/local_notification/plugin.py

@@ -0,0 +1,123 @@
+import sys
+from models.core import Content, Payload, PluginBase, Event, Reaction, Comment, Relationship, Locator
+from models.enums import ContentType
+from utils.helpers import camel_case
+from data_adapters.adapter import data_adapter as db
+from uuid import uuid4
+from fastapi.logger import logger
+from utils.async_request import AsyncRequest
+from utils.settings import settings
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        if not isinstance(data.shortname, str):
+            logger.error("data.shortname is None and str is required at local_notification")
+            return
+        
+        if data.resource_type is None:
+            return
+        
+        resource_type = data.resource_type
+        try:
+            class_type = getattr(sys.modules["models.core"], camel_case(resource_type))
+        except AttributeError:
+            logger.warning(
+                f"local_notification: unsupported resource_type={resource_type!s} (no model class found)"
+            )
+            return
+        parent_subpath, parent_shortname, parent_owner = None, None, None
+
+        entry = await db.load(
+            space_name=data.space_name,
+            subpath=data.subpath,
+            shortname=data.shortname,
+            class_type=class_type,
+            user_shortname=data.user_shortname
+        )
+        relationship = None
+        if class_type in [Reaction, Comment]:
+            parent_subpath, parent_shortname = data.subpath.rsplit("/", 1)
+            parent = await db.load(
+                space_name=data.space_name,
+                subpath=parent_subpath,
+                shortname=parent_shortname,
+                class_type=Content,
+                user_shortname=data.user_shortname
+            )
+            if parent.owner_shortname == data.user_shortname:
+                return
+
+            parent_owner = parent.owner_shortname
+
+            relationship = Relationship(
+                related_to=Locator(
+                    type=resource_type,
+                    space_name=data.space_name,
+                    subpath=parent_subpath,
+                    shortname=parent_shortname
+                ),
+                attributes={
+                    "parent_owner": parent_owner
+                }
+            )
+
+        else:
+            if not entry.owner_shortname or entry.owner_shortname == data.user_shortname:
+                return
+            parent_owner = entry.owner_shortname
+
+        uuid = uuid4()
+
+        meta_obj = Content(
+            uuid=uuid,
+            shortname=str(uuid)[:8],
+            owner_shortname=data.user_shortname,
+            is_active=True,
+            payload=Payload(
+                content_type=ContentType.json,
+                schema_shortname="notification",
+                body=f"{str(uuid)[:8]}.json"
+            ),
+        )
+        
+        if relationship is not None:
+            meta_obj.relationships = [relationship]
+
+        await db.save(
+            "personal",
+            f"people/{parent_owner}/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,
+            "resource_type": data.resource_type,
+            "is_read": "no"
+        }
+        await db.save_payload_from_json(
+            "personal",
+            f"people/{parent_owner}/notifications",
+            meta_obj,
+            notification_obj,
+        )
+
+        if not settings.websocket_url:
+            return
+
+        async with AsyncRequest() as client:
+            await client.post(
+                f"{settings.websocket_url}/send-message/{parent_owner}",
+                json={
+                    "type": "notification",
+                    "channels": [
+                        f"{data.space_name}:__ALL__:__ALL__:__ALL__:__ALL__",
+                    ],
+                    "message": notification_obj
+                }
+            )

plugins/realtime_updates_notifier/plugin.py

@@ -0,0 +1,58 @@
+from models.core import PluginBase, Event
+from utils.async_request import AsyncRequest
+from utils.settings import settings
+
+
+class Plugin(PluginBase):
+
+    async def hook(self, data: Event):
+        all_MKW = "__ALL__"
+
+        state = data.attributes.get("state", all_MKW)
+
+        # if subpath = parent/child
+        # send to channels with subpaths "parent" and "parent/child"
+        channels = []
+        subpath = ""
+        for subpath_part in data.subpath.split("/"):
+            if not subpath_part:
+                continue
+            subpath += subpath_part
+            
+            # Consider channels with __ALL__ magic word
+            if not subpath.startswith("/"):
+                subpath = "/" + subpath
+            channels.extend([
+                f"{data.space_name}:{subpath}:{all_MKW}:{data.action_type}:{state}",
+                f"{data.space_name}:{subpath}:{all_MKW}:{all_MKW}:{state}",
+                f"{data.space_name}:{subpath}:{all_MKW}:{data.action_type}:{all_MKW}",
+                f"{data.space_name}:{subpath}:{all_MKW}:{all_MKW}:{all_MKW}",
+            ])
+            if data.schema_shortname:
+                channels.extend([
+                    f"{data.space_name}:{subpath}:{data.schema_shortname}:{data.action_type}:{state}",
+                    f"{data.space_name}:{subpath}:{data.schema_shortname}:{all_MKW}:{state}",
+                    f"{data.space_name}:{subpath}:{data.schema_shortname}:{data.action_type}:{all_MKW}",
+                    f"{data.space_name}:{subpath}:{data.schema_shortname}:{all_MKW}:{all_MKW}",
+                ])
+            subpath += "/"
+        if not settings.websocket_url:
+            return
+
+        async with AsyncRequest() as client:
+            await client.post(
+                f"{settings.websocket_url}/broadcast-to-channels",
+                json={
+                    "type": "notification_subscription",
+                    "channels": [*set(channels)],
+                    "message": {
+                        "title": "updated",
+                        "subpath": data.subpath,
+                        "space": data.space_name,
+                        "shortname": data.shortname,
+                        "action_type": data.action_type,
+                        "owner_shortname": data.user_shortname
+                    }
+                }                
+            )
+            

plugins/redis_db_update/plugin.py

@@ -0,0 +1,188 @@
+import sys
+from models.core import ActionType, Attachment, PluginBase, Event, Space
+from utils.helpers import camel_case
+from data_adapters.file.adapter_helpers import generate_payload_string
+from data_adapters.adapter import data_adapter as db
+from models import core
+from models.enums import ContentType, ResourceType
+from data_adapters.file.redis_services import RedisServices
+from fastapi.logger import logger
+from data_adapters.file.create_index import main as reload_redis
+from utils.settings import settings
+from typing import Any
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        if settings.active_data_db == "sql":
+            return
+
+        self.data = data
+        # Type narrowing for PyRight
+        if (
+            not isinstance(data.shortname, str)
+            or not isinstance(data.resource_type, ResourceType)
+            or not isinstance(data.attributes, dict)
+        ):
+            logger.error("invalid data at redis_db_update")
+            return
+
+        spaces = await db.get_spaces()
+        if (
+            data.space_name not in spaces
+            or not Space.model_validate_json(spaces[data.space_name]).indexing_enabled
+        ):
+            return
+
+        class_type = getattr(
+            sys.modules["models.core"],
+            camel_case(core.ResourceType(data.resource_type)),
+        )
+        if issubclass(class_type, Attachment):
+            await self.update_parent_entry_payload_string()
+            return
+
+        async with RedisServices() as redis_services:
+            if data.resource_type == ResourceType.folder and data.action_type in [
+                ActionType.delete,
+                ActionType.move,
+            ]:
+                await reload_redis(for_space=data.space_name)
+                return
+
+            if data.action_type == ActionType.delete:
+                doc_id = redis_services.generate_doc_id(
+                    data.space_name,
+                    "meta",
+                    data.shortname,
+                    data.subpath,
+                )
+                meta_doc = await redis_services.get_doc_by_id(doc_id)
+                # Delete meta doc
+                await redis_services.delete_doc(
+                    data.space_name,
+                    "meta",
+                    data.shortname,
+                    data.subpath,
+                )
+                # Delete payload doc
+                await redis_services.delete_doc(
+                    data.space_name,
+                    (
+                        meta_doc.get("payload", {}).get("schema_shortname", "meta")
+                        if meta_doc
+                        else "meta"
+                    ),
+                    data.shortname,
+                    data.subpath,
+                )
+                return
+            try:
+                meta = await db.load(
+                    space_name=data.space_name,
+                    subpath=data.subpath,
+                    shortname=data.shortname,
+                    class_type=class_type,
+                    user_shortname=data.user_shortname,
+                )
+            except Exception as _:
+                return
+
+            if data.action_type in [
+                ActionType.create,
+                ActionType.update,
+                ActionType.progress_ticket,
+            ]:
+                meta_doc_id, meta_json = redis_services.prepare_meta_doc(
+                    data.space_name, data.subpath, meta
+                )
+                payload: dict[str, Any] = {}
+                if (
+                    meta.payload
+                    and meta.payload.content_type == ContentType.json
+                    and meta.payload.body is not None
+                ):
+                    mypayload = await db.load_resource_payload(
+                        space_name=data.space_name,
+                        subpath=data.subpath,
+                        filename=str(meta.payload.body),
+                        class_type=class_type,
+                    )
+                    payload = mypayload if mypayload else {}
+
+                meta_json["payload_string"] = await generate_payload_string(
+                    db,
+                    space_name=data.space_name,
+                    subpath=meta_json["subpath"],
+                    shortname=meta_json["shortname"],
+                    payload=payload,
+                ) if settings.store_payload_string else ""
+
+                await redis_services.save_doc(meta_doc_id, meta_json)
+                if meta.payload:
+                    payload.update(meta_json)
+                    await redis_services.save_payload_doc(
+                        data.space_name,
+                        data.subpath,
+                        meta,
+                        payload,
+                        data.resource_type,
+                    )
+
+            elif data.action_type == ActionType.move:
+                await redis_services.move_meta_doc(
+                    data.space_name,
+                    data.attributes["src_shortname"],
+                    data.attributes["src_subpath"],
+                    data.subpath,
+                    meta,
+                )
+                if meta.payload and meta.payload.schema_shortname:
+                    await redis_services.move_payload_doc(
+                        data.space_name,
+                        meta.payload.schema_shortname,
+                        data.attributes["src_shortname"],
+                        data.attributes["src_subpath"],
+                        meta.shortname,
+                        data.subpath,
+                    )
+
+    async def update_parent_entry_payload_string(self) -> None:
+        async with RedisServices() as redis_services:
+            # get the parent meta doc
+            subpath_parts = self.data.subpath.strip("/").split("/")
+            if len(subpath_parts) <= 1:
+                return
+            parent_subpath, parent_shortname = (
+                "/".join(subpath_parts[:-1]),
+                subpath_parts[-1],
+            )
+            doc_id = redis_services.generate_doc_id(
+                self.data.space_name,
+                "meta",
+                parent_shortname,
+                parent_subpath,
+            )
+            meta_doc: dict = await redis_services.get_doc_by_id(doc_id)
+
+            if meta_doc is None:
+                raise Exception("Meta doc not found")
+
+            payload = {}
+            if meta_doc.get("payload_doc_id"):
+                payload_doc = await redis_services.get_doc_by_id(
+                    meta_doc["payload_doc_id"]
+                )
+                payload = {k: v for k, v in payload_doc.items() if k not in meta_doc}
+
+            # generate the payload string
+            meta_doc["payload_string"] = await generate_payload_string(
+                db,
+                space_name=self.data.space_name,
+                subpath=parent_subpath,
+                shortname=parent_shortname,
+                payload=payload,
+            ) if settings.store_payload_string else ""
+
+            # update parent meta doc
+            await redis_services.save_doc(doc_id, meta_doc)

plugins/resource_folders_creation/plugin.py

@@ -0,0 +1,81 @@
+from models.core import Folder, PluginBase, Event
+from models.enums import ResourceType
+from data_adapters.file.redis_services import RedisServices
+from fastapi.logger import logger
+from data_adapters.adapter import data_adapter as db
+from utils.settings import settings
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        # Type narrowing for PyRight
+        if (
+            not isinstance(data.shortname, str)
+            or not isinstance(data.resource_type, ResourceType)
+            or not isinstance(data.attributes, dict)
+        ):
+            logger.error("invalid data at resource_folders_creation")
+            return
+
+        folders = []
+        if data.resource_type == ResourceType.user:
+            folders = [
+                ("personal", "people", data.shortname),
+                ("personal", f"people/{data.shortname}", "notifications"),
+                ("personal", f"people/{data.shortname}", "private"),
+                ("personal", f"people/{data.shortname}", "protected"),
+                ("personal", f"people/{data.shortname}", "public"),
+                ("personal", f"people/{data.shortname}", "inbox"),
+            ]
+        elif data.resource_type == ResourceType.space:
+            # sys_schemas = ["meta_schema", "folder_rendering"]
+            # for schema_name in sys_schemas:
+            #     await clone(
+            #         src_space=settings.management_space,
+            #         src_subpath="schema",
+            #         src_shortname=schema_name,
+            #         dest_space=data.shortname,
+            #         dest_subpath="schema",
+            #         dest_shortname=schema_name,
+            #         class_type=Schema,
+            #     )
+            if settings.active_data_db == "file":
+                async with RedisServices() as redis_services:
+                    await redis_services.create_indices(
+                        for_space=data.shortname,
+                        # for_schemas=sys_schemas,
+                        for_custom_indices=False,
+                        del_docs=False,
+                    )
+
+            # redis_update_plugin = RedisUpdatePlugin()
+            # for schema_name in sys_schemas:
+            #     await redis_update_plugin.hook(Event(
+            #         space_name=data.shortname,
+            #         subpath="schema",
+            #         shortname=schema_name,
+            #         action_type=ActionType.create,
+            #         resource_type=ResourceType.schema,
+            #         user_shortname=data.user_shortname
+            #     ))
+
+            folders = [(data.shortname, "/", "schema")]
+
+        for folder in folders:
+            existing_folder = await db.load_or_none(
+                space_name=folder[0],
+                subpath=folder[1],
+                shortname=folder[2],
+                class_type=Folder,
+                user_shortname=data.user_shortname,
+            )
+            if existing_folder is None:
+                await db.internal_save_model(
+                    space_name=folder[0],
+                    subpath=folder[1],
+                    meta=Folder(
+                        shortname=folder[2],
+                        is_active=True,
+                        owner_shortname=data.user_shortname,
+                    ),
+                )

plugins/system_notification_sender/plugin.py

@@ -0,0 +1,188 @@
+from sys import modules as sys_modules
+from uuid import uuid4
+from models import api
+from models.enums import ContentType, QueryType
+from models.core import (
+    ActionType,
+    Content,
+    NotificationData,
+    Payload,
+    PluginBase,
+    Event,
+    Translation,
+)
+from utils.notification import NotificationManager
+from utils.helpers import camel_case, replace_message_vars
+from utils.settings import settings
+from fastapi.logger import logger
+from data_adapters.adapter import data_adapter as db
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        """
+        after any action
+        1- get the matching SystemNotificationRequest for this action
+        2- generate list of users to send the notification to (based on the action entry):
+            2.1- entry.owner_shortname, entry.group.members?, and entry.collaborators?
+        3- send the notification to the list of generated users
+        """
+        # Type narrowing for PyRight
+        if not isinstance(data.shortname, str):
+            logger.warning(
+                "data.shortname is None and str is required at system_notification_sender"
+            )
+            return
+
+        if data.action_type == ActionType.delete and data.attributes.get("entry"):
+            entry = data.attributes["entry"].model_dump()
+        else:
+            entry = (
+                await db.load(
+                    data.space_name,
+                    data.subpath,
+                    data.shortname,
+                    getattr(sys_modules["models.core"], camel_case(data.resource_type)),
+                    data.user_shortname,
+                )
+            ).model_dump()
+            if entry["payload"] is not None:
+                try:
+                    entry["payload"]["body"] = await db.load_resource_payload(
+                        space_name=data.space_name,
+                        subpath=data.subpath,
+                        filename=entry["payload"]["body"],
+                        class_type=getattr(
+                            sys_modules["models.core"], camel_case(data.resource_type)
+                        ),
+                    )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to load payload for entry {data.space_name}/{data.subpath}/{data.shortname}: {e}"
+                    )
+        entry["space_name"] = data.space_name
+        entry["resource_type"] = str(data.resource_type)
+        entry["subpath"] = data.subpath
+        # 1- get the matching SystemNotificationRequests
+        total, matching_notification_requests = await db.query(api.Query(
+            type=QueryType.search,
+            retrieve_json_payload=True,
+            space_name="management",
+            subpath="notifications/system",
+            search=f"@payload.body.on_space:{data.space_name} @payload.body.on_subpath:{data.subpath.lstrip('/')} @payload.body.on_action:{data.action_type}",
+            limit=30,
+            offset=0
+        ), "dmart")
+        if total == 0:
+            return
+
+        sub_matching_notification_requests = matching_notification_requests[0].model_dump()
+        notification_dict = sub_matching_notification_requests
+        if (
+            "state" in entry
+            and notification_dict.get("on_state", "") != ""
+            and notification_dict["on_state"] != entry["state"]
+        ):
+            return
+
+
+        # 2- get list of subscribed users
+        notification_subscribers =[]
+        # if entry.get("collaborators", None):
+        #     notification_subscribers.extend(entry["collaborators"].values())
+
+        data_owner_shortname = entry["owner_shortname"]
+        if entry.get("owner_group_shortname", None):
+            group_users = await db.get_group_users(entry["owner_group_shortname"])
+            notification_subscribers.extend(group_users)        
+        if data_owner_shortname in notification_subscribers:
+            notification_subscribers.remove(data_owner_shortname)
+        users_objects: dict[str, dict] = {}
+
+        for subscriber in notification_subscribers:
+            users_objects[subscriber] = (await db.load(
+                settings.management_space,
+                settings.users_subpath,
+                subscriber,
+                getattr(sys_modules["models.core"], camel_case("user")),
+                data.user_shortname,
+            )).model_dump()
+        # 3- send the notification
+        notification_manager = NotificationManager()
+
+        formatted_req = await self.prepare_request(notification_dict, entry)
+        for receiver in set(notification_subscribers):
+            if not formatted_req["push_only"]:
+                notification_content = Content(
+                    shortname=str(uuid4())[:8],
+                    is_active=True,
+                    displayname=notification_dict["attributes"]["displayname"],
+                    description=notification_dict["attributes"]["description"],
+                    owner_shortname=receiver,
+                    payload=Payload(
+                        content_type=ContentType.json,
+                        body={
+                            "type": "system",
+                            "is_read": False,
+                            "priority": notification_dict["attributes"]["payload"]["body"]["priority"],
+                            "entry_space": entry["space_name"],
+                            "entry_subpath": entry["subpath"],
+                            "entry_shortname": entry["shortname"],
+                            "resource_type": entry["resource_type"],
+                            "created_by": data.user_shortname,
+                            "action_type": str(data.action_type)
+                        }
+                    )
+                )
+                await db.internal_save_model(
+                    space_name="personal",
+                    subpath=f"people/{receiver}/notifications",
+                    meta=notification_content
+                )
+
+            for platform in formatted_req["platforms"]:
+                await notification_manager.send(
+                    platform=platform,
+                    data=NotificationData(
+                        receiver=users_objects[receiver],
+                        title=formatted_req["title"],
+                        body=formatted_req["body"],
+                        image_urls=formatted_req["images_urls"],
+                        deep_link=notification_dict.get("deep_link", {}),
+                        entry_id=entry["shortname"],
+                    ),
+                )
+
+    async def prepare_request(self, notification_dict: dict, entry: dict) -> dict:
+        for locale in ["ar", "en", "ku"]:
+            if "displayname" in notification_dict:
+                notification_dict["displayname"][locale] = replace_message_vars(
+                    notification_dict["displayname"][locale], entry, locale
+                )
+            if "description" in notification_dict:
+                notification_dict["description"][locale] = replace_message_vars(
+                    notification_dict["description"][locale], entry, locale
+                )
+            
+        # Get Notification Request Images
+        attachments_path = (
+            settings.spaces_folder
+            / f"{settings.management_space}"
+            f"/{notification_dict['subpath']}/.dm/{notification_dict['shortname']}"
+        )
+        notification_attachments = await db.get_entry_attachments(
+            subpath=f"{notification_dict['subpath']}/{notification_dict['shortname']}",
+            attachments_path=attachments_path,
+        )
+        notification_images = {
+            "en": notification_attachments.get("media", {}).get("en"),
+            "ar": notification_attachments.get("media", {}).get("ar"),
+            "ku": notification_attachments.get("media", {}).get("ku"),
+        }
+        return {
+            "platforms": notification_dict.get("types", []),
+            "title": Translation(**notification_dict.get("displayname", {})),
+            "body": Translation(**notification_dict.get("description", {})),
+            "images_urls": Translation(**notification_images),
+            "push_only": notification_dict.get("push_only", False),
+        }

plugins/update_access_controls/plugin.py

@@ -0,0 +1,9 @@
+from models.core import PluginBase, Event
+from utils.access_control import access_control
+from utils.settings import settings
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        if settings.active_data_db == "file":
+            await access_control.load_permissions_and_roles()

pytests/api_user_models_erros_test.py

@@ -0,0 +1,16 @@
+import pytest
+from models.api import Error
+from utils.internal_error_code import InternalErrorCode
+from api.user.model.errors import INVALID_OTP, EXPIRED_OTP
+
+def test_invalid_otp():
+    assert isinstance(INVALID_OTP, Error)
+    assert INVALID_OTP.type == "OTP"
+    assert INVALID_OTP.code == InternalErrorCode.OTP_INVALID
+    assert INVALID_OTP.message == "Invalid OTP"
+
+def test_expired_otp():
+    assert isinstance(EXPIRED_OTP, Error)
+    assert EXPIRED_OTP.type == "OTP"
+    assert EXPIRED_OTP.code == InternalErrorCode.OTP_EXPIRED
+    assert EXPIRED_OTP.message == "Expired OTP"