flowtask 5.8.4__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/components/NetworkNinja/models/abstract.py

@@ -0,0 +1,177 @@
+from typing import Any, ClassVar, Optional, Union
+from datetime import datetime, timezone
+from datamodel import BaseModel, Field
+from asyncpg.exceptions import UniqueViolationError
+from asyncdb import AsyncDB
+from asyncdb.utils.types import Entity
+from navconfig.logging import logging
+from querysource.conf import default_dsn, async_default_dsn
+from querysource.outputs.tables import PgOutput
+
+
+class AbstractPayload(BaseModel):
+    """Abstract Payload Model.
+
+    Common fields implemented by any Object in NetworkNinja Payloads.
+    """
+    orgid: int
+    inserted_at: datetime = Field(required=False, default=datetime.now)
+    _pgoutput: ClassVar[Optional[Any]] = None
+
+    def __post_init__(self):
+        super().__post_init__()
+        object.__setattr__(self, '_pgoutput', PgOutput(
+            dsn=async_default_dsn,
+            use_async=True
+        ))
+
+    def ensure_timezone(self, dt: Union[datetime, None]) -> Union[datetime, None]:
+        """Ensure a datetime has timezone information."""
+        if dt is None:
+            return None
+        if isinstance(dt, datetime.datetime) and dt.tzinfo is None:
+            return dt.replace(tzinfo=timezone.utc)
+        return dt
+
+    async def sync(self, **kwargs):
+        """
+        Sync the Object with the Database
+        """
+        return await self.upsert_record(**kwargs)
+
+    async def upsert_record(self, **kwargs):
+        """Upsert Record to Database.
+        """
+        # output = PgOutput(dsn=async_default_dsn, use_async=True)
+        # Synchronize self object into the database using Upsert.
+        fields = self.columns()
+        # remove from column list the "_pgoutput" field
+        fields.pop('_pgoutput', None)
+        pk = kwargs.get('pk', [])
+        if not pk:
+            for _, field in fields.items():
+                if field.primary_key:
+                    pk.append(field.name)
+        async with self._pgoutput as conn:
+            try:
+                if self.Meta.name:
+                    return await conn.do_upsert(
+                        self,
+                        table_name=self.Meta.name,
+                        schema=self.Meta.schema,
+                        primary_keys=pk,
+                        use_conn=conn.get_connection()
+                    )
+                else:
+                    logging.warning(
+                        f"Unable to Upsert NetworkNinja record: {self.Meta}"
+                    )
+                    return None
+            except Exception as e:
+                logging.error(
+                    f"Error Upserting Record: {e}"
+                )
+                return None
+
+    async def _sync_object(self, conn: Any):
+        pass
+
+    async def on_sync(self, conn: Any, upsert: bool = True):
+        """
+        Sync Current Object with the Database.
+        """
+        await self._sync_object(conn)
+
+    async def save(self, conn: Any, pk: Union[str, list] = None, **kwargs):
+        """
+        Save the Object to the Database.
+        """
+        if isinstance(pk, str):
+            pk = [pk]
+        # Create a string with the WHERE clause (a = 1 AND b = 2)
+        conditions = [f"{k} = ${i+1}" for i, k in enumerate(pk)]
+        _where = " AND ".join(conditions)
+        _values = [getattr(self, k) for k in pk]
+        qry = f"SELECT EXISTS (SELECT 1 FROM {self.Meta.schema}.{self.Meta.name} WHERE {_where})"
+        # print('QUERY INSERT > ', qry, _values)
+        try:
+            exists = await conn.fetchval(qry, *_values)
+        except Exception as e:
+            print('ERROR EXISTS > ', e)
+            exists = False
+        # print('EXISTS > ', exists, type(exists))
+        if exists:
+            # Making an Upsert:
+            return await self.upsert_record(pk=pk, **kwargs)
+        else:
+            # Doing a Faster insert:
+            logging.debug(
+                f"Inserting new record: {self.Meta.schema}.{self.Meta.name}"
+            )
+            return await self.insert_record(conn)
+
+    async def insert_record(self, conn: Any, **kwargs):
+        """Insert Record to Database.
+        """
+        # Convert all objects in dataclass into a INSERT statement
+        columns = self.get_fields()
+        # remove from column list the "_pgoutput" field
+        columns = [col for col in columns if col != '_pgoutput']
+        cols = ",".join(columns)
+        data = self.to_dict(as_values=True)
+        # print('DATA > ', data)
+        data.pop('_pgoutput', None)
+        _values = ', '.join([f"${i+1}" for i, _ in enumerate(columns)])
+        insert = f"INSERT INTO {self.Meta.schema}.{self.Meta.name}({cols}) VALUES({_values})"
+        try:
+            # Convert data dictionary into a list, ordered by column list:
+            source = [data.get(col) for col in columns]
+            stmt = await conn.engine().prepare(insert)
+            result = await stmt.fetchrow(*source, timeout=2)
+            # logging.debug(f"Result: {result}, Status: {stmt.get_statusmsg()}")
+            return True
+        except Exception as e:
+            logging.error(
+                f"Error Inserting Record: {e}"
+            )
+            return False
+
+    async def update_many(
+        self,
+        objects: list,
+        primary_keys: list = None,
+        **kwargs
+    ):
+        """Upsert Several Records in Database.
+        """
+        output = PgOutput(dsn=async_default_dsn, use_async=True)
+        # Synchronize self object into the database using Upsert.
+        if not primary_keys:
+            fields = self.columns()
+            pk = []
+            for _, field in fields.items():
+                if field.primary_key:
+                    pk.append(field.name)
+        else:
+            pk = primary_keys
+        async with output as conn:
+            try:
+                if self.Meta.name:
+                    await conn.upsert_many(
+                        objects,
+                        table_name=self.Meta.name,
+                        schema=self.Meta.schema,
+                        primary_keys=pk,
+                        # use_conn=conn.get_connection()
+                    )
+                    return True
+                else:
+                    logging.warning(
+                        f"Unable to Upsert NetworkNinja record: {self.Meta}"
+                    )
+                    return None
+            except Exception as e:
+                logging.error(
+                    f"Error Upserting Record: {e}"
+                )
+                return None

flowtask/components/NetworkNinja/models/account.py

@@ -0,0 +1,39 @@
+from datetime import datetime, timezone
+from datamodel import Field
+from .abstract import AbstractPayload
+
+
+class Account(AbstractPayload):
+    """
+    {
+            "metadata": {
+                "type": "retailer",
+                "transaction_type": "UPSERT",
+                "source": "MainEvent",
+                "client": "global",
+                "client_id": 1,
+                "orgid": null,
+                "timestamp": 1742240432.348096
+            },
+            "payload": {
+                "account_id": 26,
+                "account_name": "Brandsmart",
+                "active": true
+            }
+        },
+    """
+    account_id: int = Field(primary_key=True, required=True)
+    account_name: str
+    active: bool = Field(default=True)
+    retailer: int
+    inserted_at: datetime = Field(default=datetime.now(tz=timezone.utc))
+
+    class Meta:
+        strict = True
+        as_objects = True
+        name = 'accounts'
+        schema: str = 'networkninja'
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.retailer = self.account_id

flowtask/components/NetworkNinja/models/client.py

@@ -0,0 +1,19 @@
+from datamodel import BaseModel, Field
+from .abstract import AbstractPayload
+from .organization import Organization
+
+
+class Client(AbstractPayload):
+    client_id: int = Field(required=False)
+    client_name: str
+    status: bool = Field(required=True, default=True)
+    orgid: int = Field(required=False)
+    program_id: int = Field(required=False)
+    program_name: str
+    program_slug: str
+
+    class Meta:
+        name: str = 'clients'
+        schema: str = 'networkninja'
+        strict: bool = True
+        as_objects: bool = True

flowtask/components/NetworkNinja/models/district.py

@@ -0,0 +1,14 @@
+from datamodel import BaseModel, Field
+
+
+class District(BaseModel):
+    district_id: str = Field(required=False, alias='id')
+    district_name: str = Field(required=False, alias='name')
+    is_active: bool = Field(required=False, alias='active')
+    client_id: int
+    orgid: int
+
+    class Meta:
+        name: str = 'districts'
+        schema: str = 'networkninja'
+        strict: bool = True

flowtask/components/NetworkNinja/models/events.py

@@ -0,0 +1,101 @@
+from typing import List, Optional
+from datetime import datetime
+from datamodel import BaseModel, Field
+from .abstract import AbstractPayload
+
+
+class EventPosition(BaseModel):
+    """
+    Event Position Model.
+    """
+    event_position_id: int = Field(primary_key=True, required=True)
+    staff_position_id: int = Field(required=True)
+    staff_position_name: str = Field(required=True)
+    position_start_time: datetime = Field(required=True)
+    position_end_time: datetime = Field(required=True)
+    assigned_staff_id: int
+    staffing_status: str = Field(required=True)
+    position_created_at: datetime = Field(required=True)
+    position_updated_at: datetime = Field(required=True)
+    position_duration_hours: float = Field(default=1)
+    staff_position_email: str = Field(required=False)
+
+class Event(AbstractPayload):
+    """
+    Event Model.
+    """
+    event_id: int = Field(primary_key=True, required=True)
+    client_id: int
+    name: str = Field(required=True)
+    start_timestamp: datetime = Field(required=True)
+    end_timestamp: datetime = Field(required=True)
+    created_at: datetime = Field(required=True)
+    updated_at: datetime = Field(required=True)
+    duration_hours: float = Field(default=1.0)
+    formid: int = Field(required=True, alias='form_id')
+    description: str
+    status: str = Field(required=True)
+    type: str = Field(required=True)
+    program_id: int = Field(required=True)
+    program_name: str = Field(required=True)
+    store_id: int = Field(required=True)  # "store_id": 5432
+    category: str = Field(required=False)
+    event_positions: List[EventPosition] = Field(required=False)
+    is_deleted: bool = Field(default=False)
+    is_archived: bool = Field(default=False)
+    ad_hoc: bool = Field(default=False)
+
+    class Meta:
+        strict = True
+        as_objects = True
+        name = 'events'
+        schema: str = 'networkninja'
+
+
+class EventPunch(AbstractPayload):
+    """
+    Event Punch Model.
+
+    Example:
+        {
+
+                "cico_id": 4089,
+                "event_id": 12272,
+                "visitor_id": 18180,
+                "latitude": "32.8066746",
+                "longitude": "-97.426601",
+                "cico_type": "out",
+                "related_checkout_id": null,
+                "total_hours": null,
+                "client_id": 57,
+                "orgid": 106,
+                "visitor_name": "Margaret Ojeogwu",
+                "timestamp_utc": "2025-03-22T01:17:36+00:00"
+            }
+    """
+    cico_id: int = Field(primary_key=True, required=True)
+    event_id: int = Field(required=True)
+    visitor_id: int = Field(required=True)
+    latitude: float
+    longitude: float
+    cico_type: str = Field(required=True)
+    related_checkout_id: Optional[int]
+    total_hours: float
+    client_id: int = Field(required=True)
+    orgid: int = Field(required=True)
+    visitor_name: str = Field(required=False)
+    event_timestamp: datetime = Field(required=True, alias='timestamp_utc')
+    is_archived: bool = Field(default=False)
+    is_deleted: bool = Field(default=False)
+    visitor_email: str = Field(required=False)
+
+    class Meta:
+        strict = True
+        as_objects = True
+        name = 'evt_checkin_checkout'
+        schema: str = 'networkninja'
+
+    def __post_init__(self):
+        super().__post_init__()
+        if self.visitor_id:
+            self.user_id = self.visitor_id