saas-common-lib-473815 0.1__tar.gz

saas_common_lib_473815-0.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: saas_common_lib_473815
+Version: 0.1
+Summary: Packaging all common functionalities
+Home-page: 
+Author: Srinidhi Nagarajan
+Author-email: Srinidhinsn@gmail.com
+License: BSD
+Keywords: Saas application
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: keywords
+Dynamic: license
+Dynamic: summary

saas_common_lib_473815-0.1/config/settings.py

@@ -0,0 +1,20 @@
+# Define logging configuration
+LOGGING_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "default": {
+            "format": "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+        }
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "formatter": "default"
+        }
+    },
+    "root": {
+        "handlers": ["console"],
+        "level": "INFO"
+    }
+}

saas_common_lib_473815-0.1/database/base.py

@@ -0,0 +1,3 @@
+from sqlalchemy.orm import declarative_base
+
+Base = declarative_base()

saas_common_lib_473815-0.1/database/postgres.py

@@ -0,0 +1,50 @@
+import os
+import sqlalchemy
+from sqlalchemy.ext.declarative import declarative_base
+from google.cloud.sql.connector import Connector, IPTypes
+import pg8000
+
+Base = declarative_base()
+
+def get_db() -> sqlalchemy.engine.base.Engine:
+    """
+    Initializes a connection pool for a Cloud SQL instance of Postgres.
+
+    Uses the Cloud SQL Python Connector package.
+    """
+    # Note: Saving credentials in environment variables is convenient, but not
+    # secure - consider a more secure solution such as
+    # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
+    # keep secrets safe.
+
+    instance_connection_name = os.environ[
+        "saas-473815:asia-south2:saas"
+    ]  # e.g. 'project:region:instance'
+    db_user = os.environ["postgres"]  # e.g. 'my-db-user'
+    db_pass = os.environ["Saasqa@123"]  # e.g. 'my-db-password'
+    db_name = os.environ["postgres"]  # e.g. 'my-database'
+
+    ip_type = IPTypes.PRIVATE if os.environ.get("PRIVATE_IP") else IPTypes.PUBLIC
+
+    # initialize Cloud SQL Python Connector object
+    connector = Connector(refresh_strategy="LAZY")
+
+    def getconn() -> pg8000.dbapi.Connection:
+        conn: pg8000.dbapi.Connection = connector.connect(
+            instance_connection_name,
+            "pg8000",
+            user=db_user,
+            password=db_pass,
+            db=db_name,
+            ip_type=ip_type,
+        )
+        return conn
+
+    # The Cloud SQL Python Connector can be used with SQLAlchemy
+    # using the 'creator' argument to 'create_engine'
+    pool = sqlalchemy.create_engine(
+        "postgresql+pg8000://",
+        creator=getconn,
+        # ...
+    )
+    return pool

saas_common_lib_473815-0.1/entity/billing_entity.py

@@ -0,0 +1,117 @@
+from sqlalchemy import Column, BigInteger, Text, Float, DateTime, Boolean, Identity, ForeignKey, func, Integer
+from database.base import Base
+from models.billing_model import BillingDocument, BillingDocumentItem
+from enum import Enum
+
+class PaymentStatusEnum(str, Enum):
+    pending = "Pending"
+    paid    = "Paid"
+    partial = "Partial"
+    overdue = "Overdue"
+
+class ApprovalStatusEnum(str, Enum):
+    pending  = "Pending"
+    approved = "Approved"
+    rejected = "Rejected"
+
+class BillingDocumentEntity(Base):
+    __tablename__ = "billing_documents"
+
+    id                       = Column(BigInteger, Identity(always=True), primary_key=True)
+    client_id                = Column(Text, nullable=True)
+    document_type            = Column(Text, nullable=True) # Quotation, 
+    document_number          = Column(Text, nullable=True)
+    document_date            = Column(DateTime, nullable=True)
+    due_date                 = Column(DateTime, nullable=True)
+    reference_number         = Column(Text, nullable=True)
+    order_id                 = Column(Text, nullable=True)
+    customer_id              = Column(Text, nullable=True)
+    vendor_id                = Column(Text, nullable=True)
+    currency                 = Column(Text, nullable=True)
+    status                   = Column(Text, nullable=True) # paid, cancelled, partially paid
+    contact_email            = Column(Text, nullable=True)
+    contact_phone            = Column(Text, nullable=True)
+    terms                    = Column(Text, nullable=True)
+    notes                    = Column(Text, nullable=True)
+    subtotal                 = Column(Float, nullable=True)
+    tax_amount               = Column(Float, nullable=True) #
+    discount_amount          = Column(Float, nullable=True)
+    total_amount             = Column(Float, nullable=True)
+    linked_document_ids      = Column(Text, nullable=True)
+    is_active                = Column(Boolean, nullable=False, default=True)
+    created_by               = Column(Text, nullable=True)
+    updated_by               = Column(Text, nullable=True)
+    created_at               = Column(DateTime, default=func.now())
+    updated_at               = Column(DateTime, default=func.now(), onupdate=func.now())
+    payment_status           = Column(Text, nullable=True, default=PaymentStatusEnum.pending)
+    payment_due_date         = Column(DateTime, nullable=True)
+    payment_method           = Column(Text, nullable=True)
+    payment_reference        = Column(Text, nullable=True)
+    approval_status          = Column(Text, nullable=True, default=ApprovalStatusEnum.pending) # rejected
+    approved_by              = Column(Text, nullable=True)
+    approval_date            = Column(DateTime, nullable=True)
+    gl_account_code          = Column(Text, nullable=True)
+    tax_code                 = Column(Text, nullable=True)
+    accounting_period        = Column(Text, nullable=True)
+    currency_conversion_rate = Column(Float, nullable=True)
+    shipping_address         = Column(Text, nullable=True)
+    shipping_method          = Column(Text, nullable=True)
+    delivery_date            = Column(DateTime, nullable=True)
+    tracking_number          = Column(Text, nullable=True)
+    document_version         = Column(Integer, default=1)
+    invoice_date             = Column(DateTime, nullable=True)
+    note                     = Column(Text, nullable=True)
+    customer_terms           = Column(Text, nullable=True)
+
+    @staticmethod
+    def copyToModel(entity):
+        model = BillingDocument(**entity.__dict__)
+        model.__dict__.pop("_sa_instance_state", None)
+        return model
+
+    @staticmethod
+    def copyToModels(entities):
+        models = [BillingDocument(**e.__dict__) for e in entities]
+        for m in models:
+            m.__dict__.pop("_sa_instance_state", None)
+        return models
+
+class BillingDocumentItemEntity(Base):
+    __tablename__   = "billing_document_items"
+
+    id              = Column(BigInteger, Identity(always=True), primary_key=True)
+    document_id     = Column(BigInteger, ForeignKey("billing_documents.id", ondelete="CASCADE"), nullable=True) 
+    item_ref_id     = Column(Text, nullable=True)
+    description     = Column(Text, nullable=True)
+    quantity        = Column(Float, nullable=True)
+    unit_price      = Column(Float, nullable=True)
+    discount        = Column(Float, nullable=True)
+    tax_rate        = Column(Float, nullable=True)
+    total           = Column(Float, nullable=True)
+    is_active       = Column(Boolean, nullable=False, default=True)
+    created_at      = Column(DateTime, default=func.now())
+    updated_at      = Column(DateTime, default=func.now(), onupdate=func.now())
+    unit_of_measure = Column(Text, nullable=True, default="Unit")
+    item_category   = Column(Text, nullable=True)
+    item_discount   = Column(Float, nullable=True, default=0.0)
+    item_tax_code   = Column(Text, nullable=True, default="Standard")
+
+    @staticmethod
+    def copyToModel(entity):
+        model = BillingDocumentItem(**entity.__dict__)
+        model.__dict__.pop("_sa_instance_state", None)
+        return model
+
+    @staticmethod
+    def copyToModels(entities):
+        models = [BillingDocumentItem(**e.__dict__) for e in entities]
+        for m in models:
+            m.__dict__.pop("_sa_instance_state", None)
+        return models
+
+
+
+             
+
+
+

saas_common_lib_473815-0.1/entity/client_entity.py

@@ -0,0 +1,27 @@
+from sqlalchemy import Column, Text, DateTime, func, ARRAY
+from sqlalchemy.dialects.postgresql import UUID
+import uuid
+from database.base import Base
+from models.client_model import ClientModel
+
+
+class Client(Base):
+    __tablename__ = "client"
+
+    id = Column(Text, primary_key=True)
+    name = Column(Text, nullable=False)
+    realm = Column(Text)
+    email = Column(Text, unique=True, nullable=True)
+    phone = Column(Text, nullable=True)
+    logo = Column(Text, nullable=True)
+    saved_address_ids = Column(ARRAY(Text), nullable=True)
+    created_date_time = Column(DateTime, default=func.now())
+    updated_date_time = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+    @staticmethod
+    def copyToModel(client):
+        model = ClientModel(**client.__dict__)
+        model.__dict__.pop("_sa_instance_state", None)
+        return model
+

saas_common_lib_473815-0.1/entity/document_entity.py

@@ -0,0 +1,44 @@
+from sqlalchemy import Column, Boolean, DateTime, Text, func
+from sqlalchemy.dialects.postgresql import UUID
+import uuid
+from database.base import Base
+from models.document_model import Document
+
+class DocumentEntity(Base):
+    __tablename__ = "documents"
+
+    id                  = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    client_id           = Column(Text, nullable=True)
+    category_id         = Column(Text, nullable=True)
+    name                = Column(Text, nullable=True)
+    description         = Column(Text, nullable=True)
+    realm               = Column(Text, nullable=True)
+    filetype            = Column(Text, nullable=True)
+    extension           = Column(Text, nullable=True)
+    size_kb             = Column(Text, nullable=True)
+    is_protected        = Column(Boolean, nullable=True)
+    is_active           = Column(Boolean, nullable=True)
+    uuid_name           = Column(Text, nullable=True)
+    path                = Column(Text, nullable=True)
+    storage_type        = Column(Text, nullable=True)
+    checksum_md5        = Column(Text, nullable=True)
+    created_by          = Column(Text, nullable=True)
+    last_read_by        = Column(Text, nullable=True)
+    created_date_time   = Column(DateTime, default=func.now())
+    last_read_date_time = Column(DateTime, default=func.now())
+
+    deleted             = Column(Boolean, nullable=True)
+    deleted_at          = Column(DateTime, nullable=True)
+
+    @staticmethod
+    def copyToModel(document):
+        model = Document(**document.__dict__)
+        model.__dict__.pop("_sa_instance_state", None)
+        return model
+
+    @staticmethod
+    def copyToModels(docs):
+        models = [Document(**doc.__dict__) for doc in docs]
+        for m in models:
+            m.__dict__.pop("_sa_instance_state", None)
+        return models

saas_common_lib_473815-0.1/entity/inventory_entity.py

@@ -0,0 +1,75 @@
+from sqlalchemy import Column, Integer, BigInteger, Boolean, Text, DateTime, Float, func, ARRAY
+from database.base import Base
+from models.inventory_model import Inventory, Category
+from sqlalchemy.dialects.postgresql import JSONB
+
+
+class InventoryEntity(Base):
+    __tablename__ = "inventory"
+
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    client_id = Column(Text, nullable=False)
+    inventory_id = Column(BigInteger, nullable=True)
+    line_item_id = Column(ARRAY(BigInteger), nullable=True)
+    name = Column(Text, nullable=True)
+    description = Column(Text, nullable=True)
+    category_id = Column(Text, nullable=True)
+    realm = Column(Text, nullable=True)
+    availability = Column(Integer, nullable=True)
+    unit = Column(Text, nullable=True)
+    unit_price = Column(Float, nullable=True)
+    unit_cst = Column(Float, nullable=True)
+    unit_gst = Column(Float, nullable=True)
+    unit_total_price = Column(Float, nullable=True)
+    price = Column(Float, nullable=True)
+    cst = Column(Float, nullable=True)
+    gst = Column(Float, nullable=True)
+    discount = Column(Float, nullable=True)
+    total_price = Column(Float, nullable=True)
+    slug = Column(Text, nullable=True)
+    created_by = Column(Text, nullable=True)
+    updated_by = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    @staticmethod
+    def copyToModel(row):
+        model = Inventory(**row.__dict__)
+        model.__dict__.pop("_sa_instance_state", None)
+        return model
+
+    @staticmethod
+    def copyToModels(rows):
+        models = [Inventory(**row.__dict__) for row in rows]
+        for m in models:
+            m.__dict__.pop("_sa_instance_state", None)
+        return models
+
+
+class CategoryEntity(Base):
+    __tablename__ = "category"
+
+    id = Column(Text, primary_key=True)
+    client_id = Column(Text, nullable=False)
+    name = Column(Text, nullable=True)
+    description = Column(Text, nullable=True)
+    sub_categories = Column(ARRAY(Text), nullable=True)
+    # sub_categories  = Column(JSONB, nullable=True, default=[])
+    slug = Column(Text, nullable=True)
+    created_by = Column(Text, nullable=True)
+    updated_by = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    @staticmethod
+    def copyToModel(row):
+        model = Category(**row.__dict__)
+        model.__dict__.pop("_sa_instance_state", None)
+        return model
+
+    @staticmethod
+    def copyToModels(rows):
+        models = [Category(**row.__dict__) for row in rows]
+        for m in models:
+            m.__dict__.pop("_sa_instance_state", None)
+        return models

saas_common_lib_473815-0.1/entity/invoice_entity.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey, ARRAY
+from sqlalchemy.orm import declarative_base
+import datetime
+
+Base = declarative_base()
+
+# Invoice Table
+class Invoice(Base):
+    __tablename__ = "Invoice"
+
+    id = Column(Integer, primary_key=True)
+    clientId = Column(String, nullable=True)
+    invoiceId = Column(String, nullable=True)
+    orderId = Column(String, nullable=True)
+    orderItemId = Column(String, nullable=True)
+    itemDescription = Column(String, nullable=True)
+    quantity = Column(Integer, nullable=True)
+    price = Column(Float, nullable=True)
+    cst = Column(Float, nullable=True)
+    gst = Column(Float, nullable=True)

saas_common_lib_473815-0.1/entity/order_entity.py

@@ -0,0 +1,102 @@
+from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey, ARRAY
+from sqlalchemy.orm import declarative_base, relationship
+import datetime
+from models.order_model import OrderItemModel, DineinOrderModel
+Base = declarative_base()
+
+
+# DineinOrders Table
+class DineinOrder(Base):
+    __tablename__ = "dinein_order"
+
+    id = Column(Integer, primary_key=True)
+    client_id = Column(String, nullable=True)
+    dinein_order_id = Column(String, nullable=True)
+    table_id = Column(Integer, nullable=True)
+    invoice_id = Column(String, nullable=True)
+    handler_id = Column(String, nullable=True)
+    invoice_status = Column(String, nullable=True)
+    price = Column(Float, nullable=True)
+    cst = Column(Float, nullable=True)
+    gst = Column(Float, nullable=True)
+    discount = Column(Float, nullable=True)
+    total_price = Column(Float, nullable=True)
+    created_by = Column(String, nullable=True)
+    updated_by = Column(String, nullable=True)
+    created_at = Column(DateTime, default=datetime.datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.datetime.utcnow,
+                        onupdate=datetime.datetime.utcnow)
+    status = Column(String, nullable=True)
+    items = relationship("OrderItem", backref="order",
+                         cascade="all, delete-orphan")
+
+    @staticmethod
+    def copyToModel(dineinOrder):
+        """Convert SQLAlchemy DineinOrders entities into Pydantic models."""
+        dineinOrderModel = DineinOrderModel(**dineinOrder.__dict__)
+        dineinOrderModel.__dict__.pop("_sa_instance_state", None)
+        return dineinOrderModel
+
+    @staticmethod
+    def copyFromModel(dineinOrderModel):
+        """Convert Pydantic DineinOrders models into SQLAlchemy entities."""
+        return DineinOrder(**dineinOrderModel.dict(exclude_unset=True))
+
+    @staticmethod
+    def copyToModels(dinein_orders):
+        """Convert SQLAlchemy DineinOrders entities into Pydantic models."""
+        dineinOrdersModels = [DineinOrderModel(
+            **order.__dict__) for order in dinein_orders]
+
+        # Remove SQLAlchemy metadata (_sa_instance_state)
+        for model in dineinOrdersModels:
+            model.__dict__.pop("_sa_instance_state", None)
+
+        return dineinOrdersModels
+
+    @staticmethod
+    def copyFromModels(dinein_orders_models):
+        """Convert Pydantic DineinOrders models into SQLAlchemy entities."""
+        return [DineinOrder(**model.dict(exclude_unset=True)) for model in dinein_orders_models]
+
+
+# OrderItems Table
+class OrderItem(Base):
+    __tablename__ = "order_item"
+
+    id = Column(Integer, primary_key=True)
+    client_id = Column(String, nullable=True)
+    order_id = Column(Integer, ForeignKey("dinein_order.id"))
+    item_id = Column(Integer, nullable=True)
+    item_name = Column(String, nullable=True)
+    slug = Column(String, nullable=True)
+    quantity = Column(Integer, nullable=True)
+    unit_price = Column(Float, nullable=True)   
+    line_total = Column(Float, nullable=True)   
+    status = Column(String, nullable=True)
+
+    @staticmethod
+    def copyToModel(orderItem):
+        """Convert SQLAlchemy OrderItems entities into Pydantic models."""
+        orderItemModel = OrderItemModel(**orderItem.__dict__)
+        orderItemModel.__dict__.pop("_sa_instance_state", None)
+        return orderItemModel
+
+    @staticmethod
+    def copyFromModel(orderItemModel):
+        """Convert Pydantic OrderItems models into SQLAlchemy entities."""
+        return OrderItem(**orderItemModel.dict(exclude_unset=True))
+
+    @staticmethod
+    def copyToModels(order_items):
+        """Convert SQLAlchemy OrderItems entities into Pydantic models."""
+        orderItemModels = [OrderItemModel(**item.__dict__)
+                           for item in order_items]
+        for model in orderItemModels:
+            model.__dict__.pop("_sa_instance_state", None)
+        return orderItemModels
+
+    @staticmethod
+    def copyFromModels(order_item_models):
+        """Convert Pydantic OrderItems models into SQLAlchemy entities."""
+        return [OrderItem(**model.dict(exclude_unset=True)) for model in order_item_models]

saas_common_lib_473815-0.1/entity/table_entity.py

@@ -0,0 +1,40 @@
+from sqlalchemy import Column, Integer, BigInteger, Boolean, Text, DateTime, func, UniqueConstraint, Identity
+from sqlalchemy.dialects.postgresql import UUID
+import uuid
+from database.base import Base
+from models.table_model import Table
+
+
+class DiningTable(Base):
+    __tablename__ = "tables"
+
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    client_id = Column(Text, nullable=False)
+    name = Column(Text, nullable=False)
+    table_type = Column(Text)
+    slug = Column(Text, unique=True, nullable=True)
+    qr_code_url = Column(Text, nullable=True)
+    description = Column(Text, nullable=True)
+    status = Column(Text, nullable=True, default="Vacant")
+    section = Column(Text, nullable=True)
+    location_zone = Column(Text, nullable=True)
+    sort_order = Column(Integer, nullable=True)
+    is_active = Column(Boolean, nullable=False, default=True)
+    created_by = Column(Text, nullable=True)
+    updated_by = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+    @staticmethod
+    def copyToModel(table):
+        model = Table(**table.__dict__)
+        model.__dict__.pop("_sa_instance_state", None)
+        return model
+
+    @staticmethod
+    def copyToModels(tables):
+        models = [Table(**table.__dict__) for table in tables]
+        for m in models:
+            m.__dict__.pop("_sa_instance_state", None)
+        return models

saas_common_lib_473815-0.1/entity/user_entity.py

@@ -0,0 +1,132 @@
+import uuid
+from database.postgres import Base
+from sqlalchemy import Column , Integer, String, ARRAY, UUID, event, Date,TIMESTAMP,func
+from models.user_model import UserModel, PageDefinitionModel,PersonModel
+
+
+
+class Person(Base):
+    __tablename__ = "person"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    first_name = Column(String, index=True, nullable=False)
+    last_name = Column(String, nullable=True)
+    dob = Column(Date, nullable=True)
+    email = Column(String, nullable=True)
+    phone = Column(String, nullable=True)
+    created_at = Column(TIMESTAMP, server_default=func.now())
+    updated_at = Column(
+        TIMESTAMP, server_default=func.now(), onupdate=func.now())
+
+
+    def generate_uuid(first_name: str, client_id: str) -> uuid.UUID:
+        namespace = uuid.UUID("6ba7b810-9dad-11d1-80b4-00c04fd430c8")  # DNS namespace
+        combined_key = f"{username}-{client_id}"
+        return uuid.uuid5(namespace, combined_key)
+    @staticmethod
+    def copyToModel(person):
+        personModel = PersonModel(**person.__dict__)
+        personModel.__dict__.pop("_sa_instance_state", None)
+        return personModel
+
+    @staticmethod
+    def copyFromModel(personModel):
+        """Convert a single Pydantic DineinOrders model into a SQLAlchemy entity."""
+        return Person(**personModel.dict(exclude_unset=True))
+
+
+class User(Base):
+    __tablename__ = "user"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    username = Column(String, index=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
+    client_id = Column(String, nullable=False)
+    roles = Column(ARRAY(String), default=[])
+    grants = Column(ARRAY(String), default=[])
+
+
+    def generate_uuid(username: str, client_id: str) -> uuid.UUID:
+        namespace = uuid.UUID("6ba7b810-9dad-11d1-80b4-00c04fd430c8")  # DNS namespace
+        combined_key = f"{username}-{client_id}"
+        return uuid.uuid5(namespace, combined_key)
+
+
+    @staticmethod
+    def copyToModel(user):
+        """Convert SQLAlchemy User entities into Pydantic User models."""
+        userModel = UserModel(**user.__dict__)
+        userModel.__dict__.pop("_sa_instance_state", None)
+        return userModel
+
+    @staticmethod
+    def copyFromModel(userModel):
+        """Convert a single Pydantic DineinOrders model into a SQLAlchemy entity."""
+        return User(**userModel.dict(exclude_unset=True))
+
+
+    @staticmethod
+    def copyToModels(users):
+        """Convert SQLAlchemy User entities into Pydantic User models."""
+        userModels = [UserModel(**user.__dict__) for user in users]
+
+        # Remove SQLAlchemy metadata (_sa_instance_state)
+        for model in userModels:
+            model.__dict__.pop("_sa_instance_state", None)
+
+        return userModels
+
+    @staticmethod
+    def copyFromModels(userModels):
+        """Convert Pydantic User models into SQLAlchemy User entities."""
+        return [User(**model.dict(exclude_unset=True)) for model in userModels]
+
+
+
+@event.listens_for(User, "before_insert")
+def set_uuid(mapper, connection, target):
+    if not target.id and target.username and target.client_id:
+        target.id = User.generate_uuid(target.username, target.client_id)
+
+
+class PageDefinition(Base):
+    __tablename__ = "page_definition"
+    id = Column (Integer, primary_key=True, index=True)
+    client_id = Column(String)
+    role = Column(String)
+    module = Column(String)
+    operations = Column(ARRAY(String))
+    screen_id = Column(String)
+    load_type = Column(String)
+
+    @staticmethod
+    def copyToModels(page_definitions):
+        """Convert SQLAlchemy PageDefinition entities into Pydantic models, removing metadata."""
+        pageDefinitionModels = [PageDefinitionModel(**page_def.__dict__) for page_def in page_definitions]
+
+        # Remove SQLAlchemy metadata (_sa_instance_state)
+        for model in pageDefinitionModels:
+            model.__dict__.pop("_sa_instance_state", None)
+
+        return pageDefinitionModels
+
+    @staticmethod
+    def copyFromModels(page_models):
+        """Convert Pydantic PageDefinition models into SQLAlchemy entities."""
+        page_definitions = [
+            PageDefinition(**model.dict(exclude_unset=True)) for model in page_models
+        ]
+        return page_definitions
+
+class Notification(Base):
+    __tablename__ = "notifications"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    client_id = Column(String, nullable=False)
+    template_name = Column(String, nullable=True)
+    template_body = Column(String, nullable=True)
+    type = Column(String, nullable=True)
+    realm = Column(String, nullable=True)
+    is_read = Column(String, nullable=True)
+    created_at = Column(TIMESTAMP, server_default=func.now())
+    updated_at = Column(
+        TIMESTAMP, server_default=func.now(), onupdate=func.now())    
+