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

api/user/model/errors.py

@@ -0,0 +1,14 @@
+from models.api import Error
+from utils.internal_error_code import InternalErrorCode
+
+INVALID_OTP = Error(
+    type="OTP",
+    code=InternalErrorCode.OTP_INVALID,
+    message="Invalid OTP",
+)
+
+EXPIRED_OTP = Error(
+    type="OTP",
+    code=InternalErrorCode.OTP_EXPIRED,
+    message="Expired OTP",
+)

api/user/model/requests.py

@@ -0,0 +1,165 @@
+from typing import Dict
+from pydantic import BaseModel, Field
+from utils.internal_error_code import InternalErrorCode
+import utils.regex as rgx
+from models.api import Exception, Error
+from models.enums import StrEnum
+
+
+class OTPType(StrEnum):
+    SMS = "SMS"
+    EMAIL = "EMAIL"
+
+
+class SendOTPRequest(BaseModel):
+    shortname: str | None = Field(None, pattern=rgx.SHORTNAME)
+    msisdn: str | None = Field(None, pattern=rgx.MSISDN)
+    email: str | None = Field(None, pattern=rgx.EMAIL)
+
+    def check_fields(self) -> Dict[str, str]:
+        if self.email is None and self.msisdn is None and self.shortname is None:
+            raise Exception(
+                422,
+                Error(
+                    type="OTP",
+                    code=InternalErrorCode.EMAIL_OR_MSISDN_REQUIRED,
+                    message="One of these [email, msisdn, shortname] should be set!",
+                ),
+            )
+
+        if [self.email, self.msisdn, self.shortname].count(None) != 2:
+            raise Exception(
+                422,
+                Error(
+                    type="OTP",
+                    code=InternalErrorCode.INVALID_STANDALONE_DATA,
+                    message="Too many input has been passed",
+                ),
+            )
+
+        elif self.msisdn:
+            return {"msisdn": self.msisdn}
+        elif self.email:
+            return {"email": self.email}
+        elif self.shortname:
+            return {"shortname": self.shortname}
+
+        raise Exception(
+            500,
+            Error(
+                type="OTP",
+                code=InternalErrorCode.OTP_ISSUE,
+                message="Something went wrong",
+            ),
+        )
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "msisdn": "7777778110"
+                }
+            ]
+        }
+    }
+
+class PasswordResetRequest(BaseModel):
+    msisdn: str | None = Field(None, pattern=rgx.MSISDN)
+    shortname: str | None = Field(None, pattern=rgx.SHORTNAME)
+    email: str | None = Field(None, pattern=rgx.EMAIL)
+
+    def check_fields(self) -> Dict[str, str]:
+        if self.email is None and self.msisdn is None and self.shortname is None:
+            raise Exception(
+                422,
+                Error(
+                    type="OTP",
+                    code=InternalErrorCode.EMAIL_OR_MSISDN_REQUIRED,
+                    message="One of these [shortname, email, msisdn] should be set!",
+                ),
+            )
+
+        if [self.email, self.msisdn, self.shortname].count(None) != 2:
+            raise Exception(
+                422,
+                Error(
+                    type="OTP",
+                    code=InternalErrorCode.INVALID_STANDALONE_DATA,
+                    message="Too many input has been passed",
+                ),
+            )
+
+        elif self.msisdn:
+            return {"msisdn": self.msisdn}
+        elif self.email:
+            return {"email": self.email}
+        elif self.shortname:
+            return {"shortname": self.shortname}
+
+        raise Exception(
+            500,
+            Error(
+                type="password_reset",
+                code=InternalErrorCode.PASSWORD_RESET_ERROR,
+                message="Something went wrong",
+            ),
+        )
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "msisdn": "7777778110"
+                }
+            ]
+        }
+    }
+class ConfirmOTPRequest(SendOTPRequest, BaseModel):
+    code: str = Field(..., pattern=rgx.OTP_CODE)
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "code": "84293201"
+                }
+            ]
+        }
+    }
+
+class UserLoginRequest(BaseModel):
+    shortname: str | None = Field(None, pattern=rgx.SHORTNAME)
+    email: str | None = Field(None, pattern=rgx.EMAIL)
+    msisdn: str | None = Field(None, pattern=rgx.MSISDN)
+    password: str | None = Field(None)
+    invitation: str | None = Field(None, pattern=rgx.INVITATION)
+    firebase_token: str | None = Field(None)
+    otp: str | None = Field(None)
+
+    def check_fields(self) -> Dict[str, str] | None:
+        if self.shortname is None and self.email is None and self.msisdn is None:
+            return {}
+            # raise ValueError("One of these [shortname, email, msisdn] should be set!")
+
+        if [self.shortname, self.email, self.msisdn].count(None) != 2:
+            raise ValueError("Too many input has been passed")
+
+        if self.shortname:
+            return {"shortname": self.shortname}
+        elif self.msisdn:
+            return {"msisdn": self.msisdn}
+        elif self.email:
+            return {"email": self.email}
+
+        return None
+
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "shortname": "john_doo",
+                    "password": "my_secure_password_@_93301"
+                }
+            ]
+        }
+    }

api/user/model/responses.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+
+from models.api import Response
+
+
+class Confirmation(BaseModel):
+    confirmation: str = Field(...)
+
+
+class ConfirmationResponse(Response):
+    data: Confirmation

{dmart-0.1.6.dist-info → dmart-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dmart
-Version: 0.1.6
+Version: 0.1.8
 Requires-Python: >=3.10
 Requires-Dist: fastapi
 Requires-Dist: pydantic

{dmart-0.1.6.dist-info → dmart-0.1.8.dist-info}/RECORD

@@ -14,6 +14,27 @@ sync.py,sha256=FlmubtlnFaxtZkbRV1-eyS_Sx5KBRvWyIZjvd0Tiar4,7339
 websocket.py,sha256=Q8WUTvOTBHKP5xy5wim8yn0t-BfjrPwx7J_6vbzAm1A,7576
 alembic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alembic/env.py,sha256=z12UKhorKSOKEovOCQOwRjfR_tup4VeRlhcB1UPk3Xw,2700
+alembic/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+alembic/scripts/calculate_checksums.py,sha256=v2NLEvReA9V3noJE-BWANgKDdhc8Mqg1ZmJJ8nc8sGI,3443
+alembic/scripts/migration_f7a4949eed19.py,sha256=oUXuxjU4MbVafm4S-xu5J_4apHqW6hQZ8ftpJtCtM28,1462
+alembic/versions/0f3d2b1a7c21_add_authz_materialized_views.py,sha256=70vrPfhMHVHhw1l7KNQpvCUU76XZfvGcPlrXOeU4FHU,2599
+alembic/versions/10d2041b94d4_last_checksum_history.py,sha256=FYjyzE5Xi6bn9LUtxLKFnQOKhg4GZOrTkpqtmlCnY6Y,2860
+alembic/versions/1cf4e1ee3cb8_ext_permission_with_filter_fields_values.py,sha256=taaFTkTaFfLfj7QUUfIdcojvbOdjut_dWtrIvQUN7-4,921
+alembic/versions/26bfe19b49d4_rm_failedloginattempts.py,sha256=-Roftn8OSUz7kfR3yMI02rulyvnH46W0WpJfDQ5xAdk,1471
+alembic/versions/3c8bca2219cc_add_otp_table.py,sha256=f-YSxx1iLA0iHWukq1VnngFmiiYQyEzowicox0-wtbY,1125
+alembic/versions/6675fd9dfe42_remove_unique_from_sessions_table.py,sha256=yP40IHwtzFAAUid_VeeCkt_9F2RszMYBjNKx2mDTKNw,1037
+alembic/versions/71bc1df82e6a_adding_user_last_login_at.py,sha256=LINO2hWUEFmsTspupd8AxgUS6tNJFNgGC5do1QPMQ1E,1486
+alembic/versions/74288ccbd3b5_initial.py,sha256=hZ1w5mqVKSO13J1O4zcTccDJBk2c-cmIB0AUx1KLlLI,13988
+alembic/versions/7520a89a8467_rm_activesession_table.py,sha256=4VYv9tCXkTQNaXPVvjdsKTiw093KkBBUHNSiWdZtqtA,1305
+alembic/versions/848b623755a4_make_created_nd_updated_at_required.py,sha256=o106xd-apT8ZAXdVCjX76o7VuqRQNkIl0V4f41m5j2E,5375
+alembic/versions/8640dcbebf85_add_notes_to_users.py,sha256=XjfW2Lc0-xoRGB2qfdzDstw7Caaev6JhqRNYV_sIqgc,813
+alembic/versions/91c94250232a_adding_fk_on_owner_shortname.py,sha256=F9FDF2qyeqvOx1gkYq5HQMkVCH1QrXciYSHVxijsSSU,4024
+alembic/versions/98ecd6f56f9a_ext_meta_with_owner_group_shortname.py,sha256=S466VE3jsxXDEpTKyhIN06uutM0jI7zYHTWIYvU_pJw,2579
+alembic/versions/9aae9138c4ef_indexing_created_at_updated_at.py,sha256=xrqfJB5cER0PYi1torwkgsbBBjDeeM6dyj4pu-quphk,3662
+alembic/versions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+alembic/versions/b53f916b3f6d_json_to_jsonb.py,sha256=LPnevQjbjs0KrwqxYHtGUC6mSBBsUpiCBnwD-FN2x50,24840
+alembic/versions/eb5f1ec65156_adding_user_locked_to_device.py,sha256=4U45sfMGIBMcRkwPuFPRc_M9pL2lmOn9kguWjakPAbU,1007
+alembic/versions/f7a4949eed19_adding_query_policies_to_meta.py,sha256=LA4rx3u0Ei5m4OcSsVYHBsGMeKOJdx8G88yK1kBLFys,2307
 api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 api/info/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 api/info/router.py,sha256=sQZZor7A-uDzsJX39aqEA7bMZOJ-WTitYeFvVNWfaHw,3938
@@ -27,6 +48,10 @@ api/qr/router.py,sha256=Ru7UT_iQS6mFwE1bCPPrusSQfFgoV_u6pjZJ0gArE7g,3870
 api/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 api/user/router.py,sha256=FwuxM04niGlls-V1MPzHH5A4jHJ0g5NNIFZBE6bJ9Fc,51302
 api/user/service.py,sha256=-iQpcBVPTDiLE_xOf87Ni0oSQDtmALAXEwU4IgSvnJk,8463
+api/user/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api/user/model/errors.py,sha256=rhcIcbAIk_7rs5lxdgcsf7SWFGmC9QLsgc67x7S6CKA,299
+api/user/model/requests.py,sha256=MazMirg7wQoUm4qvnm_EAB_gJIy3YxvYYqNyU3fZJc0,5025
+api/user/model/responses.py,sha256=0vbigspq_aBd1JS6hEm13BnG7Hm7EIiWBZ6xz3d5hmE,202
 config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 config/channels.json,sha256=GepystGi0h_1fuakC_gdIc-YYxyy-a4TI619ygIpyyM,156
 config/notification.json,sha256=esrOaMUIqfcCHB0Tawp3t4cu7DQAA15X12OS-Gyenb0,361
@@ -63,6 +88,24 @@ models/api.py,sha256=f5X56dudyEysPmDuI5grM2RRCXuIQoehaAB6wMAGG28,6473
 models/core.py,sha256=tEb7cbnC71yE9SDluynj7dE3U8Ed-EbF3uRJizy-uuU,16880
 models/enums.py,sha256=y2G5EKIc8FusVW4JvEozGFKL2GxjtuOK7k3zSguP4dc,5395
 plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/action_log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/action_log/plugin.py,sha256=-JY_iIIJJjFFofvpMoCxNJMXNr_KC6kA8TiwvvoxaWI,4434
+plugins/admin_notification_sender/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/admin_notification_sender/plugin.py,sha256=sxVGW8qtRmDEQeS6QD3F3IqzZOoh_9H_y2TsRCDkXaw,4771
+plugins/ldap_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/ldap_manager/plugin.py,sha256=c05pKGsyLETMrheCqIw3gZOSLdTWvEDq_WCl0Q_0yXQ,3030
+plugins/local_notification/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/local_notification/plugin.py,sha256=FObVxID5Bg0G_xStpJYZkg706wu_CpUqk09DmzHAyPQ,4074
+plugins/realtime_updates_notifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/realtime_updates_notifier/plugin.py,sha256=Gcvob4ShSs2Ht1hLD2vtwhR_PSFYMv3_l_VPM2opTYs,2374
+plugins/redis_db_update/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/redis_db_update/plugin.py,sha256=z05k1zNJgBnKPj-jrtMUeI9br75ZPlifbzL0HxpRnXg,7128
+plugins/resource_folders_creation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/resource_folders_creation/plugin.py,sha256=OwYPtRjMt2esAAEdv1FjdZgjEz01yt2xOZQi3nB0kEQ,3327
+plugins/system_notification_sender/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/system_notification_sender/plugin.py,sha256=96xzmuUGvO2WOJ5y90akDoRB7Bqy-VpOo6ht8-rLLtQ,8253
+plugins/update_access_controls/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugins/update_access_controls/plugin.py,sha256=43UV4vg-zxBF_7Bv0AZH6gU0Bgy2ybapNK21wJTF05k,301
 pytests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pytests/api_user_models_erros_test.py,sha256=6VWLIhazYjz7avXIMIDpT6doiBO5FVzGsGJ3Cv8cXyg,583
 pytests/api_user_models_requests_test.py,sha256=1AYZcMwa-AVeGrhTgwIkwqw3w7_CDPkbaJ0YDxLLKdY,3859
@@ -99,8 +142,8 @@ utils/ticket_sys_utils.py,sha256=9QAlW2iiy8KyxQRBDj_WmzS5kKb0aYJmGwd4qzmGVqo,700
 utils/web_notifier.py,sha256=QM87VVid2grC5lK3NdS1yzz0z1wXljr4GChJOeK86W4,843
 utils/templates/activation.html.j2,sha256=XAMKCdoqONoc4ZQucD0yV-Pg5DlHHASZrTVItNS-iBE,640
 utils/templates/reminder.html.j2,sha256=aoS8bTs56q4hjAZKsb0jV9c-PIURBELuBOpT_qPZNVU,639
-dmart-0.1.6.dist-info/METADATA,sha256=ftqcSub4og9EUODZ17nuZMM0w5RIDwN8d3iPJh-zuqg,2091
-dmart-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dmart-0.1.6.dist-info/entry_points.txt,sha256=GjfoGh1bpxuU9HHGJzbtCFPNptHv9TryxHMN3uBSKpg,37
-dmart-0.1.6.dist-info/top_level.txt,sha256=JTypu1r5v9v7ru-60JSSbnSMEESHFRMacpcz-rPJx_U,262
-dmart-0.1.6.dist-info/RECORD,,
+dmart-0.1.8.dist-info/METADATA,sha256=rm9HvMHuQkwfhoqO9mQfhMjHGA8_7DU__kyukUzXXwM,2091
+dmart-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dmart-0.1.8.dist-info/entry_points.txt,sha256=GjfoGh1bpxuU9HHGJzbtCFPNptHv9TryxHMN3uBSKpg,37
+dmart-0.1.8.dist-info/top_level.txt,sha256=JTypu1r5v9v7ru-60JSSbnSMEESHFRMacpcz-rPJx_U,262
+dmart-0.1.8.dist-info/RECORD,,

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