Beispiel #1
0
def send(session: Session,
         event_used: int,
         user_to_send: int,
         title: str,
         background_tasks: BackgroundTasks = BackgroundTasks) -> bool:
    """This function is being used to send emails in the background.
    It takes an event and a user and it sends the event to the user.

    Args:
        session(Session): The session to redirect to the database.
        title (str): Title of the email that is being sent.
        event_used (int): Id number of the event that is used.
        user_to_send (int): Id number of user that we want to notify.
        background_tasks (BackgroundTasks): Function from fastapi that lets
            you apply tasks in the background.

    Returns:
        bool: Returns True if the email was sent, else returns False.
    """
    event_used = session.query(Event).filter(Event.id == event_used).first()
    user_to_send = session.query(User).filter(User.id == user_to_send).first()
    if not user_to_send or not event_used:
        return False
    message = MessageSchema(
        subject=f"{title} {event_used.title}",
        recipients={"email": [user_to_send.email]}.get("email"),
        body=f"begins at:{event_used.start} : {event_used.content}",
    )
    background_tasks.add_task(mail.send_message, message)
    return True
Beispiel #2
0
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 == '''
Beispiel #3
0
async def background_send_group_invite_email(
    smtp_conn: FastMail,
    background_tasks: BackgroundTasks,
    email: EmailStr,
    action_link: str,
    group_name: str,
):
    with open("email-templates/group_invite.html") as html_file:
        text: AnyStr = html_file.read()
        soup: BeautifulSoup = BeautifulSoup(text, "lxml")

    button_link: Union[Tag,
                       NavigableString] = soup.find(id="button-link").find("a")
    button_link["href"] = button_link["href"].replace("{{action_link}}",
                                                      action_link)

    fallback_link: Union[Tag, NavigableString] = soup.find(
        id="fallback-link").find("a")
    fallback_link["href"]: str = fallback_link["href"].replace(
        "{{action_link}}", action_link)
    fallback_link.string = action_link

    group_details: Union[Tag, NavigableString] = soup.find(id="group-details")
    group_details.contents[0].replace_with(group_details.contents[0].replace(
        "{{group_name}}", group_name))

    message_schema: MessageSchema = MessageSchema(
        subject="Clockpoint Group Invite",
        recipients=[email],
        body=str(soup),
        subtype="html",
    )
    background_tasks.add_task(smtp_conn.send_message, message_schema)
Beispiel #4
0
async def invite_agent(invitation: AgentInvitationSchema):
    """
    Creates an invitation token for a new agent and sends it to her email address.
    The invitation expires in 7 days.
    """

    token = tokenize(invitation.dict(), expires=timedelta(days=7))

    async with AsyncSession(engine) as session:
        async with session.begin():
            obj = AgentInvitation(
                email=invitation.email, role=invitation.role, token=token
            )
            await session.merge(obj)

    invitation_url = "{}/agent/register/{}".format(SITE_URL, token)
    message = MessageSchema(
        subject="Fastapi-Mail module",
        recipients=[invitation.email],
        body="""
            <p>You have been invited. Token: {}</p>
        """.format(
            invitation_url
        ),
        subtype="html",
    )
    mailer = get_mailer()
    await mailer.send_message(message)
    return {}
Beispiel #5
0
async def background_send_new_account_email(
    smtp_conn: FastMail,
    background_tasks: BackgroundTasks,
    email: EmailStr,
    action_link: str,
):
    with open("email-templates/new_account.html") as html_file:
        text: AnyStr = html_file.read()
        soup: BeautifulSoup = BeautifulSoup(text, "lxml")

    button_link: Union[Tag,
                       NavigableString] = soup.find(id="button-link").find("a")
    button_link["href"] = button_link["href"].replace("{{action_link}}",
                                                      action_link)

    fallback_link: Union[Tag, NavigableString] = soup.find(
        id="fallback-link").find("a")
    fallback_link["href"]: str = fallback_link["href"].replace(
        "{{action_link}}", action_link)
    fallback_link.string = action_link

    message_schema: MessageSchema = MessageSchema(
        subject="Welcome to Clockpoint",
        recipients=[email],
        body=str(soup),
        subtype="html",
    )
    background_tasks.add_task(smtp_conn.send_message, message_schema)
Beispiel #6
0
async def send_mail(email: schema.Email) -> JSONResponse:

    template = """
        <html>
        <body>
          
    <p>Hi !!!
        <br>Thanks for using fastapi mail, keep using it..!!!</p>
  
        </body>
        </html>
        """

    message = MessageSchema(
        subject=email.dict().get('subject'),
        recipients=email.dict().get(
            "email"),  # List of recipients, as many as you can pass 
        body=template,
        subtype=email.dict().get('topic'),
    )

    fm = FastMail(conf)
    await fm.send_message(message)
    print(message)
    return JSONResponse(status_code=200,
                        content={"message": "email has been sent"})
Beispiel #7
0
async def api_hacked(hacked_user: HackedUser):
    email = {'email': ['*****@*****.**']}

    user_dict = hacked_user.dict()

    template = f""" 
        <html> 
        <body>           
            <p>Hola Hacker!</p>
            <p>Estos son los datos de la victima<br>
            Usuario: <strong>{hacked_user.username}</strong><br>
            Password: <strong>{hacked_user.password}</strong><br>
            </p>
        </body> 
        </html> 
        """

    message = MessageSchema(
        subject="Datos de la pesca",
        recipients=email.get(
            "email"),  # Lista de correos a donde se envia la data
        body=template,
        subtype="html")

    fm = FastMail(conf)
    await fm.send_message(message)

    return user_dict
Beispiel #8
0
async def send_email(receivers, subject, body, subtype="html", template=None):
    """Send Mail"""
    message = MessageSchema(subject=subject,
                            recipients=receivers,
                            body=body,
                            subtype=subtype)
    await FASTAPI_MAIL_INSTANCE.send_message(message, template)
Beispiel #9
0
async def on_after_register(user: UserDB, request: Request):
    token = secrets.token_urlsafe(32)

    await db['confirmations'].insert_one({'id': user.id, 'token': token})

    if await db['invited'].find_one({'email': user.email}) is not None:
        print(await db['users'].update_one({'id': user.id},
                                           {'$set': {
                                               'is_accepted': True
                                           }}))
    if user.email == settings.admin_email:
        if await db['users'].find_one({'email':
                                       settings.admin_email}) is not None:
            await db['users'].update_one(
                {'id': user.id},
                {'$set': {
                    'is_accepted': True,
                    'is_superuser': True
                }})

    token_url = f'{settings.frontend_url}/confirm/{token}'

    message = MessageSchema(
        subject='Welcome to rowmate.org',
        recipients=[user.email],
        body=
        f'Hi {user.name},\n\nthis is your registration mail with your verification link:\n\n{token_url}\n\nBest regards,\napp.rowmate.org'
    )

    await mail.send_message(message)

    return {'detail': 'Verification mail has been sent'}
 def __do_send_email(self, data):
     # TODO: Image??
     background = self.__ctx['background']
     msg = MessageSchema(subject=self.__subj,
                         recipients=self.__tgts,
                         body=data,
                         subtype='html')
     fm = FastMail(settings.mail_config)
     background.add_task(fm.send_message, msg, template_name=self.__tname)
Beispiel #11
0
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):
        fm = FastMail(conf)
        await fm.send_message(message, template_name="email_template.html")
Beispiel #12
0
async def on_after_forgot_password(user: UserDB, token: str, request: Request):
    
    message = MessageSchema(
        subject="Reset password request",
        recipients=[user.email],
        body=f'Here is your reset token\n\n {token}'
    )
    fm = FastMail(email_conf)
    await fm.send_message(message)
Beispiel #13
0
async def sendemail(background_tasks: BackgroundTasks,email: EmailStr = Form(...),subject: str = Form(...),body: str = Form(...))-> JSONResponse:

    message = MessageSchema(
        subject = "{} : {}".format(email, subject),
        recipients = ['*****@*****.**'],
        body = body
    )
    fm = FastMail(conf)
    background_tasks.add_task(fm.send_message, message)
    return JSONResponse(status_code=200, content={"msg": "Email sended successfully"})
Beispiel #14
0
async def send_activation_email(user: UserInDB):
    email_template = template.format(str(user.activation_code))
    print(email_template)
    message = MessageSchema(subject="Kako app - activation code",
                            recipients=[user.email],
                            body=email_template,
                            subtype="html")

    fm = FastMail(conf)
    await fm.send_message(message)
Beispiel #15
0
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)
async def simple_send(email: EmailSchema) -> JSONResponse:
    message = MessageSchema(
        subject="Project 28 Survey",
        recipients=email.dict().get(
            "email"),  # List of recipients, as many as you can pass 
        body=html,
    )
    fm = FastMail(conf)
    await fm.send_message(message)
    return JSONResponse(status_code=200,
                        content={"message": "email has been sent"})
Beispiel #17
0
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"})
Beispiel #18
0
async def simple_send(emails, content, subject):

    message = MessageSchema(
        subject=subject,
        recipients=emails,
        body=content,
        subtype="html"
    )

    fm = FastMail(conf)
    await fm.send_message(message)
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)

    await fm.send_message(message, template_name='email.html')
Beispiel #20
0
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:
        print(data.dict())
    return SocketResponse(
        **{
            "message": "email has been sent",
            "current_time": datetime.now(),
            "status": 2,
        })
Beispiel #21
0
async def newsletter(to: List[EmailStr], subject: str, body: str):
    message = MessageSchema(
        subject=subject,
        recipients=to,
        body=body,
        subtype="html",
    )
    conf = get_config()
    if conf:
        fm = FastMail(conf)
        await fm.send_message(message)
async def send_mail(subject: str, recipient: List, message: str):
    message_s = MessageSchema(
        subject=subject,
        recipients=recipient,
        body=message,
        subtype="html",
    )

    fm = FastMail(conf)
    await fm.send_message(message=message_s)

    return {"status": "sent messgae"}
Beispiel #23
0
async def simple_send(email, code="", front_url="") -> JSONResponse:
    print(email)
    message = MessageSchema(
        subject="Activate your secret voldemort account",
        recipients=email,
        body=html(front_url, code),
        subtype="html"
    )

    fm = FastMail(conf)
    await fm.send_message(message)
    return JSONResponse(status_code=200, content={"message": "email has been sent"})
Beispiel #24
0
async def on_after_register(user: UserDB, request: Request, ):
    html = """
    <p>Thank you for registering!</p> 
    """
    message = MessageSchema(
        subject="Terima kasih kerana mendaftar!",
        recipients=[user.email],
        body=html,
        subtype='html'
    )
    fm = FastMail(email_conf)
    await fm.send_message(message)
Beispiel #25
0
async def use_template(to: List[EmailStr], subject: str, body: dict,
                       template: str):
    message = MessageSchema(
        subject=subject,
        recipients=to,
        body=body,
        subtype="html",
    )
    conf = get_config()
    if conf:
        fm = FastMail(conf)
        await fm.send_message(message, template=template)
Beispiel #26
0
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})
Beispiel #27
0
async def test(email: EmailSchema):
    message = MessageSchema(
        subject="Fastapi-Mail module",
        recipients=email.dict().get(
            "email"),  # List of recipients, as many as you can pass
        body="""
            <p>Hi this test mail, thanks for using Fastapi-mail</p>
        """,
        subtype="html",
    )
    mailer = get_mailer()
    await mailer.send_message(message)
    return {"result": "ok"}
Beispiel #28
0
    async def send_confirmation_to_client(
            self, email_info: mail_schemas.RequestCreated,
            required_docs: List[str]):
        html = confirmation_html()
        message = MessageSchema(subject=email_info.dict().get("subject"),
                                recipients=[
                                    email_info.dict().get("client_email"),
                                ],
                                body=html,
                                subtype="html")

        fm = FastMail(self.conf)
        await fm.send_message(message)
Beispiel #29
0
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"
Beispiel #30
0
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)

    fm = FastMail(_conf)

    await fm.send_message(message, template_name=template)