async def test_html_message_with_html(mail_config):
persons = [{
'name': 'Andrej'
}, {
'name': 'Mark'
}, {
'name': 'Thomas'
}, {
'name': 'Lucy',
}, {
'name': 'Robert'
}, {
'name': 'Dragomir'
}]
directory = os.getcwd()
html = directory + "/files"
msg = MessageSchema(subject="testing",
recipients=["*****@*****.**"],
html=persons)
conf = ConnectionConfig(**mail_config)
fm = FastMail(conf)
await fm.send_message(message=msg, template_name="email.html")
assert msg.html == '''
def __init__(self):
self.conf = ConnectionConfig(MAIL_USERNAME=settings.system_username,
MAIL_PASSWORD=settings.system_mail_pw,
MAIL_FROM=settings.system_mail,
MAIL_PORT=settings.mail_server_port,
MAIL_SERVER=settings.mail_server,
MAIL_TLS=True,
MAIL_SSL=False)
async def test_connection(mail_config):
message = MessageSchema(subject="test subject",
recipients=["*****@*****.**"],
body="test",
subtype="plain")
conf = ConnectionConfig(**mail_config)
fm = FastMail(conf)
await fm.send_message(message)
def send_email(background_tasks: BackgroundTasks, email, code,
request: Request):
"""Sends an email with a defined template containing the passcode.
Email is intialized at '/enter_recovery_email' endpoint as global.
You have to fill in here your email and password from which you want
to send the mail (GMAIL).
Parameters
----------
background_tasks : BackgroudTasks
For sending the mail in the background.
request : Request
For using JinJaTemplates as a response.
Returns
-------
template : Jinaja Template
Returns the template "after_email_sent_response.html".
"""
template = """
<html>
<body>
<p>Hi !!!
<br>Thanks for using Workeeper</p>
<p> Your passcode is : %s </p>
</body>
</html>
""" % (code)
conf = ConnectionConfig(MAIL_USERNAME='******',
MAIL_PASSWORD="******",
MAIL_PORT=587,
MAIL_SERVER="smtp.gmail.com",
MAIL_TLS=True,
MAIL_SSL=False)
message = MessageSchema(
subject="password recovery",
recipients=[email], # List of recipients, as many as you can pass
body=template,
subtype="html")
fm = FastMail(conf)
#await fm.send_message(message)
background_tasks.add_task(fm.send_message, message)
return templates.TemplateResponse("after_email_sent_response.html",
{"request": request})
async def send_email(self,
subject: str,
email: str,
recipients,
test_email: bool = False):
conf = await self.get_email_config()
if not conf:
return f"no email server configured"
decoded = self.decode(conf[0]["password"])
conf[0]["password"] = decoded[1]["password"]
conf = conf[0]
conf = ConnectionConfig(
**{
"MAIL_USERNAME": conf["username"],
"MAIL_PASSWORD": conf["password"],
"MAIL_FROM": conf["mail_from"],
"MAIL_PORT": conf["port"],
"MAIL_SERVER": conf["server"],
"MAIL_FROM_NAME": conf["mail_from_name"],
"MAIL_TLS": conf["mail_tls"],
"MAIL_SSL": conf["mail_ssl"],
})
body = f"""<p>{email}</p>"""
message = MessageSchema(
subject=f"{subject}",
recipients=recipients if isinstance(recipients, list) else
[recipients], # List of recipients, as many as you can pass
body=body,
subtype="html",
)
async def email_send():
try:
return await fm.send_message(message)
except Exception as e:
self.log.exception("Error sending email")
return f"Error Sending Email - {repr(e)}"
fm = FastMail(conf)
if not test_email:
asyncio.create_task(email_send())
else:
result = await email_send()
return {"message": "email sent"}
class EmailSchema(BaseModel):
emails: List[EmailStr]
try:
conf = ConnectionConfig(MAIL_USERNAME=MAIL_USERNAME,
MAIL_PASSWORD=MAIL_PASSWORD,
MAIL_FROM=MAIL_SENDER_ADDRESS,
MAIL_PORT=MAIL_PORT,
MAIL_SERVER=MAIL_SERVER,
MAIL_TLS=MAIL_TLS,
MAIL_SSL=MAIL_SSL,
USE_CREDENTIALS=True)
except Exception as e:
warnings.warn(f"Error while trying to config email schema:{e}")
async def connect_to_smtp():
logging.info("FastMail: Start Connection...")
smtp.client = FastMail(
ConnectionConfig(
MAIL_USERNAME=settings.MAIL_USERNAME,
MAIL_PASSWORD=settings.MAIL_PASSWORD,
MAIL_FROM=settings.MAIL_FROM,
MAIL_PORT=settings.MAIL_PORT,
MAIL_SERVER=settings.MAIL_SERVER,
MAIL_TLS=settings.MAIL_TLS,
MAIL_SSL=settings.MAIL_SSL,
USE_CREDENTIALS=settings.MAIL_USE_CREDENTIALS,
))
logging.info("FastMail: Connection Successful!")
async def test_html_message(mail_config):
directory = os.getcwd()
html = directory + "/files"
msg = MessageSchema(subject="testing",
recipients=["*****@*****.**"],
body="html test")
conf = ConnectionConfig(**mail_config)
fm = FastMail(conf)
await fm.send_message(message=msg, template_name="test.html")
assert msg.subtype == "html"
def get_config():
current_config = data.get_campaign_config_default()
if not current_config:
return False
return ConnectionConfig(
MAIL_USERNAME=current_config["MAIL_USERNAME"],
MAIL_PASSWORD=current_config["MAIL_PASSWORD"],
MAIL_FROM=current_config["MAIL_FROM"],
MAIL_PORT=current_config["MAIL_PORT"],
MAIL_SERVER=current_config["MAIL_SERVER"],
MAIL_FROM_NAME=current_config["MAIL_FROM_NAME"],
MAIL_TLS=current_config["MAIL_TLS"],
MAIL_SSL=current_config["MAIL_SSL"],
USE_CREDENTIALS=current_config["USE_CREDENTIALS"],
TEMPLATE_FOLDER="./api/templates",
)
async def test_send_msg(mail_config):
msg = MessageSchema(subject="testing",
recipients=["*****@*****.**"],
body="html test")
sender = f"{mail_config['MAIL_FROM_NAME']} <{mail_config['MAIL_FROM']}>"
conf = ConnectionConfig(**mail_config)
fm = FastMail(conf)
fm.config.SUPPRESS_SEND = 1
with fm.record_messages() as outbox:
await fm.send_message(message=msg, template_name="test.html")
assert len(outbox) == 1
assert outbox[0]["subject"] == "testing"
assert outbox[0]["from"] == sender
assert outbox[0]["To"] == "*****@*****.**"
async def test_html_message_with_html(mail_config):
persons = [
{"name": "Andrej"},
{"name": "Mark"},
{"name": "Thomas"},
{"name": "Lucy", },
{"name": "Robert"},
{"name": "Dragomir"}
]
directory = os.getcwd()
html = directory + "/files"
msg = MessageSchema(subject="testing",
recipients=["*****@*****.**"],
html=persons)
conf = ConnectionConfig(**mail_config)
fm = FastMail(conf)
await fm.send_message(message=msg, template_name="email.html")
assert msg.html == """
class Settings(BaseSettings):
app_name: str = "DACoT API"
mongo_uri: str
mail_user: str
mail_pass: str
mail_config: ConnectionConfig = None
mail_extra_targets: List[str] = list()
authjwt_secret_key: str
apikey_users_file: str = '/app/fake_users.json'
settings = Settings()
if settings.mail_user and settings.mail_pass:
settings.mail_config = ConnectionConfig(
MAIL_USERNAME=settings.mail_user,
MAIL_PASSWORD=settings.mail_pass,
MAIL_PORT=587,
MAIL_FROM='*****@*****.**',
MAIL_SERVER='smtp.gmail.com',
MAIL_TLS=True,
MAIL_SSL=False,
USE_CREDENTIALS=True,
TEMPLATE_FOLDER='/app/email_templates/')
@lru_cache()
def get_settings():
return settings
from fastapi import BackgroundTasks
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
from pydantic import EmailStr
from config import MailSettings
from os import path
_conf = ConnectionConfig(MAIL_USERNAME=MailSettings.MAIL_USERNAME,
MAIL_PASSWORD=MailSettings.MAIL_PASSWORD,
MAIL_SERVER=MailSettings.MAIL_SERVER,
MAIL_PORT=MailSettings.MAIL_PORT,
MAIL_TLS=MailSettings.MAIL_TLS,
MAIL_SSL=MailSettings.MAIL_SSL,
MAIL_FROM=MailSettings.MAIL_FROM,
MAIL_FROM_NAME=MailSettings.MAIL_NICENAME,
USE_CREDENTIALS=True,
TEMPLATE_FOLDER=path.join(path.dirname(__file__),
'..', 'templates', 'email'))
async def send_email_async(subject: str,
recipients: list[EmailStr],
template: str,
body: dict = {},
attachments: list[dict] = []):
message = MessageSchema(subject=subject,
recipients=recipients,
template_body=body,
subtype='html',
attachments=attachments)
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
from mjml import mjml_to_html
from app.core import config, security
EMAIL_TEMPLATES = Path(__file__).parent.parent / "email_templates"
SRC_TEMPATE_LOC = EMAIL_TEMPLATES / "src"
BUILD_TEMPLATE_LOC = EMAIL_TEMPLATES / "build"
conf = ConnectionConfig(
MAIL_USERNAME=config.SMTP_USER,
MAIL_PASSWORD=config.SMTP_PASSWORD,
MAIL_FROM=config.EMAILS_FROM_EMAIL,
MAIL_PORT=1025,
MAIL_SERVER="localhost",
MAIL_FROM_NAME=config.EMAILS_FROM_NAME,
MAIL_TLS=False,
MAIL_SSL=False,
USE_CREDENTIALS=False,
VALIDATE_CERTS=False,
TEMPLATE_FOLDER=BUILD_TEMPLATE_LOC,
)
def build_email_templates():
for template_filename in os.listdir(SRC_TEMPATE_LOC):
logging.info(f"Building email template {template_filename}...")
template_name = template_filename.split(".")[0]
with (SRC_TEMPATE_LOC / template_filename).open("rb") as fp:
html_output = mjml_to_html(fp)
with (BUILD_TEMPLATE_LOC / (template_name + ".html")).open("w+") as fp:
from jose import JWTError, jwt
from datetime import datetime, timedelta
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
#from modules.topic_classification import inference
import json
#Define secret key and algorithm
SECRET_KEY = "b8f93afd6ae4f16427e475cb090a23671e6e9f00dc5fbd603c1469355f575854"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 1000
conf = ConnectionConfig(MAIL_USERNAME="******",
MAIL_PASSWORD="******",
MAIL_FROM="*****@*****.**",
MAIL_PORT=587,
MAIL_SERVER="smtp.gmail.com",
MAIL_TLS=True,
MAIL_SSL=False)
#Load model
"""def load_model():
predictor = inference.Predictor()
return predictor
"""
#predictor = load_model()
def get_db():
db = SessionLocal()
try:
"""
Extracts the logic needed to craft a notification email.
"""
from fastapi_mail import ConnectionConfig
from backend.server.actions import job_actions, todo_actions
from datetime import datetime, timedelta
from jinja2 import Environment, FileSystemLoader
import os
# Move this to env file
email_config = ConnectionConfig(
MAIL_USERNAME="******",
MAIL_PASSWORD="******",
MAIL_FROM="*****@*****.**",
MAIL_PORT=587,
MAIL_SERVER="smtp.gmail.com",
MAIL_FROM_NAME="Jobful App",
MAIL_TLS=True,
MAIL_SSL=False,
)
# Receives a user object, returns a template to be sent
async def build_template(user):
# Get data from DB
incomplete_todos = []
jobs = await job_actions.get_all_with_status(user.id, "0"
) # "0" is all "Added" jobs
for job in jobs:
todos = await todo_actions.get_all(job,
config.parse_args()
class Body(BaseModel):
username: str
confirm_url: AnyHttpUrl
conf = ConnectionConfig(
MAIL_USERNAME=os.getenv("MAIL_USERNAME") or config.CONFIG.mail_username,
MAIL_PASSWORD=os.getenv("MAIL_PASSWORD") or config.CONFIG.mail_password,
MAIL_FROM=os.getenv("MAIL_USERNAME") or config.CONFIG.mail_username
or "*****@*****.**",
MAIL_PORT=int(config.CONFIG.mail_port),
MAIL_SERVER=config.CONFIG.mail_server,
MAIL_FROM_NAME=config.CONFIG.mail_from,
MAIL_TLS=True,
MAIL_SSL=False,
USE_CREDENTIALS=True,
TEMPLATE_FOLDER="./api/mail",
)
async def user(to: EmailStr, body: Body):
message = MessageSchema(subject="Confirm your email address",
recipients=[to],
body=body,
subtype="html")
if (os.getenv("MAIL_USERNAME") and os.getenv("MAIL_PASSWORD")) or (
config.CONFIG.mail_username and config.CONFIG.mail_password):
import os
from datetime import datetime
from typing import List, Union
from reykjalundur.common.config import email_console
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
from .models import EmailMessage, SocketResponse
conf = ConnectionConfig(
MAIL_USERNAME=os.environ["MAIL_USER"],
MAIL_PASSWORD=os.environ["MAIL_PASSWORD"],
MAIL_FROM=os.environ["MAIL_FROM"],
MAIL_PORT=587,
MAIL_SERVER=os.environ["MAIL_SERVER"],
MAIL_TLS=True,
MAIL_SSL=False,
)
async def send_mail(message: EmailMessage) -> SocketResponse:
data = MessageSchema(
subject=message.subject,
recipients=message.recipients.dict().get("email"),
body=message.body,
subtype="html",
)
fm = FastMail(conf)
if not email_console:
await fm.send_message(data)
else:
from functools import lru_cache
from typing import List
import os
from fastapi_mail import FastMail, ConnectionConfig
from pydantic import EmailStr, BaseModel
class EmailSchema(BaseModel):
email: List[EmailStr]
conf = ConnectionConfig(
MAIL_USERNAME=os.environ["MAIL_USERNAME"],
MAIL_PASSWORD=os.environ["MAIL_PASSWORD"],
MAIL_FROM=os.environ["MAIL_FROM"],
MAIL_PORT=int(os.environ["MAIL_PORT"]),
MAIL_SERVER=os.environ["MAIL_HOSTNAME"],
MAIL_TLS=bool(os.environ["MAIL_TLS"]),
MAIL_SSL=bool(os.environ["MAIL_SSL"]),
)
mailer = FastMail(conf)
@lru_cache()
def get_mailer():
return mailer
@router.delete("/notes/{note_id}/",
response_model=Note,
status_code=status.HTTP_200_OK)
async def delete_note(note_id: int):
query = notes.delete().where(notes.c.id == note_id)
await database.execute(query)
return {
"message": "Note with id: {} deleted successfully!".format(note_id)
}
conf = ConnectionConfig(
MAIL_USERNAME="******",
MAIL_PASSWORD="******",
MAIL_FROM="*****@*****.**",
MAIL_PORT=587,
MAIL_SERVER="smtp.gmail.com",
MAIL_TLS=True,
MAIL_SSL=False,
)
template = """
<p>Your Account is registered Sucessfully </p>
"""
@router.post('/User', status_code=status.HTTP_200_OK)
async def User_Created(email: Email):
if not email.email:
raise HTTPException(status_code=status.HTTP_204_NO_CONTENT,
detail="User is not Created")
config.read("../conf/conf.ini")
PROD = eval(config['MODE']['PRODUCTION'])
INDEX = config['ES']['QUANTITIES']
mail = config['MAIL']
HOST = os.getenv('API_HOST', '0.0.0.0')
PORT = os.getenv('API_PORT', 5000)
uvicorn_logger = logging.getLogger('uvicorn')
f_logger.handlers = uvicorn_logger.handlers
f_logger.setLevel(uvicorn_logger.level)
MAIL = ConnectionConfig(MAIL_USERNAME=os.getenv('MAIL_USER', ''),
MAIL_PASSWORD=os.getenv('MAIL_KEY', ''),
MAIL_FROM="*****@*****.**",
MAIL_FROM_NAME="Science Checker",
MAIL_PORT=int(os.getenv('MAIL_PORT', 587)),
MAIL_SERVER=os.getenv('MAIL_SERVER', ''),
MAIL_TLS=True,
MAIL_SSL=False,
TEMPLATE_FOLDER=mail['TEMPLATE'])
CLASSIFIER = config['SQA']['CLASSIFIER']
PULLER = config['SQA'].get('PULLER')
EXTRACTOR = config['SQA'].get('EXTRACTOR', 'eqa')
LIST_TASK = list()
DATA_PATH = config['BASE'].get('PATH', '')
##################################################
sampler, classifier, puller = load_sqa(CLASSIFIER, PULLER, extractor=EXTRACTOR)
class Envs:
MAIL_USERNAME = os.getenv('MAIL_USERNAME')
MAIL_PASSWORD = os.getenv('MAIL_PASSWORD')
MAIL_FROM = os.getenv('MAIL_FROM')
MAIL_PORT = int(os.getenv('MAIL_PORT'))
MAIL_SERVER = os.getenv('MAIL_SERVER')
MAIL_FROM_NAME = os.getenv('MAIN_FROM_NAME')
conf = ConnectionConfig(MAIL_USERNAME=Envs.MAIL_USERNAME,
MAIL_PASSWORD=Envs.MAIL_PASSWORD,
MAIL_FROM=Envs.MAIL_FROM,
MAIL_PORT=Envs.MAIL_PORT,
MAIL_SERVER=Envs.MAIL_SERVER,
MAIL_FROM_NAME=Envs.MAIL_FROM_NAME,
MAIL_TLS=True,
MAIL_SSL=False,
USE_CREDENTIALS=True,
TEMPLATE_FOLDER='./templates/email')
async def send_email_async(subject: str, email_to: str, body: dict):
message = MessageSchema(
subject=subject,
recipients=[email_to],
body=body,
subtype='html',
)
fm = FastMail(conf)
# settings
settings = Settings()
# client
client = AsyncIOMotorClient(settings.database_url,
uuidRepresentation='standard')
# database
db = client['rowmate']
db['templates'].create_index([('ngrams', TEXT)], name='templates_ngrams_index')
db['questions'].create_index([('ngrams', TEXT)], name='questions_ngrams_index')
db['events'].create_index([('ngrams', TEXT)], name='events_ngrams_index')
user_db = MongoDBUserDatabase(UserDB, db['users'])
jwt_auth = Authentication(secret=settings.jwt_secret,
lifetime_seconds_refresh=50000,
lifetime_seconds=3600)
api_user = APIUsers(user_db, [jwt_auth], User, UserCreate, UserUpdate, UserDB)
smtp_config = ConnectionConfig(MAIL_USERNAME=settings.smtp_username,
MAIL_PASSWORD=settings.smtp_password,
MAIL_SERVER=settings.smtp_server,
MAIL_PORT=settings.smtp_port,
MAIL_TLS=settings.smtp_tls,
MAIL_SSL=settings.smtp_ssl,
MAIL_FROM=settings.smtp_username)
# initialize
mail = FastMail(smtp_config)
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
from pydantic import EmailStr, BaseModel
from fastapi_mail.email_utils import DefaultChecker
from dotenv import load_dotenv
import os
load_dotenv()
conf = ConnectionConfig(
MAIL_USERNAME=os.getenv("MAIL_USERNAME"),
MAIL_PASSWORD=os.getenv("MAIL_PASSWORD"),
MAIL_FROM=os.getenv("MAIL_FROM"),
MAIL_PORT=int(os.getenv("MAIL_PORT")),
MAIL_SERVER=os.getenv("MAIL_SERVER"),
MAIL_FROM_NAME=os.getenv("MAIL_FROM_NAME"),
MAIL_TLS=True if os.getenv("MAIL_TLS") == "True" else False,
MAIL_SSL=True if os.getenv("MAIL_SSL") == "True" else False,
)
async def simple_send(emails, content, subject):
message = MessageSchema(
subject=subject,
recipients=emails,
body=content,
subtype="html"
)
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
import logging
import os
from models import NewUserInput, ResetPasswordInput, MailOutput
logging.config.fileConfig('logging.conf', disable_existing_loggers=False)
templates = Jinja2Templates(directory='templates')
app = FastAPI()
logger = logging.getLogger('email')
conf = ConnectionConfig(MAIL_USERNAME=os.environ.get('SMTP_USERNAME'),
MAIL_PASSWORD=os.environ.get('SMTP_PASSWORD'),
MAIL_FROM='*****@*****.**',
MAIL_PORT=os.environ.get('EMAIL_PORT', '2525'),
MAIL_SERVER=os.environ.get('SMTP_SERVER'),
MAIL_TLS=True,
MAIL_SSL=False,
USE_CREDENTIALS=True)
fm = FastMail(conf)
FRONT_URL = 'http://example.com'
@app.post('/new-user/', response_model=MailOutput)
async def new_user(data: NewUserInput):
""" Send email welcoming a new user. """
logger.info(f'new_user email input received: {data}')
template = templates.get_template('new_user.html')
from typing import List
from database import app, client
from models import EmailSchema
from fastapi import APIRouter
from starlette.responses import JSONResponse
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
SURVEY_URL = 'https://www.google.com/'
conf = ConnectionConfig(MAIL_USERNAME="******",
MAIL_PASSWORD="******",
MAIL_FROM="*****@*****.**",
MAIL_PORT=587,
MAIL_SERVER="smtp.gmail.com",
MAIL_FROM_NAME="Project 28",
MAIL_TLS=True,
MAIL_SSL=False,
USE_CREDENTIALS=True,
VALIDATE_CERTS=True)
app = APIRouter()
html = f"""
Hello, this is Project 28.
We are pleased to invite you to join our survey. Below is the survey link.
{SURVEY_URL}
Thank you.
"""
db = client.email2
# Q1 Haven't put any data to database
from email.mime.text import MIMEText
from fastapi_mail import ConnectionConfig, MessageSchema, FastMail
from jinja2 import Environment, PackageLoader, select_autoescape
from app.settings import mail_setting, app_settings
conf = ConnectionConfig(MAIL_USERNAME=mail_setting.username,
MAIL_PASSWORD=mail_setting.password,
MAIL_FROM=mail_setting.from_email,
MAIL_PORT=mail_setting.port,
MAIL_SERVER=mail_setting.server,
MAIL_TLS=mail_setting.tls,
MAIL_SSL=mail_setting.ssl)
class MailHelper:
async def send_welcome_email(self, registration_data, user_email):
await self.send_email(
subject='Inscripción a II Carrera Virtual Runners Cúcuta',
html_template="",
recipents=[user_email],
template_name='welcome.html',
template_data=registration_data,
)
async def send_reset_password_email(self, recovery_password_data: dict,
user_email: str):
await self.send_email(
subject='Runners Cúcuta: Recupera tu contraseña',
html_template="",
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
from schema.user_schema import UserSchema
from models.user import User
from mongoengine.errors import NotUniqueError
from os import getenv
from dotenv import load_dotenv
load_dotenv()
router = APIRouter()
conf = ConnectionConfig(MAIL_USERNAME=getenv("GMAIL"),
MAIL_PASSWORD=getenv("PASSWORD"),
MAIL_FROM=getenv("GMAIL"),
MAIL_PORT=587,
MAIL_SERVER="smtp.gmail.com",
MAIL_TLS=True,
MAIL_SSL=False)
@router.post('/api/register')
async def register_user(background_tasks: BackgroundTasks,
payload: UserSchema) -> JSONResponse:
try:
user = User(full_name=payload.full_name, email=payload.email)
user.save()
registeredUser = UserSchema(full_name=user.full_name, email=user.email)
except NotUniqueError:
from fastapi import FastAPI, BackgroundTasks, UploadFile, File, Form
from starlette.responses import JSONResponse
from .templates import html, template, bulkmail
from .schema import EmailSchema, EmailStr
from starlette.requests import Request
from fastapi_mail import FastMail, MessageSchema, ConnectionConfig
conf = ConnectionConfig(MAIL_USERNAME="******",
MAIL_PASSWORD="******",
MAIL_PORT=587,
MAIL_SERVER="your mail server",
MAIL_TLS=True,
MAIL_SSL=False)
app = FastAPI()
#test email standart sending mail
@app.post("/email")
async def simple_send(email: EmailSchema) -> JSONResponse:
message = MessageSchema(subject="Fastapi-Mail module",
recipients=email.dict().get("email"),
body=html,
subtype="html")
fm = FastMail(conf)
await fm.send_message(message)
return JSONResponse(status_code=200,
content={"message": "email has been sent"})
JWT_HASH_ALGORITHM = "HS256"
JWT_ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 2
SECRET_KEY = os.environ.get(
"SECRET_KEY",
"09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7")
ALLOWED_ORIGINS = json.loads(os.environ.get("ALLOWED_ORIGINS", "[]"))
_EMAIL_CONF = ConnectionConfig(
MAIL_USERNAME=os.environ.get("EMAIL_USERNAME", ""),
MAIL_PASSWORD=os.environ.get("EMAIL_PASSWORD", ""),
MAIL_FROM=os.environ.get("EMAIL_FROM", "*****@*****.**"),
MAIL_PORT=int(os.environ.get("EMAIL_PORT", 0)),
MAIL_SERVER=os.environ.get("EMAIL_SERVER", ""),
MAIL_TLS=os.environ.get("EMAIL_TLS", "false") != "false",
MAIL_SSL=os.environ.get("EMAIL_SSL", "false") != "false",
USE_CREDENTIALS=True,
TEMPLATE_FOLDER="./app/emails")
FASTAPI_MAIL_INSTANCE = FastMail(_EMAIL_CONF)
TZ = "Asia/Calcutta"
assert isinstance(ALLOWED_ORIGINS, list)
def get_origin_settings():
"""Set CORS Settings According To DEBUG"""
settings = {