@bernierllc/email 1.0.0 → 1.1.0

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

@@ -1,344 +0,0 @@
-"""
-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,
-        )