@bernierllc/email 1.0.0

package/packages/python/email_template_manager/core/manager.py

@@ -0,0 +1,344 @@
+"""
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+"""
+
+"""
+Core email template manager implementation
+"""
+
+import logging
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from jinja2 import BaseLoader, Environment, TemplateError
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    Column,
+    DateTime,
+    Integer,
+    String,
+    Text,
+    create_engine,
+)
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.sql import func
+
+from ..exceptions import DatabaseError, TemplateNotFoundError, ValidationError
+from ..models.template import (
+    EmailTemplate,
+    RenderedTemplate,
+    TemplateFilters,
+    TemplateVariable,
+    ValidationResult,
+)
+
+logger = logging.getLogger(__name__)
+
+Base = declarative_base()
+
+
+class EmailTemplateModel(Base):
+    """SQLAlchemy model for email templates"""
+
+    __tablename__ = "email_templates"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    name = Column(String, nullable=False)
+    subject = Column(String, nullable=False)
+    html_body = Column(Text, nullable=False)
+    text_body = Column(Text, nullable=False)
+    variables = Column(JSON, default=[])
+    category_id = Column(String, nullable=True)
+    tags = Column(JSON, default=[])
+    is_active = Column(Boolean, default=True)
+    version = Column(Integer, default=1)
+    created_at = Column(DateTime, server_default=func.now())
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+    created_by = Column(String, nullable=True)
+    template_metadata = Column(JSON, default={})
+
+
+class EmailTemplateManager:
+    """Manages email templates with database persistence"""
+
+    def __init__(self, database_url: str, echo: bool = False):
+        """Initialize template manager with database connection"""
+        self.engine = create_engine(database_url, echo=echo)
+        Base.metadata.create_all(self.engine)
+        self.SessionLocal = sessionmaker(bind=self.engine)
+        self.jinja_env = Environment(loader=BaseLoader())
+
+    def get_session(self) -> Session:
+        """Get database session"""
+        return self.SessionLocal()
+
+    async def create_template(self, template: EmailTemplate) -> EmailTemplate:
+        """Create a new email template"""
+        try:
+            with self.get_session() as session:
+                # Validate template
+                validation_result = self.validate_template_variables(template, {})
+                if not validation_result.is_valid:
+                    raise ValidationError(
+                        "Template validation failed", validation_result.errors
+                    )
+
+                # Create model instance
+                template_model = EmailTemplateModel(
+                    id=template.id or str(uuid.uuid4()),
+                    name=template.name,
+                    subject=template.subject,
+                    html_body=template.html_body,
+                    text_body=template.text_body,
+                    variables=[var.dict() for var in template.variables],
+                    category_id=template.category_id,
+                    tags=template.tags,
+                    is_active=template.is_active,
+                    version=template.version,
+                    created_by=template.created_by,
+                    template_metadata=template.metadata,
+                )
+
+                session.add(template_model)
+                session.commit()
+                session.refresh(template_model)
+
+                return self._model_to_template(template_model)
+
+        except Exception as e:
+            logger.error(f"Failed to create template: {str(e)}")
+            raise DatabaseError(f"Failed to create template: {str(e)}")
+
+    async def get_template(self, template_id: str) -> Optional[EmailTemplate]:
+        """Get template by ID"""
+        try:
+            with self.get_session() as session:
+                template_model = (
+                    session.query(EmailTemplateModel)
+                    .filter(EmailTemplateModel.id == template_id)
+                    .first()
+                )
+
+                if not template_model:
+                    return None
+
+                return self._model_to_template(template_model)
+
+        except Exception as e:
+            logger.error(f"Failed to get template {template_id}: {str(e)}")
+            raise DatabaseError(f"Failed to get template: {str(e)}")
+
+    async def update_template(
+        self, template_id: str, updates: Dict[str, Any]
+    ) -> EmailTemplate:
+        """Update existing template"""
+        try:
+            with self.get_session() as session:
+                template_model = (
+                    session.query(EmailTemplateModel)
+                    .filter(EmailTemplateModel.id == template_id)
+                    .first()
+                )
+
+                if not template_model:
+                    raise TemplateNotFoundError(f"Template {template_id} not found")
+
+                # Update fields
+                for key, value in updates.items():
+                    if hasattr(template_model, key):
+                        setattr(template_model, key, value)
+
+                template_model.updated_at = datetime.utcnow()
+                session.commit()
+                session.refresh(template_model)
+
+                return self._model_to_template(template_model)
+
+        except TemplateNotFoundError:
+            raise
+        except Exception as e:
+            logger.error(f"Failed to update template {template_id}: {str(e)}")
+            raise DatabaseError(f"Failed to update template: {str(e)}")
+
+    async def delete_template(self, template_id: str) -> bool:
+        """Delete template"""
+        try:
+            with self.get_session() as session:
+                template_model = (
+                    session.query(EmailTemplateModel)
+                    .filter(EmailTemplateModel.id == template_id)
+                    .first()
+                )
+
+                if not template_model:
+                    raise TemplateNotFoundError(f"Template {template_id} not found")
+
+                session.delete(template_model)
+                session.commit()
+                return True
+
+        except TemplateNotFoundError:
+            raise
+        except Exception as e:
+            logger.error(f"Failed to delete template {template_id}: {str(e)}")
+            raise DatabaseError(f"Failed to delete template: {str(e)}")
+
+    async def list_templates(
+        self, filters: Optional[TemplateFilters] = None, skip: int = 0, limit: int = 100
+    ) -> List[EmailTemplate]:
+        """List templates with optional filtering"""
+        try:
+            with self.get_session() as session:
+                query = session.query(EmailTemplateModel)
+
+                # Apply filters
+                if filters:
+                    if filters.category_id:
+                        query = query.filter(
+                            EmailTemplateModel.category_id == filters.category_id
+                        )
+                    if filters.is_active is not None:
+                        query = query.filter(
+                            EmailTemplateModel.is_active == filters.is_active
+                        )
+                    if filters.search:
+                        search_term = f"%{filters.search}%"
+                        query = query.filter(
+                            EmailTemplateModel.name.ilike(search_term)
+                            | EmailTemplateModel.subject.ilike(search_term)
+                        )
+                    if filters.created_by:
+                        query = query.filter(
+                            EmailTemplateModel.created_by == filters.created_by
+                        )
+
+                # Apply pagination
+                query = query.offset(skip).limit(limit)
+
+                template_models = query.all()
+                return [self._model_to_template(model) for model in template_models]
+
+        except Exception as e:
+            logger.error(f"Failed to list templates: {str(e)}")
+            raise DatabaseError(f"Failed to list templates: {str(e)}")
+
+    async def render_template(
+        self, template_id: str, variables: Dict[str, Any]
+    ) -> RenderedTemplate:
+        """Render template with variables"""
+        template = await self.get_template(template_id)
+        if not template:
+            raise TemplateNotFoundError(f"Template {template_id} not found")
+
+        # Validate variables
+        validation_result = self.validate_template_variables(template, variables)
+        if not validation_result.is_valid:
+            raise ValidationError(
+                "Variable validation failed", validation_result.errors
+            )
+
+        try:
+            # Render subject
+            subject_template = self.jinja_env.from_string(template.subject)
+            rendered_subject = subject_template.render(**variables)
+
+            # Render HTML content
+            html_template = self.jinja_env.from_string(template.html_body)
+            rendered_html = html_template.render(**variables)
+
+            # Render text content
+            text_template = self.jinja_env.from_string(template.text_body)
+            rendered_text = text_template.render(**variables)
+
+            return RenderedTemplate(
+                subject=rendered_subject,
+                html_content=rendered_html,
+                text_content=rendered_text,
+                variables=variables,
+                template_id=template_id,
+            )
+
+        except TemplateError as e:
+            logger.error(f"Template rendering failed: {str(e)}")
+            raise ValidationError(f"Template rendering failed: {str(e)}")
+
+    def validate_template_variables(
+        self, template: EmailTemplate, variables: Dict[str, Any]
+    ) -> ValidationResult:
+        """Validate template variables"""
+        errors = []
+        warnings = []
+
+        # Check required variables
+        for var in template.variables:
+            if var.required and var.name not in variables:
+                errors.append(
+                    {
+                        "field": var.name,
+                        "message": f"Required variable '{var.name}' is missing",
+                        "code": "MISSING_REQUIRED_VARIABLE",
+                    }
+                )
+
+        # Check variable types
+        for var in template.variables:
+            if var.name in variables:
+                value = variables[var.name]
+                if not self._validate_variable_type(var, value):
+                    errors.append(
+                        {
+                            "field": var.name,
+                            "message": f"Variable '{var.name}' has invalid type",
+                            "code": "INVALID_VARIABLE_TYPE",
+                            "expected_type": var.type,
+                            "actual_value": value,
+                        }
+                    )
+
+        return ValidationResult(
+            is_valid=len(errors) == 0, errors=errors, warnings=warnings
+        )
+
+    def _validate_variable_type(self, var: TemplateVariable, value: Any) -> bool:
+        """Validate variable type"""
+        if var.type == "text":
+            return isinstance(value, str)
+        elif var.type == "number":
+            return isinstance(value, (int, float))
+        elif var.type == "boolean":
+            return isinstance(value, bool)
+        elif var.type == "email":
+            return isinstance(value, str) and "@" in value
+        elif var.type == "url":
+            return isinstance(value, str) and (
+                "http://" in value or "https://" in value
+            )
+        elif var.type == "date":
+            return isinstance(value, (str, datetime))
+        return True
+
+    def _model_to_template(self, model: EmailTemplateModel) -> EmailTemplate:
+        """Convert SQLAlchemy model to Pydantic model"""
+        return EmailTemplate(
+            id=model.id,
+            name=model.name,
+            subject=model.subject,
+            html_body=model.html_body,
+            text_body=model.text_body,
+            variables=[TemplateVariable(**var) for var in model.variables],
+            category_id=model.category_id,
+            tags=model.tags,
+            is_active=model.is_active,
+            version=model.version,
+            created_at=model.created_at,
+            updated_at=model.updated_at,
+            created_by=model.created_by,
+            metadata=model.template_metadata,
+        )