dmart 0.1.9__py3-none-any.whl

models/enums.py

@@ -0,0 +1,255 @@
+from enum import StrEnum
+import redis.commands.search.reducers as reducers
+
+
+class RequestType(StrEnum):
+    create = "create"
+    update = "update"
+    patch = "patch"
+    update_acl = "update_acl"
+    assign = "assign"
+    delete = "delete"
+    move = "move"
+
+
+class Language(StrEnum):
+    ar = "arabic"
+    en = "english"
+    ku = "kurdish"
+    fr = "french"
+    tr = "turkish"
+
+    @staticmethod
+    def code(lang_str):
+        codes = {
+            "arabic": "ar",
+            "english": "en",
+            "kurdish": "ku",
+            "french": "fr",
+            "turkish": "tr",
+        }
+        return codes[lang_str]
+
+
+class PublicSubmitResourceType(StrEnum):
+    content = "content"
+    ticket = "ticket"
+
+
+class ResourceType(StrEnum):
+    user = "user"
+    group = "group"
+    folder = "folder"
+    schema = "schema"
+    content = "content"
+    log = "log"
+    acl = "acl"
+    comment = "comment"
+    media = "media"
+    data_asset = "data_asset"
+    locator = "locator"
+    relationship = "relationship"
+    alteration = "alteration"
+    history = "history"
+    space = "space"
+    permission = "permission"
+    role = "role"
+    ticket = "ticket"
+    json = "json"
+    lock = "lock"
+    post = "post"
+    reaction = "reaction"
+    reply = "reply"
+    share = "share"
+    plugin_wrapper = "plugin_wrapper"
+    notification = "notification"
+    csv = "csv"
+    jsonl = "jsonl"
+    sqlite = "sqlite"
+    duckdb = "duckdb"
+    parquet = "parquet"
+
+
+class DataAssetType(StrEnum):
+    csv = "csv"
+    jsonl = "jsonl"
+    sqlite = "sqlite"
+    duckdb = "duckdb"
+    parquet = "parquet"
+
+
+class AttachmentType(StrEnum):
+    reaction = "reaction"
+    share = "share"
+    json = "json"
+    reply = "reply"
+    comment = "comment"
+    lock = "lock"
+    media = "media"
+    data_asset = "data_asset"
+    relationship = "relationship"
+    alteration = "alteration"
+
+
+class ContentType(StrEnum):
+    text = "text"
+    comment = "comment"
+    reaction = "reaction"
+    markdown = "markdown"
+    html = "html"
+    json = "json"
+    image = "image"
+    python = "python"
+    pdf = "pdf"
+    audio = "audio"
+    video = "video"
+    csv = "csv"
+    parquet = "parquet"
+    jsonl = "jsonl"
+    apk = "apk"
+    duckdb = "duckdb"
+    sqlite = "sqlite"
+
+    @staticmethod
+    def inline_types() -> list:
+        return [ContentType.text, ContentType.markdown, ContentType.html]
+
+
+class TaskType(StrEnum):
+    query = "query"
+
+
+class UserType(StrEnum):
+    web = "web"
+    mobile = "mobile"
+    bot = "bot"
+
+
+class ValidationEnum(StrEnum):
+    valid = "valid"
+    invalid = "invalid"
+
+
+class LockAction(StrEnum):
+    fetch = "fetch"
+    lock = "lock"
+    extend = "extend"
+    unlock = "unlock"
+    cancel = "cancel"
+
+
+class NotificationType(StrEnum):
+    admin = "admin"
+    system = "system"
+
+
+class NotificationPriority(StrEnum):
+    high = "high"
+    medium = "medium"
+    low = "low"
+
+
+class StrBoolEnum(StrEnum):
+    true = "yes"
+    false = "no"
+
+
+class ActionType(StrEnum):
+    query = "query"
+    view = "view"
+    update = "update"
+    create = "create"
+    delete = "delete"
+    attach = "attach"
+    assign = "assign"
+    move = "move"
+    progress_ticket = "progress_ticket"
+    lock = "lock"
+    unlock = "unlock"
+
+
+class ConditionType(StrEnum):
+    is_active = "is_active"
+    own = "own"
+
+
+class PluginType(StrEnum):
+    hook = "hook"
+    api = "api"
+
+
+class EventListenTime(StrEnum):
+    before = "before"
+    after = "after"
+
+
+class QueryType(StrEnum):
+    search = "search"
+    subpath = "subpath"
+    events = "events"
+    history = "history"
+    tags = "tags"
+    random = "random"
+    spaces = "spaces"
+    counters = "counters"
+    reports = "reports"
+    aggregation = "aggregation"
+    attachments = "attachments"
+    attachments_aggregation = "attachments_aggregation"
+
+
+class SortType(StrEnum):
+    ascending = "ascending"
+    descending = "descending"
+
+
+class Status(StrEnum):
+    success = "success"
+    failed = "failed"
+
+
+class RedisReducerName(StrEnum):
+    count_distinct = "count_distinct"
+    r_count = "r_count"
+    # Same as COUNT_DISTINCT - but provide an approximation instead of an exact count,
+    # at the expense of less memory and CPU in big groups
+    count_distinctish = "count_distinctish"
+    sum = "sum"
+    min = "min"
+    max = "max"
+    avg = "avg"
+    # Returns all the matched properties in a list
+    tolist = "tolist"
+    quantile = "quantile"
+    stddev = "stddev"
+    # Selects the first value within the group according to sorting parameters
+    first_value = "first_value"
+    # Returns a random sample of items from the dataset, from the given property
+    random_sample = "random_sample"
+
+    @staticmethod
+    def mapper(red: str):
+        map = {
+            "r_count": reducers.count,
+            "count_distinct": reducers.count_distinct,
+            "count_distinctish": reducers.count_distinctish,
+            "sum": reducers.sum,
+            "min": reducers.min,
+            "max": reducers.max,
+            "avg": reducers.avg,
+            "tolist": reducers.tolist,
+            "quantile": reducers.quantile,
+            "stddev": reducers.stddev,
+            "first_value": reducers.first_value,
+            "random_sample": reducers.random_sample,
+        }
+        return map[red]
+
+
+class ReactionType(StrEnum):
+    like = "like"
+    dislike = "dislike"
+    love = "love"
+    care = "care"
+    laughing = "laughing"
+    sad = "sad"

password_gen.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+
+from utils.password_hashing import hash_password
+
+print("Enter the password: ", end="")
+password = input()
+print("Generated hash: ", end="")
+print(hash_password(password))

plugins/action_log/plugin.py

@@ -0,0 +1,121 @@
+import sys
+from typing import Any
+import aiofiles
+from utils.middleware import get_request_data
+from models.core import ActionType, PluginBase, Event, Payload
+from models.enums import ContentType, ResourceType
+from models.core import Action, Locator, Meta
+from utils.helpers import camel_case
+from utils.settings import settings
+from datetime import datetime
+from fastapi.logger import logger
+from data_adapters.adapter import data_adapter as db
+
+
+class Plugin(PluginBase):
+    async def hook(self, data: Event):
+        if settings.active_data_db == "sql":
+            return
+
+        if (
+            not isinstance(data.shortname, str)
+            or not isinstance(data.action_type, ActionType)
+            or not isinstance(data.resource_type, ResourceType)
+            or not isinstance(data.attributes, dict)
+        ):
+            logger.warning("invalid data at action_log")
+            return
+
+        class_type = getattr(
+            sys.modules["models.core"], camel_case(ResourceType(data.resource_type))
+        )
+
+        if data.action_type == ActionType.delete:
+            entry = data.attributes["entry"]
+        else:
+            entry = await db.load_or_none(
+                space_name=data.space_name,
+                subpath=data.subpath,
+                shortname=data.shortname,
+                class_type=class_type,
+                user_shortname=data.user_shortname,
+            )
+
+            if entry is None:
+                return
+
+        action_attributes = {}
+        if data.action_type == ActionType.create:
+            payload: dict[str,Any] = {}
+            if(
+                entry.payload and
+                isinstance(entry.payload, Payload) and
+                entry.payload.content_type and
+                entry.payload.content_type == ContentType.json
+                and entry.payload.body
+            ):
+                mypayload = await db.load_resource_payload(
+                    space_name=data.space_name,
+                    subpath=data.subpath,
+                    filename=entry.payload.body if isinstance(entry.payload.body, str) else data.shortname,
+                    class_type=class_type,
+                )
+                payload = mypayload if mypayload else {}
+            action_attributes = self.generate_create_event_attributes(entry, payload)
+
+        elif data.action_type == ActionType.update:
+            action_attributes = data.attributes.get("history_diff", {})
+
+        action_attributes = {**action_attributes, **get_request_data()}
+        action_attributes.pop("_sa_instance_state", None)
+        event_obj = Action(
+            resource=Locator(
+                uuid=entry.uuid,
+                type=data.resource_type,
+                space_name=data.space_name,
+                subpath=data.subpath,
+                shortname=data.shortname,
+                displayname=entry.displayname,
+                description=entry.description,
+                tags=entry.tags,
+            ),
+            user_shortname=data.user_shortname,
+            request=data.action_type,
+            timestamp=datetime.now(),
+            attributes=action_attributes,
+        )
+
+        events_file_path = (
+            settings.spaces_folder
+            / data.space_name
+            / ".dm"
+        )
+        events_file_path.mkdir(parents=True, exist_ok=True)
+        events_file_path = events_file_path / "events.jsonl"
+
+        # Remove binary content in the event object before serializing to json
+        if isinstance(event_obj.attributes, dict) and "media" in event_obj.attributes:
+            del event_obj.attributes["media"]
+
+        file_content = (
+            f"{event_obj.model_dump_json()}\n"
+        )
+        async with aiofiles.open(events_file_path, "a") as events_file:
+            await events_file.write(file_content)
+
+    def generate_create_event_attributes(self, entry: Meta, attributes: dict):
+        generated_attributes = {}
+        for key, value in entry.__dict__.items():
+            if key not in Meta.model_fields:
+                generated_attributes[key] = value
+
+        if entry.payload:
+            if isinstance(entry.payload, Payload):
+                generated_attributes["payload"] = entry.payload.model_dump()
+            else:
+                generated_attributes["payload"] = entry.payload
+
+        if attributes:
+            generated_attributes["payload"]["body"] = attributes
+
+        return generated_attributes

plugins/admin_notification_sender/plugin.py

@@ -0,0 +1,124 @@
+import json
+from sys import modules as sys_modules
+
+from models import api
+from models.core import Notification, NotificationData, PluginBase, Event, Translation
+from utils.helpers import camel_case
+from utils.notification import NotificationManager
+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 creating a new admin notification request
+        1- get the notification request
+        2- if it's scheduled for later, ignore it and let the cron job handle it
+        3- else send it to all its msisdns
+        """
+
+        # 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
+
+        notification_request_meta = await db.load(
+            data.space_name,
+            data.subpath,
+            data.shortname,
+            getattr(sys_modules["models.core"], camel_case(data.resource_type)),
+            data.user_shortname,
+        )
+
+        notification_dict = notification_request_meta.dict()
+        notification_dict["subpath"] = data.subpath
+        notification_request_payload = await db.get_payload_from_event(data)
+
+        notification_dict.update(notification_request_payload)
+
+        if not notification_dict or notification_dict.get("scheduled_at", False):
+            return
+
+        # Get msisdns users
+        search_criteria = notification_dict.get('search_string', '')
+        if not search_criteria:
+            search_criteria = '@msisdn:' + '|'.join(notification_dict.get('msisdns', ''))
+
+        total, receivers = await db.query(api.Query(
+            space_name=data.space_name,
+            subpath=notification_dict['subpath'],
+            filters={},
+            search=search_criteria,
+            limit=10000,
+            offset=0
+        ))
+        if total == 0:
+            return
+
+        sub_receivers: dict = receivers[0].model_dump()
+
+        receivers_shortnames = set()
+        for receiver in sub_receivers["data"]:
+            receivers_shortnames.add(json.loads(receiver)["shortname"])
+
+        # await send_notification(
+        #     notification_dict=notification_dict,
+        #     receivers=receivers_shortnames
+        # )
+        notification_manager = NotificationManager()
+        formatted_req = await self.prepare_request(notification_dict)
+        for receiver in set(receivers_shortnames):
+            if not formatted_req["push_only"]:
+                notification_obj = await Notification.from_request(notification_dict)
+                await db.internal_save_model(
+                    "personal",
+                    f"people/{receiver}/notifications",
+                    notification_obj,
+                )
+            for platform in formatted_req["platforms"]:
+                await notification_manager.send(
+                    platform=platform,
+                    data=NotificationData(
+                        receiver=receiver,
+                        title=formatted_req["title"],
+                        body=formatted_req["body"],
+                        image_urls=formatted_req["images_urls"],
+                    ),
+                )
+
+
+        notification_request_payload["status"] = "finished"
+        await db.save_payload_from_json(
+            space_name=data.space_name,
+            subpath=data.subpath,
+            meta=notification_request_meta,
+            payload_data=notification_request_payload,
+        )
+
+    async def prepare_request(self, notification_dict) -> dict:
+        # 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["types"],
+            "title": Translation(**notification_dict["displayname"]),
+            "body": Translation(**notification_dict["description"]),
+            "images_urls": Translation(**notification_images),
+            "push_only": notification_dict.get("push_only", False),
+        }

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()]
+                )],
+            }
+        )