updated nits

Author: Mayank808

backend/app/interfaces/email_service.py

@@ -1,38 +1,6 @@
-import json
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from enum import Enum
-from typing import Generic, TypeVar
 
-T = TypeVar("T")
-
-
-class TemplateData(ABC):
-    def get_formatted_string(self) -> str:
-        class_dict = self.__dict__
-        try:
-            formatted_string = json.dumps(class_dict)  # Try to convert to a JSON string
-        except (TypeError, ValueError) as e:
-            # Handle errors and return a message instead
-            return f"Error in converting data to JSON: {e}"
-
-        return formatted_string
-
-
-@dataclass
-class TestEmailData(TemplateData):
-    name: str
-    date: str
-
-
-class EmailTemplate(Enum):
-    TEST = "Test"
-
-
-@dataclass
-class EmailContent(Generic[T]):
-    recipient: str
-    data: T
+from app.schemas.email_template import EmailContent, EmailTemplateType
 
 
 class IEmailService(ABC):
@@ -42,18 +10,20 @@ class IEmailService(ABC):
     """
 
     @abstractmethod
-    def send_email(self, template: EmailTemplate, content: EmailContent) -> dict:
-        """
-        Sends an email with the given parameters.
-
-        :param to: Recipient's email address
-        :type to: str
-        :param subject: Subject of the email
-        :type subject: str
-        :param body: HTML body content of the email
-        :type body: str
-        :return: Provider-specific metadata (like message ID, thread ID, label IDs)
-        :rtype: dict
-        :raises Exception: if email was not sent successfully
+    def send_email(
+        self, templateType: EmailTemplateType, content: EmailContent
+    ) -> dict:
+        """Send an email using the given template and content with a
+            respective service provider.
+
+        Args:
+            templateType (EmailTemplateType): Specifies the template
+                to be used for the email
+            content (EmailContent): Contains the recipient and data
+                to be used in the email
+
+        Returns:
+            dict: Provider-specific metadata if any
+                (like message ID, thread ID, label IDs)
         """
         pass

backend/app/interfaces/email_service_provider.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 
-from app.interfaces.email_service import EmailContent, EmailTemplate
+from app.schemas.email_template import EmailContent, EmailTemplateType
 
 
 class IEmailServiceProvider(ABC):
@@ -10,21 +10,19 @@ class IEmailServiceProvider(ABC):
     """
 
     @abstractmethod
-    def send_email(self, template: EmailTemplate, content: EmailContent) -> dict:
-        """
-        Sends an email using the provider's service.
+    def send_email(
+        self, templateType: EmailTemplateType, content: EmailContent
+    ) -> dict:
+        """_summary_
+
+        Args:
+            templateType (EmailTemplate): Helps provider determine which
+                template to use for the given email
+            content (EmailContent): Contains the recipient and data to be
+                used in the email
 
-        :param recipient: Email address of the recipient
-        :type recipient: str
-        :param subject: Subject of the email
-        :type subject: str
-        :param body_html: HTML body content of the email
-        :type body_html: str
-        :param body_text: Plain text content of the email
-        :type body_text: str
-        :return: Provider-specific metadata related to the sent email
-        (like message ID, status, etc.)
-        :rtype: dict
-        :raises Exception: if the email fails to send
+        Returns:
+            dict: Provider-specific metadata if any
+                (like message ID, thread ID, label IDs)
         """
         pass

backend/app/routes/email.py backend/app/routes/email_test.pybackend/app/routes/email.py renamed to backend/app/routes/email_test.py

@@ -2,16 +2,12 @@
 
 from fastapi import APIRouter, Depends
 
-from app.interfaces.email_service import (
-    EmailContent,
-    EmailTemplate,
-    IEmailService,
-    TestEmailData,
-)
-from app.services.email.email_service import EmailService
-from app.services.email.email_service_provider import (
+from app.interfaces.email_service import IEmailService
+from app.schemas.email_template import EmailContent, EmailTemplateType, TestEmailData
+from app.services.email.amazon_ses_provider import (
     get_email_service_provider,
 )
+from app.services.email.email_service import EmailService
 
 router = APIRouter(
     prefix="/email",
@@ -31,7 +27,7 @@ async def send_welcome_email(
     email_service: Annotated[IEmailService, Depends(get_email_service)],
 ):
     return email_service.send_email(
-        template=EmailTemplate.TEST,
+        templateType=EmailTemplateType.TEST,
         content=EmailContent[TestEmailData](
             recipient=recipient, data=TestEmailData(name=user_name, date="2021-12-01")
         ),

backend/app/schemas/email_template.py

@@ -0,0 +1,34 @@
+import json
+from abc import ABC
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, TypeVar
+
+EmailData = TypeVar("EmailData")
+
+
+class TemplateData(ABC):
+    def get_formatted_string(self) -> str:
+        class_dict = self.__dict__
+        try:
+            formatted_string = json.dumps(class_dict)  # Try to convert to a JSON string
+        except (TypeError, ValueError) as e:
+            raise Exception(f"Error converting class to JSON: {e}")
+
+        return formatted_string
+
+
+@dataclass
+class TestEmailData(TemplateData):
+    name: str
+    date: str
+
+
+class EmailTemplateType(Enum):
+    TEST = "Test"
+
+
+@dataclass
+class EmailContent(Generic[EmailData]):
+    recipient: str
+    data: EmailData

backend/app/server.py

@@ -5,7 +5,7 @@
 from dotenv import load_dotenv
 from fastapi import FastAPI
 
-from app.routes import email
+from app.routes import email_test
 
 load_dotenv()
 
@@ -32,7 +32,7 @@ async def lifespan(_: FastAPI):
 app = FastAPI(lifespan=lifespan)
 app.include_router(user.router)
 
-app.include_router(email.router)
+app.include_router(email_test.router)
 
 
 @app.get("/")

…services/email/email_service_provider.py …pp/services/email/amazon_ses_provider.pybackend/app/services/email/email_service_provider.py renamed to backend/app/services/email/amazon_ses_provider.py backend/app/services/email/email_service_provider.py renamed to backend/app/services/email/amazon_ses_provider.py

@@ -3,11 +3,26 @@
 import boto3
 from botocore.exceptions import ClientError
 
-from app.interfaces.email_service import EmailContent, EmailTemplate
 from app.interfaces.email_service_provider import IEmailServiceProvider
+from app.schemas.email_template import EmailContent, EmailTemplateType
 
 
 class AmazonSESEmailProvider(IEmailServiceProvider):
+    """Amazon SES Email Provider.
+
+    This class is responsible for sending emails using Amazon SES.
+    """
+
+    """
+    Args:
+        aws_access_key (str): AWS Access Key ID
+        aws_secret_key (str): AWS Secret Access Key
+        region (str): AWS region where SES is configured
+        source_email (str): Email address from which the email will be sent
+        is_sandbox (bool): If True, the amazon provider will only be able to send emails
+            to previously verified email addresses and domains
+    """
+
     def __init__(
         self,
         aws_access_key: str,
@@ -30,28 +45,28 @@ def __init__(
             response = self.ses_client.list_verified_email_addresses()
             self.verified_emails = response.get("VerifiedEmailAddresses", [])
 
-    def _verify_email(self, email: str):
-        if not self.is_sandbox:
-            return
+    def _verify_email(self, email: str, templateType: EmailTemplateType) -> None:
         try:
-            if email not in self.verified_emails:
+            if self.is_sandbox and email not in self.verified_emails:
                 self.ses_client.verify_email_identity(EmailAddress=email)
                 print(f"Verification email sent to {email}.")
+            if self.ses_client.get_template(TemplateName=templateType.value):
+                print(f"Template {templateType.value} exists.")
         except Exception as e:
             print(f"Failed to verify email: {e}")
 
-    def send_email(self, template: EmailTemplate, content: EmailContent) -> dict:
+    def send_email(
+        self, templateType: EmailTemplateType, content: EmailContent
+    ) -> dict:
         try:
-            self._verify_email(content.recipient)
-
-            self.ses_client.get_template(TemplateName=template.value)
+            self._verify_email(content.recipient, templateType)
 
             template_data = content.data.get_formatted_string()
 
             response = self.ses_client.send_templated_email(
                 Source=self.source_email,
                 Destination={"ToAddresses": [content.recipient]},
-                Template=template.value,
+                Template=templateType.value,
                 TemplateData=template_data,
             )
 

backend/app/services/email/email_service.py

@@ -1,34 +1,19 @@
 import logging
 
-from app.interfaces.email_service import EmailContent, EmailTemplate, IEmailService, T
+from app.interfaces.email_service import IEmailService
 from app.interfaces.email_service_provider import IEmailServiceProvider
+from app.schemas.email_template import EmailContent, EmailData, EmailTemplateType
 
 
-# TODO (Mayank, Nov 30th) - Implement the email service methods and use User object
 class EmailService(IEmailService):
     def __init__(self, provider: IEmailServiceProvider):
         self.provider = provider
         self.logger = logging.getLogger(__name__)
 
-    # def render_templates(self, template: EmailTemplate) -> tuple[str, str]:
-    #     html_path = self.template_dir / f"{template.value}.html"
-    #     text_path = self.template_dir / f"{template.value}.txt"
-
-    #      # Check if both files exist
-    #     if not html_path.exists():
-    #         raise FileNotFoundError(f"HTML template not found: {html_path}")
-    #     if not text_path.exists():
-    #         raise FileNotFoundError(f"Text template not found: {text_path}")
-
-    #     # Read the templates
-    #     html_template = html_path.read_text(encoding="utf-8")
-    #     text_template = text_path.read_text(encoding="utf-8")
-
-    #     return html_template, text_template
-
-    def send_email(self, template: EmailTemplate, content: EmailContent[T]) -> dict:
+    def send_email(
+        self, templateType: EmailTemplateType, content: EmailContent[EmailData]
+    ) -> dict:
         self.logger.info(
-            f"Sending email to {content.recipient} with template {template.value}"
+            f"Sending email to {content.recipient} with template {templateType.value}"
         )
-        # html_template, text_template = self.render_templates(template)
-        return self.provider.send_email(template, content)
+        return self.provider.send_email(templateType, content)

backend/app/utilities/ses/ses_init.py

@@ -38,9 +38,6 @@ def load_file_content(file_path: str) -> str:
         return ""
 
 
-templates_metadata = load_templates_metadata(TEMPLATES_FILE)
-
-
 # Function to create SES template
 def create_ses_template(template_metadata):
     name = template_metadata["TemplateName"]
@@ -68,6 +65,8 @@ def create_ses_template(template_metadata):
 
 # Ensure SES templates are available at app startup
 def ensure_ses_templates():
+    templates_metadata = load_templates_metadata(TEMPLATES_FILE)
+
     for template_metadata in templates_metadata:
         name = template_metadata["TemplateName"]
         try: