def _send_login_email(user, uri):
global _smtp
if not _smtp:
if not (pkconfig.channel_in('dev')
and cfg.smtp_server == _DEV_SMTP_SERVER):
a = sirepo.util.flask_app()
a.config.update(
MAIL_USE_TLS=True,
MAIL_PORT=587,
MAIL_SERVER=cfg.smtp_server,
MAIL_USERNAME=cfg.smtp_user,
MAIL_PASSWORD=cfg.smtp_password,
)
_smtp = flask_mail.Mail(a)
else:
pkdlog('{}', uri)
return http_reply.gen_json_ok({'uri': uri})
login_text = u'sign in to' if user.user_name else \
u'confirm your email and finish creating'
msg = flask_mail.Message(subject='Sign in to Sirepo',
sender=(cfg.from_name, cfg.from_email),
recipients=[user.unverified_email],
body=u'''
Click the link below to {} your Sirepo account.
This link will expire in {} hours and can only be used once.
{}
'''.format(login_text, _EXPIRES_MINUTES / 60, uri))
_smtp.send(msg)
return http_reply.gen_json_ok()
def api_comsolRegister():
import flask
import flask_mail
import sirepo.util
global _mail
if not _mail:
a = sirepo.util.flask_app()
a.config.update(
MAIL_USE_TLS=True,
MAIL_PORT=587,
MAIL_SERVER=cfg.mail_server,
MAIL_USERNAME=cfg.mail_username,
MAIL_PASSWORD=cfg.mail_password,
)
_mail = flask_mail.Mail(a)
req = http_request.parse_json()
msg = flask_mail.Message(
subject='Sirepo / COMSOL Registration',
sender=cfg.mail_support_email,
recipients=[cfg.mail_recipient_email],
body=u'''
Request for access to Sirepo / COMSOL.
Name: {}
Email: {}
'''.format(req.name, req.email),
)
_mail.send(msg)
return http_reply.gen_json_ok()
def init_app(self, app):
self.config = app.config
scheme = None
mailer_uri = self.config.get("MAIL_URL")
if mailer_uri:
mailer_uri = utils.urlparse(mailer_uri)
scheme = mailer_uri.scheme
hostname = mailer_uri.hostname
# Using ses-mailer
if "ses" in scheme.lower():
self.provider = "SES"
access_key = mailer_uri.username or app.config.get(
"AWS_ACCESS_KEY_ID")
secret_key = mailer_uri.password or app.config.get(
"AWS_SECRET_ACCESS_KEY")
region = hostname or self.config.get("AWS_REGION", "us-east-1")
self.mail = ses_mailer.Mail(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region=region,
sender=self.config.get("MAIL_SENDER"),
reply_to=self.config.get("MAIL_REPLY_TO"),
template=self.config.get("MAIL_TEMPLATE"),
template_context=self.config.get("MAIL_TEMPLATE_CONTEXT"))
# SMTP will use flask-mail
elif "smtp" in scheme.lower():
self.provider = "SMTP"
class _App(object):
config = {
"MAIL_SERVER": mailer_uri.hostname,
"MAIL_USERNAME": mailer_uri.username,
"MAIL_PASSWORD": mailer_uri.password,
"MAIL_PORT": mailer_uri.port,
"MAIL_USE_TLS":
True if "tls" in mailer_uri.scheme else False,
"MAIL_USE_SSL":
True if "ssl" in mailer_uri.scheme else False,
"MAIL_DEFAULT_SENDER": app.config.get("MAIL_SENDER"),
"TESTING": app.config.get("TESTING"),
"DEBUG": app.config.get("DEBUG")
}
debug = app.config.get("DEBUG")
testing = app.config.get("TESTING")
_app = _App()
self.mail = flask_mail.Mail(app=_app)
_ses_mailer = ses_mailer.Mail(
template=self.config.get("MAIL_TEMPLATE"),
template_context=self.config.get("MAIL_TEMPLATE_CONTEXT"))
self._template = _ses_mailer.parse_template
else:
logging.warning("Mailer Error. Invalid scheme '%s'" % scheme)
def init_extensions(self):
mail_app = flask_mail.Mail(self.flask_app)
babel = flask_babel.Babel(self.flask_app)
babel.locale_selector_func = self.locale_selector
self.extensions.update(
babel=babel,
mail=mail_app,
)
def test_unicode_subject(self):
app = flask.Flask(__name__)
flask_mail.Mail(app)
with app.app_context():
msg = SuperdeskMessage(self.subject, sender="root", body="test")
out = msg.as_bytes()
parsed = Parser().parsestr(out.decode("utf-8"), headersonly=True)
decoded, charset = decode_header(parsed["subject"])[0]
self.assertEqual(self.subject, decoded.decode(charset))
def report():
service = auth.get_calendar_service()
req_json = request.get_json()
event_id = req_json['body']['eventId']
# Send email
event = calendar_api.get_event(service, event_id)
event_info = calendar_api.parse_event_info(event)
mail = flask_mail.Mail(app)
message = flask_mail.Message(subject='Zoom Event Reported',
html=render_template('report_event.html',
**event_info),
recipients=['*****@*****.**'])
mail.send(message)
return SUCCESS_STATUS
def send_email(title, html_text, body_text, recipients):
# Prepare email
css = sass.compile(string=flask.render_template('email/base.scss'))
html = flask.render_template('email/base.html',
title=title,
css=css,
text=html_text)
html = premailer.Premailer(html, strip_important=False).transform()
body = flask.render_template('email/base.txt', title=title, text=body_text)
# Send email
mail = flask_mail.Mail(flask.current_app)
msg = flask_mail.Message(title,
recipients=recipients,
body=body,
html=html)
mail.send(msg)
def delete_event():
"""Removes calendar event with specified eventId."""
service = auth.get_calendar_service()
event_id = request.form.get('event_id')
event = calendar_api.get_event(service, event_id)
event_info = calendar_api.parse_event_info(event)
calendar_api.delete_event(service, event_id)
# Send email to whoever's event it was notifying them.
mail = flask_mail.Mail(app)
message = flask_mail.Message(subject='Your Zoom Event was Removed',
html=render_template('removed_event.html',
**event_info),
recipients=[event_info['creator']])
mail.send(message)
return "Event %s with ID %s was successfully removed." % (
event_info['summary'], event_id)
def email_sender(mail, app, subject: str, body: str, recipients: list,
sender: str):
msg = flask_mail.Message(
subject,
sender=sender,
recipients=recipients,
)
msg.body = body
mail = flask_mail.Mail(app) if mail is None else mail
try:
mail.send(msg)
except smtplib.SMTPAuthenticationError:
return ('Please log in with your web browser and then try again.', 401)
except BaseException as error:
return ('Unexpected error occured while sending email. '
'Traceback: {}'.format(error), 500)
return 'Email was sent.', 200
def init_apis(app, *args, **kwargs):
global cfg
cfg = pkconfig.init(
mail_server=(None, str, 'Mail server'),
mail_username=(None, str, 'Mail user name'),
mail_password=(None, str, 'Mail password'),
mail_support_email=(None, str, 'Support email address'),
mail_recipient_email=(None, str,
'Email to receive registration messages'),
)
assert cfg.mail_server and cfg.mail_username and cfg.mail_password \
and cfg.mail_support_email and cfg.mail_recipient_email, \
'Missing mail config'
app.config.update(
MAIL_USE_TLS=True,
MAIL_PORT=587,
MAIL_SERVER=cfg.mail_server,
MAIL_USERNAME=cfg.mail_username,
MAIL_PASSWORD=cfg.mail_password,
)
global _mail
_mail = flask_mail.Mail(app)
def resetpass():
cursor = connexiondb()
msg = ''
try:
if request.method == "POST":
rmail = request.form['Resetmail']
cursor.execute("SELECT * FROM Administrateur WHERE Email=%s",
(rmail))
requet = cursor.fetchall()
if len(requet) == 1:
envoi = flask_mail.Message(
subject='hello',
sender=app.config.get('MAIL_USERNAME'),
body='hallo hello flask test')
envoi.add_recipient(rmail)
flask_mail.Mail().send(envoi)
msg = 'mail envoyer'
else:
msg = 'mail incorrect'
except Exception, e:
return str(e)
def init_apis(app, *args, **kwargs):
global cfg
cfg = pkconfig.init(
#TODO(robnagler) validate email
from_email=pkconfig.Required(str, 'From email address'),
from_name=pkconfig.Required(str, 'From display name'),
smtp_password=pkconfig.Required(str, 'SMTP auth password'),
smtp_server=pkconfig.Required(str, 'SMTP TLS server'),
smtp_user=pkconfig.Required(str, 'SMTP auth user'),
)
auth_db.init_model(app, _init_model)
if pkconfig.channel_in('dev') and cfg.smtp_server == _DEV_SMTP_SERVER:
return
app.config.update(
MAIL_USE_TLS=True,
MAIL_PORT=587,
MAIL_SERVER=cfg.smtp_server,
MAIL_USERNAME=cfg.smtp_user,
MAIL_PASSWORD=cfg.smtp_password,
)
global _smtp
_smtp = flask_mail.Mail(app)
import flask
import flask_mail
import jwt
app = flask.Flask(__name__)
app.config["SECRET_KEY"] = 'ShHhHhhhitsasecret'
app.config['MAIL_SERVER'] = '*****@*****.**'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USERNAME'] = "******"
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_USERNAME'] = "******"
app.config['MAIL_PASSWORD'] = "******"
payload = {'message': 'helloooo'}
token = jwt.encode(payload, 'ShHhHhhhitsasecret')
print('encoded token: ' + token)
decoded = jwt.decode(token, app.config['SECRET_KEY'])
print(decoded)
print(payload)
mail_mgr = flask_mail.Mail(app)
from . import views
import flask as fl
import flaskext.mysql as sql
import flask_mail as fmail
from flask_uploads import UploadSet, configure_uploads, IMAGES
from csming import config as cfg
# init app
app = fl.Flask(__name__)
app.secret_key = cfg.BasicConfig.secret_key
# init flask-uploads
photos = UploadSet('photos', IMAGES)
# config
app.config.from_object(cfg.BasicConfig)
configure_uploads(app, photos)
# init mail
mail = fmail.Mail(app)
# init MySQL
mysql = sql.MySQL(app)
import csming.views
from flask import Flask
import flask_mail as eMail
'''
Add the Job and depratment connection to the Empoyee
Make the edit option available using the select list
'''
app = Flask(__name__)
mail_settings = {
"MAIL_SERVER": 'smtp.gmail.com',
"MAIL_PORT": 465,
"MAIL_USE_TLS": False,
"MAIL_USE_SSL": True,
"MAIL_USERNAME": "******",
"MAIL_PASSWORD": "******"
}
app.config.update(mail_settings)
mail = eMail.Mail(app)
app.config["UploadImageFolder"] = "Beec\\UploadedImgs"
# Set the secret key to some random bytes. Keep this really secret!
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'
import Beec.OnlyWebsite
import Beec.OnlyApp
import Beec.LoginRouts
from flask_debugtoolbar import DebugToolbarExtension
from flask_bcrypt import Bcrypt
import flask_mail
import flask_fanstatic
from dotenv import load_dotenv
import os
from werkzeug.middleware.proxy_fix import ProxyFix
import logging
from logging.config import dictConfig
toolbar = DebugToolbarExtension()
flask_bcrypt = Bcrypt()
flask_mailer = flask_mail.Mail()
fanstatic = flask_fanstatic.Fanstatic()
def create_app(test_config=None):
# create and configure the app
log.info("create_app: called")
app = Flask(__name__, instance_relative_config=True)
app.wsgi_app = ProxyFix(app.wsgi_app,
x_for=1,
x_proto=1,
x_host=1,
x_port=1,
x_prefix=1)
def create_app(is_sentry_on=False, **kwargs):
app = Flask(__name__)
app.config.update(kwargs or {})
db = MongoEngine()
CORS(app)
if 'TESTING' in kwargs and kwargs['TESTING']:
app.testing = True
db.init_app(
app, {
'MONGODB_SETTINGS': {
'db':
'testing',
'host':
'mongodb://*****:*****@ds111876.mlab.com:11876/testing'
}
})
# db.connection
else:
app.config['MONGODB_SETTINGS'] = {
'db':
'cheapbookdev',
'host':
'mongodb://*****:*****@ds053305.mlab.com:53305/cheapbookdev'
}
db.init_app(app)
import models
configs = models.Config.objects.get(config_id='initials')
app.config.from_object(configs)
app.config['DEBUG'] = False
mail = flask_mail.Mail()
mail.init_app(app=app)
if is_sentry_on:
sentry = Sentry(
dsn=
'https://*****:*****@sentry.io/177217'
)
sentry.init_app(app)
flask_mobility.Mobility().init_app(app=app)
from utils.exception_handler import error_dict, Handler
for e in error_dict:
app.register_error_handler(e, Handler(e).generate_response)
from utils.exceptions import general_exceptions
# @app.errorhandler(404)
# @app.errorhandler(401)
@app.errorhandler(500)
@json_response
def page_not_found_500(error):
print(error)
return general_exceptions.BASIC_ERROR_500
@app.errorhandler(404)
@json_response
def page_not_found_404(error):
print(error)
return general_exceptions.BASIC_ERROR_500
@app.before_request
def before_request():
request_data = save_request(request)
global_storage.request_data = request_data
@app.after_request
def after_request(resp):
resp_data = save_response(resp)
request_data = global_storage.request_data
traffic = models.Traffic(request=request_data, response=resp_data)
traffic.save()
return resp
import URLs
routes = URLs.get_urls()
for model in dir(models):
temp_class = getattr(models, model)
if inspect.isclass(temp_class) and issubclass(
temp_class, models.base.BaseDocument):
print(temp_class.__name__)
app.url_map.converters[
temp_class.__name__] = temp_class.get_converter()
for route in routes:
imported_class = route['cls']
route_object = imported_class()
app.add_url_rule(route['route'],
view_func=route_object.dispatcher,
endpoint=route['endpoint'],
methods=['GET', 'POST', 'PUT', 'DELETE'])
return app
import flask
import flask_sqlalchemy
import flask_migrate
import flask_mail
from flask_login import LoginManager
from .static import enums
import os
db = flask_sqlalchemy.SQLAlchemy()
migrate = flask_migrate.Migrate()
login_manager = LoginManager()
mail_manager = flask_mail.Mail()
def create_app(default_env="production"):
# imports
from config import config
from .views import main_blueprint
from .user_managment import user_blueprint
from .learning_hub import learning_hub_bp
from . import models
#learning_app init
app = flask.Flask(__name__)
# environment
env = os.environ.get(
"FLASK_ENV", default_env
) # This will be different given the computer python is running on
app.config.from_object(config[env])
# learning_app.config['SECRET_KEY'] = "secretKey"
def __init(self, instance):
instance.config.from_envvar('FLASK_SETTING')
self.settings = instance.config
if instance.debug:
current = os.path.dirname(__file__)
self.path = os.path.join(current, '..', 'dump', 'data')
self.lpath = os.path.join(current, '..', 'dump', 'logs')
else:
self.path = os.path.join('/', 'var', 'rere1')
self.lpath = os.path.join('/', 'var', 'logs')
instance.wsgi_app = \
werkzeug.contrib.fixers.ProxyFix(instance.wsgi_app)
self.sentry = raven.contrib.flask.Sentry(
instance,
logging=True,
level=logging.WARNING,
)
const = base.Constant
with instance.app_context():
for _ in range(0,
self.settings[const.SETTING_MAX_RECONNECTION_TRY]):
try:
self.db = base.Alchemy
self.db.init_app(instance)
self.db.create_all()
self.db.session.commit()
break
except Exception as exception:
time.sleep(self.settings[const.SETTING_DEFAULT_SLEEP_TIME])
self.redis = flask_redis.FlaskRedis()
self.redis.init_app(instance, decode_responses=True)
for _ in range(0,
self.settings[const.SETTING_MAX_RECONNECTION_TRY]):
try:
if self.redis.ping():
break
else:
raise Exception()
except Exception as exception:
time.sleep(self.settings[const.SETTING_DEFAULT_SLEEP_TIME])
flask_cors.CORS(instance)
self.extensions = {}
self.extensions['mail'] = flask_mail.Mail()
self.extensions['mail'].init_app(instance)
remote = flask_limiter.util.get_remote_address
self.extensions['limiter'] = flask_limiter.Limiter(key_func=remote)
self.extensions['limiter'].init_app(instance)
self.extensions['cache'] = flask_cache.Cache(with_jinja2_ext=False)
self.extensions['cache'].init_app(instance)
if not instance.debug:
for name, exception in werkzeug.exceptions.__dict__.items():
if isinstance(exception, type):
if issubclass(exception, Exception):
instance.register_error_handler(
exception,
lambda exception: flask.jsonify({}),
)
if not instance.debug:
instance.logger.removeHandler(flask.logging.default_handler)
handler = logging.FileHandler(os.path.join(self.lpath,
'api.log'), )
handler.setLevel(logging.WARNING)
instance.logger.addHandler(handler)
self.__components = {}
for name, component in components.__dict__.items():
if isinstance(component, type):
if issubclass(component, base.Component):
self.__components[name.lower()] = component(self)
self.__actions = {}
for name, action in actions.__dict__.items():
if isinstance(action, type):
if issubclass(action, base.Action):
self.__actions[name.lower()] = action(self)
for name, command in commands.__dict__.items():
if isinstance(command, type):
if issubclass(command, base.Command):
cmd = functools.partial(command.execute, command(self))
cmd.__name__ = command.NAME
cmd = click.command()(cmd)
cmd.short_help = command.DESCRIPTION
for argument in command.ARGUMENTS:
cmd = click.option(
'--' + argument['name'],
type=argument['type'],
default=argument['default'],
help=argument['description'],
)(cmd)
instance.cli.add_command(cmd)
import flask_migrate import flask_bootstrap import flask_login import flask_mail import flask_moment import werkzeug from app import config # ~ from app import forms bazadanych = flask_sqlalchemy.SQLAlchemy() migracje = flask_migrate.Migrate() stylista = flask_bootstrap.Bootstrap() zalogowany = flask_login.LoginManager() wysylacz = flask_mail.Mail() momencik = flask_moment.Moment() # ~ from app import models # ~ aplikacja = flask.Flask( __name__ ) # ~ aplikacja.config.from_object( config.Config ) # ~ bazadanych.init_app( aplikacja ) # ~ migracje.init_app( aplikacja, bazadanych ) # ~ stylista.init_app( aplikacja ) # ~ zalogowany.init_app( aplikacja ) # ~ from app.auth import auth as bp_auth # ~ aplikacja.register_blueprint( bp_auth )
conf = configparser.ConfigParser()
config_path = util.get_root_path() + "/conf/platform.conf"
conf.read(config_path)
host = conf.get("system", "host")
port = conf.get("system", "port")
stp_app = flask.Flask("SubwayTraffic")
stp_app.config.update(
MAIL_SERVER="smtp.qq.com",
MAIL_PORT=465,
MAIL_USE_SSL=True,
MAIL_USERNAME=conf.get("deploy", "admin_email"),
MAIL_PASSWORD=conf.get("deploy", "admin_email_pwd"),
)
stp_email = flask_mail.Mail(stp_app)
server_init.register(stp_app)
def send_mail(**kwargs):
subject = kwargs["header"]
mail_type = kwargs["type"]
message = flask_mail.Message(
subject,
recipients=kwargs["receiver"],
sender=("SubwayTraffic", conf.get("deploy", "admin_email")),
)
if mail_type == "send_code":
message.html = flask.render_template("send_code.html",
operate=kwargs["operate"],
import os.path
import smtplib
import time
import uuid
import couchdb2
import flask
import flask_mail
import jinja2.utils
import marko
import werkzeug.routing
from anubis import constants
# Global instance of mail interface.
MAIL = flask_mail.Mail()
def init(app):
"""Initialize.
- Add template filters.
- Update CouchDB design documents.
"""
MAIL.init_app(app)
app.add_template_filter(display_markdown)
app.add_template_filter(display_field_value)
app.add_template_filter(display_value)
app.add_template_filter(display_datetime_local_server)
app.add_template_filter(display_boolean)
app.add_template_filter(user_link)
app.add_template_filter(call_link)
import datetime
import itertools
import werkzeug
import flask
import flask_appconfig.env
import flask_mail
import flask.ext.cache
import flask.ext.compress
import flask.ext.assets
import identity
app = flask.Flask(__name__)
flask_appconfig.env.from_envvars(app.config, prefix='MPCV_')
mail = flask_mail.Mail(app)
cache = flask.ext.cache.Cache(app,config={'CACHE_TYPE': 'simple'})
flask.ext.compress.Compress(app)
assets = flask.ext.assets.Environment(app)
import lookups
import constants
# Log to stderr for Heroku
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
app.logger.addHandler(stream_handler)
#####################################################################
# Sitemap and global API
# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# This file is part of MyDojo package (https://github.com/honzamach/mydojo).
#
# Copyright (C) since 2018 Honza Mach <*****@*****.**>
# Use of this source is governed by the MIT license, see LICENSE file.
#-------------------------------------------------------------------------------
"""
This module contains mailing functions for MyDojo application. They are built on
top of :py:mod:`flask_mail` extension.
"""
__author__ = "Honza Mach <*****@*****.**>"
import flask_mail
MAILER = flask_mail.Mail()
"""Global application resource: :py:mod:`flask_mail` mailer."""
def on_email_sent(message, app):
"""
Signal handler for handling :py:func:`flask_mail.email_dispatched` signal.
Log subject and recipients of all email that have been sent.
"""
app.logger.info("Sent email '%s' to '%s'", message.subject,
', '.join(message.recipients))
flask_mail.email_dispatched.connect(on_email_sent)
import smtplib
from typing import Any, Dict
import flask
import flask_mail
from . import config
mail = flask_mail.Mail()
def send_mail(email: str, template: str, params: Dict[str, Any]) -> bool:
message = flask_mail.Message()
message.sender = '{} <{}>'.format(
config.get('APP_EMAIL_SENDER_NAME'),
config.get('APP_EMAIL_SENDER_MAIL'),
)
message.recipients = [email]
message.subject = flask.render_template(
'{}/subject.txt'.format(template),
**params,
)
message.body = flask.render_template(
'{}/body.txt'.format(template),
**params,
)
mail: flask_mail.Mail = flask.current_app.extensions['mail']
try:
mail.send(message)
from flask import Flask, request, url_for, render_template, session
app = Flask(__name__)
app.config['DEBUG'] = True
app.secret_key = 'asd'
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = timedelta(seconds=1)
# mail和redis配置
app.config['MAIL_SERVER'] = 'smtp.126.com'
app.config['MAIL_PORT'] = 25
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
app.config['FLASK_MAIL_SENDER'] = '皮皮虾！我们走！<*****@*****.**>'
app.config['FLASK_MAIL_SUBJECT_PREFIX'] = '[皮皮虾！我们走]'
mail = flaskmail.Mail(app)
redis_store = redis.StrictRedis(host='127.0.0.1', port='6379')
@app.route('/')
def toLogin():
return render_template('login.html')
@app.route('/reNewPwd.html')
def toReNewPwd():
return render_template('reNewPwd.html')
@app.route('/index.html')
def toIndex():
