dmart 0.1.4__py3-none-any.whl → 0.1.8__py3-none-any.whl

plugins/ldap_manager/plugin.py

@@ -0,0 +1,100 @@
+from fastapi.logger import logger
+from models.core import Event, PluginBase, User
+from models.enums import ActionType
+from utils.settings import settings
+from data_adapters.adapter import data_adapter as db
+
+from ldap3 import AUTO_BIND_NO_TLS, MODIFY_REPLACE, Server, Connection, ALL
+
+
+class Plugin(PluginBase):
+
+    def __init__(self) -> None:
+        super().__init__()
+        try:
+            server = Server(settings.ldap_url, get_info=ALL)
+            self.conn = Connection(
+                server, 
+                user=settings.ldap_admin_dn, 
+                password=settings.ldap_pass, 
+                auto_bind=AUTO_BIND_NO_TLS
+            )
+        except Exception:
+            logger.error(
+                "Failed to connect to LDAP"
+            )
+            
+        
+
+    async def hook(self, data: Event):
+        if not hasattr(self, "conn"):
+            return
+        
+        # Type narrowing for PyRight
+        if not isinstance(data.shortname, str):
+            logger.warning(
+                "data.shortname is None and str is required at ldap_manager"
+            )
+            return
+        
+        if data.action_type == ActionType.delete:
+            self.delete(data.shortname)
+            return
+        
+        user_model: User = await db.load(
+            space_name=settings.management_space,
+            subpath=data.subpath,
+            shortname=data.shortname,
+            class_type=User
+        )
+        
+        if data.action_type == ActionType.create:
+            self.add(data.shortname, user_model)
+            
+        elif data.action_type == ActionType.update:
+            self.modify(data.shortname, user_model)
+            
+
+        elif data.action_type == ActionType.move and "src_shortname" in data.attributes:
+            self.delete(data.attributes['src_shortname'])
+            self.add(data.shortname, user_model)
+            
+            
+            
+    def delete(self, shortname: str):
+        self.conn.delete(f"cn={shortname},{settings.ldap_root_dn}")
+        
+    def add(
+        self, 
+        shortname: str, 
+        user_model: User
+    ):
+        self.conn.add(
+            f"cn={shortname},{settings.ldap_root_dn}", 
+            'dmartUser',
+            {
+                "cn": shortname.encode(),
+                "sn": shortname.encode(),
+                "gn": str(getattr(user_model, "displayname", "")).encode(),
+                "userPassword": getattr(user_model, "password", "").encode()
+            }
+        )
+        
+    def modify(
+        self, 
+        shortname: str, 
+        user_model: User
+    ):
+        self.conn.modify(
+            f"cn={shortname},{settings.ldap_root_dn}", 
+            {
+                "gn": [(
+                    MODIFY_REPLACE, 
+                    [str(getattr(user_model, "displayname", "")).encode()]
+                )],
+                "userPassword": [(
+                    MODIFY_REPLACE,
+                    [getattr(user_model, "password", "").encode()]
+                )],
+            }
+        )

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,
+                    ),
+                )