Email SeS implementation (#19)

## Notion ticket link
<!-- Please replace with your ticket's URL -->
[Setup Email
System](https://www.notion.so/uwblueprintexecs/Setup-Basic-Email-System-11110f3fb1dc80a48e88ce63228b926c?pvs=4)

NOTE THIS IS A PR for feedback not to merge. 
Will be removing email.py route as its simply there right now for
testing
will be removing todos and adding comments 
will be removing any prints or updating them to logs

<!-- Give a quick summary of the implementation details, provide design
justifications if necessary -->
## Implementation description
* Implemented Email sending using amazon ses.
* Create email templates at startup
* use email templates to send single and bulk emails to users with
predefined templates
* Email templates can use inline CSS need to define a text file with
only text for each respective email

Process to create a new Email Template to use:

1. Create the HTML and Text files for the new template. Use inline CSS
and direct hosted links to any images required.
2. Update `backend/app/utilities/ses/ses_templates.json` to include
template name subject and absolute paths to the above file
3. Create a new data class Type for the Email template
```python
@DataClass
class NewEmailTemplatData():
    name: str
    date: str
    random: int
 ```
4. Update Email template enum to include the file name of the template defined in amazon ses and the `ses_templates.json` file

```python
class EmailTemplate(Enum):
   NEWEMAILTEMPLATE = "newemailtemplate"
```

5. Use in code to send emails using email service
```python
email_service.send_email(
    template=EmailTemplate.NEWEMAILTEMPLATE,
    content=EmailContent[NewEmailTemplatData](
        recipient=recipient, 
data=NewEmailTemplatData(name=user_name, date="2021-12-01", random: 20)
    ),
)
```

## Todo
- [ ] Add bulk send email after general flow is good
- [ ] Look into schedule send
- [ ] Clean up logging and comments
- [ ] Remove email.py route
- [ ] Unit Testing
- [ ] File clean up


<!-- What should the reviewer do to verify your changes? Describe expected results and include screenshots when appropriate -->
## Steps to test
1. Simply hit the `/email/send-test` email route when running the be on local

<!-- Draw attention to the substantial parts of your PR or anything you'd like a second opinion on -->
## What should reviewers focus on?
* Focus on overall design of things and how things are laid out as this pr still needs to be cleaned up. 
* How templates are defined, what folders code blocks should be stored in
* Are we okay with running the email template check on startup
* Will be removing email.py route as its simply there right now for testing


## Checklist
- [x] My PR name is descriptive and in imperative tense
- [x] My commit messages are descriptive and in imperative tense. My commits are atomic and trivial commits are squashed or fixup'd into non-trivial commits
- [x] I have run the appropriate linter(s)
- [ ] I have requested a review from the PL, as well as other devs who have background knowledge on this PR or who will be building on top of this PR

Author: Mayank808

.env.sample

@@ -2,4 +2,7 @@ POSTGRES_DATABASE=
 POSTGRES_USER=
 POSTGRES_PASSWORD=
 POSTGRES_DATABASE_URL=
-
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_REGION=
+SES_EMAIL_FROM=

backend/app/interfaces/email_service.py

@@ -1,5 +1,7 @@
 from abc import ABC, abstractmethod
 
+from app.schemas.email_template import EmailContent, EmailTemplateType
+
 
 class IEmailService(ABC):
     """
@@ -8,65 +10,20 @@ class IEmailService(ABC):
     """
 
     @abstractmethod
-    def send_email(self, to: str, subject: str, body: str) -> 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
-        """
-        pass
-
-    @abstractmethod
-    def send_welcome_email(self, recipient: str, user_name: str) -> dict:
-        """
-        Sends a welcome email to the specified user.
-
-        :param recipient: Email address of the user
-        :type recipient: str
-        :param user_name: Name of the user
-        :type user_name: str
-        :return: Provider-specific metadata for the sent email
-        :rtype: dict
-        :raises Exception: if email was not sent successfully
-        """
-        pass
-
-    @abstractmethod
-    def send_password_reset_email(self, recipient: str, reset_link: str) -> dict:
-        """
-        Sends a password reset email with the provided reset link.
-
-        :param recipient: Email address of the user requesting the reset
-        :type recipient: str
-        :param reset_link: Password reset link
-        :type reset_link: str
-        :return: Provider-specific metadata for the sent email
-        :rtype: dict
-        :raises Exception: if email was not sent successfully
-        """
-        pass
-
-    @abstractmethod
-    def send_notification_email(self, recipient: str, notification_text: str) -> dict:
-        """
-        Sends a notification email to the user with the provided notification text.
-        Examples of use case include matches completed and ready to view, new messages,
-        meeting time scheduled, etc.
-
-        :param recipient: Email address of the user
-        :type recipient: str
-        :param notification_text: The notification content
-        :type notification_text: str
-        :return: Provider-specific metadata for the sent email
-        :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,5 +1,7 @@
 from abc import ABC, abstractmethod
 
+from app.schemas.email_template import EmailContent, EmailTemplateType
+
 
 class IEmailServiceProvider(ABC):
     """
@@ -9,22 +11,18 @@ class IEmailServiceProvider(ABC):
 
     @abstractmethod
     def send_email(
-        self, recipient: str, subject: str, body_html: str, body_text: str
+        self, templateType: EmailTemplateType, content: EmailContent
     ) -> dict:
-        """
-        Sends an email using the provider's service.
+        """_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/send_email.py

@@ -3,8 +3,11 @@
 from fastapi import APIRouter, Depends
 
 from app.interfaces.email_service import IEmailService
+from app.schemas.email_template import EmailContent, EmailTemplateType, MockEmailData
+from app.services.email.amazon_ses_provider import (
+    get_email_service_provider,
+)
 from app.services.email.email_service import EmailService
-from app.services.email.email_service_provider import AmazonSESEmailProvider
 
 router = APIRouter(
     prefix="/email",
@@ -13,16 +16,19 @@
 
 
 def get_email_service() -> IEmailService:
-    email_provider = AmazonSESEmailProvider(aws_access_key="", aws_secret_key="")
-    return EmailService(email_provider)
+    return EmailService(provider=get_email_service_provider())
 
 
 # TODO (Mayank, Nov 30th) - Remove test emails once email service is fully implemented
-@router.post("/send-test-email/")
+@router.post("/send-test")
 async def send_welcome_email(
     recipient: str,
     user_name: str,
     email_service: Annotated[IEmailService, Depends(get_email_service)],
 ):
-    email_service.send_welcome_email(recipient, user_name)
-    return {"message": f"Welcome email sent to {user_name}!"}
+    return email_service.send_email(
+        templateType=EmailTemplateType.TEST,
+        content=EmailContent[MockEmailData](
+            recipient=recipient, data=MockEmailData(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 MockEmailData(TemplateData):
+    name: str
+    date: str
+
+
+class EmailTemplateType(Enum):
+    TEST = "Test"
+
+
+@dataclass
+class EmailContent(Generic[EmailData]):
+    recipient: str
+    data: EmailData

backend/app/server.py

@@ -9,16 +9,17 @@
 from .routes import send_email, user
 from .utilities.constants import LOGGER_NAME
 from .utilities.firebase_init import initialize_firebase
+from .utilities.ses.ses_init import ensure_ses_templates
 
 load_dotenv()
 
-
 log = logging.getLogger(LOGGER_NAME("server"))
 
 
 @asynccontextmanager
 async def lifespan(_: FastAPI):
     log.info("Starting up...")
+    ensure_ses_templates()
     models.run_migrations()
     initialize_firebase()
     yield
@@ -29,12 +30,12 @@ async def lifespan(_: FastAPI):
 # running-alembic-migrations-on-fastapi-startup
 app = FastAPI(lifespan=lifespan)
 app.include_router(user.router)
-
 app.include_router(send_email.router)
 
 
 @app.get("/")
 def read_root():
+    log.info("Hello World")
     return {"Hello": "World"}
 
 

backend/app/services/email/amazon_ses_provider.py

@@ -0,0 +1,87 @@
+import os
+
+import boto3
+from botocore.exceptions import ClientError
+
+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,
+        aws_secret_key: str,
+        region: str,
+        source_email: str,
+        is_sandbox: bool = True,
+    ):
+        self.source_email = source_email
+        self.is_sandbox = is_sandbox
+        self.ses_client = boto3.client(
+            "ses",
+            region_name=region,
+            aws_access_key_id=aws_access_key,
+            aws_secret_access_key=aws_secret_key,
+        )
+
+        self.verified_emails = None
+        if self.is_sandbox:
+            response = self.ses_client.list_verified_email_addresses()
+            self.verified_emails = response.get("VerifiedEmailAddresses", [])
+
+    def _verify_email(self, email: str, templateType: EmailTemplateType) -> None:
+        try:
+            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, templateType: EmailTemplateType, content: EmailContent
+    ) -> dict:
+        try:
+            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=templateType.value,
+                TemplateData=template_data,
+            )
+
+            return {
+                "message": "Email sent successfully!",
+                "message_id": response["MessageId"],
+            }
+        except ClientError as e:
+            return {"error": f"An error occurred: {e.response['Error']['Message']}"}
+
+
+def get_email_service_provider() -> IEmailServiceProvider:
+    return AmazonSESEmailProvider(
+        aws_access_key=os.getenv("AWS_ACCESS_KEY"),
+        aws_secret_key=os.getenv("AWS_SECRET_KEY"),
+        region=os.getenv("AWS_REGION"),
+        source_email=os.getenv("SES_SOURCE_EMAIL"),
+    )

backend/app/services/email/email_service.py

@@ -1,20 +1,19 @@
+import logging
+
 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 send_email(self, to: str, subject: str, body: str) -> dict:
-        pass
-
-    def send_welcome_email(self, recipient: str, user_name: str) -> dict:
-        pass
-
-    def send_password_reset_email(self, recipient: str, reset_link: str) -> dict:
-        pass
-
-    def send_notification_email(self, recipient: str, notification_text: str) -> dict:
-        pass
+    def send_email(
+        self, templateType: EmailTemplateType, content: EmailContent[EmailData]
+    ) -> dict:
+        self.logger.info(
+            f"Sending email to {content.recipient} with template {templateType.value}"
+        )
+        return self.provider.send_email(templateType, content)