def send_email(to, subject, template, **kwargs):
mail = Mail(app)
msg = Message(app.config['FLASKY_MAIL_SUBJECT_PREFIX'] + ' ' + subject,
sender=app.config['FLASKY_MAIL_SENDER'], recipients=[to])
msg.body = render_template(template + '.txt', **kwargs)
msg.html = render_template(template + '.html', **kwargs)
mail.send(msg)
def send_message(subject, body, html=False, caps_gs_sem=False):
from sync import app
mail = Mail(app)
if caps_gs_sem:
recipients = CAPS_GS_SEM_RECIPIENTS
else:
recipients = ADMIN_RECIPIENTS
msg = Message(subject=subject,
sender="*****@*****.**",
recipients=recipients)
if html:
msg.html = body
else:
msg.body = body
try:
mail.send(msg)
except socket.error:
print "failed to send message %s" % body
return False
return True
def adoptPuppyPage(puppy_id):
""" Provides a page where adopters can adopt a puppy. """
puppy = session.query(Puppy).filter_by(id=puppy_id).one()
if request.method == 'POST':
try:
# Change the adopter_puppy field of adopter to reflect the puppy.
adopter_id = int(request.form['adopterIDField'])
adopter = session.query(Adopter).filter_by(id=adopter_id).one()
adopter.adopted_puppy = puppy.id
session.add(adopter)
# Change the shelter id of the puppy to None since it has a home.
puppy.shelter_id = None
session.add(puppy)
session.commit()
# Create a mail instance for use with sending messages.
mail = Mail(app)
msg = Message("Hello Em, thanks for adopting %s" % puppy.name,
sender="*****@*****.**",
recipients=["*****@*****.**"])
mail.send(msg)
return redirect(url_for('puppyList'))
except:
print "The adoption process was unsuccessful."
return redirect(url_for('puppyList'))
else:
return render_template('adopt_puppy.html', puppy=puppy)
def send_pdf_by_email(invoice_id):
form = InvoiceEmail(request.form)
if not form.validate():
return form.errors_as_json()
invoice = Invoice.find_by_id(invoice_id)
if not invoice:
return abort(404)
message = Message(form.subject.data.encode('utf-8'), sender=(g.member.display, g.member.get_email().encode('utf-8')))
message.add_recipient(sanitize_address((form.name.data, form.email.data)))
message.body = form.message.data.encode('utf-8')
invoice_key = amazons3.get_invoice(invoice)
message.attach("Invoice_{0}.pdf".format(invoice.reference), "application/pdf", invoice_key.get_contents_as_string())
mail = Mail()
mail.init_app(current_app)
mail.send(message)
history = InvoiceHistory()
history.description = 'Sent email to {0}'.format(message.recipients[0])
history.pdf = invoice_key.key
history.status = 'SENT'
history.misc = "{0}\n\n{1}".format(message.subject, message.body)
history.member_id = g.member.id
history.invoice_id = invoice.id
history.save()
return 'sent', 200
def add_post_post():
members = session.query(User).all()
post = Post(
title=request.form["title"],
content=mistune.markdown(request.form["content"]),
description = request.form["description"],
author=current_user
)
session.add(post)
session.commit()
all_members = []
for member in members:
all_members.append(member.email)
all_members = [str(i) for i in all_members]
describe = request.form["description"] +".... View full message on TeamForum!"
mail=Mail(app)
with mail.connect() as conn:
for email in all_members:
message = Message(subject="A new forum has been created by "+ current_user.name,
body= describe,
sender=("TeamForum", "*****@*****.**"),
recipients=[email]
)
conn.send(message)
flash("You have created a new forum. Team members have been notified.", "info")
return redirect(url_for("posts"))
def UserMail(user, passwd, smtp, smtp_port, smtp_tsl, smtp_auth, data):
mail_user = user
mail_passwd = passwd
print "--- DEBUG ---"
print "--- DEBUG ---"
print data
print "--- DEBUG ---"
print "--- DEBUG ---"
from_addr = user
to_addr = ';'.join(data.get("from_mail"))
print to_addr
mail = Mail(current_app)
current_app.config.update(
MAIL_SERVER=smtp,
MAIL_PORT=smtp_port,
MAIL_USE_SSL=smtp_auth,
MAIL_USE_TLS=smtp_tsl,
MAIL_USERNAME=mail_user,
MAIL_PASSWORD=mail_passwd
)
mail.init_app(current_app)
msg = Message('Reztoran', sender=from_addr, recipients=to_addr.split(";"))
msg.html = data.get("text")
msg.subject = data.get('title')
mail.send(msg)
return "ok"
def test_send_email():
mailForm= MailForm()
if mailForm.validate_on_submit():#表单提交成功的判断
try:
app = Flask(__name__)
app.config['SECRET_KEY'] = 'qiyeboy'
#下面是SMTP服务器配置
app.config['MAIL_SERVER'] = 'smtp.163.com' #电子邮件服务器的主机名或IP地址
app.config['MAIL_PORT'] = '25' #电子邮件服务器的端口
app.config['MAIL_USE_TLS'] = True #启用传输层安全
app.config['MAIL_USERNAME'] ='******' #os.environ.get('MAIL_USERNAME') #邮件账户用户名
app.config['MAIL_PASSWORD'] = '******'#os.environ.get('MAIL_PASSWORD') #邮件账户的密码
mail = Mail(app)
receiverName = mailForm.receiver.data #收件人文本框的内容
styledata = mailForm.style.data#主题文本框的内容
bodydata = mailForm.body.data#正文文本框的内容
msg = Message(styledata,sender='*****@*****.**',recipients=[receiverName])#发件人，收件人
msg.body = bodydata
# send_email('*****@*****.**','Test email-function',)
mail.send(msg)
flash('邮件发送成功!')#提示信息
return redirect(url_for('.index'))
except:
flash('邮件发送失败!')
return redirect(url_for('.index'))
return render_template('testemail.html',form=mailForm,name ='*****@*****.**' )#渲染网页
# @main.route('/secret')
# @login_required
# def secret():
# return 'Only authenticated users are allowed!'
def send_email(msg):
from routes import app
with app.app_context():
mail = Mail()
mail.init_app(current_app)
print("hallo world")
mail.send(msg)
def register():
owner = "*****@*****.**"
sysadmin = "*****@*****.**"
name = request.form.get('name', None)
email = request.form.get('email', None)
institute = request.form.get('institute', None)
message = request.form.get('message', None)
app =Flask(__name__)
mail=Mail(app)
_subject = "[Multinet] Request Access Form: %s, %s" % ( name, email )
#1.check if user exists, generate access url for user and save user to db
_token = generate_id()
udata = { "email" : email,"name" : name,"institute" : institute,"message" : message, "token": _token }
ret = insert_user(udata)
if not ret:
return render_template('start.html',errors="This email address is already registered.")
#2.send new user to admin
try:
msg = Message( subject=_subject , recipients=[ owner ], body=message, sender=sysadmin )
mail.send(msg)
except Exception,e:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_tb(exc_traceback, limit=5, file=sys.stdout)
def sendConfirmation(app, teamEmail, html = None):
if not configSet :
setConfigOptions(app)
mail = Mail(app)
msg = Message(subject=_subject, sender=_mailDefaultSender, recipients=[teamEmail], bcc=[_mailDefaultSender])
msg.body = getEmailTemplate()
msg.html = html
mail.send(msg)
def send_email(to,subject,template):
mail = Mail(application)
mail.init_app(application)
msg = Message(
subject,recipients = [to],
html = template,
sender = application.config['MAIL_USERNAME'])
mail.send(msg)
def send_email(email, pdf):
mail_ext = Mail(app)
subject = "Phone Notes"
receiver = "*****@*****.**"
mail_to_be_sent = Message(subject=subject, recipients=[receiver])
mail_to_be_sent.body = "This email contains PDF."
mail_to_be_sent.attach("file.pdf", "application/pdf", pdf)
mail_ext.send(mail_to_be_sent)
def count_words_at_url(url, mailAddress):
resp = requests.get(url)
result = len(resp.text.split())
mail = Mail(current_app)
msg = Message("test", recipients=["*****@*****.**"])
msg.body = str(result)
msg.add_recipient(str(mailAddress))
mail.send(msg)
return result
def send_email(subject, text):
""" Send email """
msg = Message(subject, sender='*****@*****.**',
recipients=['*****@*****.**'])
msg.body = text
mail = Mail(current_app)
mail.send(msg)
def send(MessageClass, **kwargs):
with app.test_request_context():
mailer = Mail(app)
mailer.send(MessageClass(**kwargs))
if 'to' in kwargs:
return "Mail type: %s, recipient: %s" % (MessageClass.desc(), kwargs['to'])
return True
def mail():
mail = Mail(app)
dishes = reduce(
operator.add,
[d.dishes for d in db.session.query(Meal).all()])
dishes_today = filter(
lambda x: x.meal.date == datetime.date.today(),
dishes)
users = db.session.query(User).all()
recipients_info = {}
for user in users:
if user.preference in dishes_today and user.email is not None:
info = {
"name": user.username,
"dish": user.preference.dish_description,
"date": user.preference.meal.date,
"meal_type": user.preference.meal.mealtime.meal_type,
"servery": user.preference.meal.mealtime.servery.name
}
recipients_info[user.email] = info
with mail.connect() as conn:
for email in recipients_info.keys():
message = (
"Hi, %s! \n Your favorite dish %s is available",
"during %s at %s servery today.") % (
recipients_info[email]["name"],
recipients_info[email]["dish"],
recipients_info[email]["meal_type"],
recipients_info[email]["servery"])
message_html = (
"Hi, %s! <br> <br> Your favorite dish <b>%s</b> is ",
"available during <b>%s</b> at <b>%s</b> servery today.") % (
recipients_info[email]["name"],
recipients_info[email]["dish"],
recipients_info[email]["meal_type"],
recipients_info[email]["servery"])
subject = "Hi %s, your favorite food is available today!" % (
recipients_info[email]["name"])
msg = Message(
sender=("Rice Servery App", "*****@*****.**"),
recipients=[email],
subject=subject)
msg.body = message
msg.html = message_html
conn.send(msg)
return "Mails sent!"
def send_async_email(app, msg, list_id, manager_id, uu):
with app.app_context():
try:
OA_Email_Url(list_id, manager_id, uu, 0).add()
db.session.commit()
mail = Mail(app)
mail.send(msg)
except:
# 回滚
db.session.rollback()
logger.exception("exception")
def sender_email(traceback):
from flask.ext.mail import Mail, Message
mail = Mail(app)
senders = app.config.get("SENDERS", [])
if not senders:
return
msg = Message(subject=u"%s %s时遇到异常" % (request.method, request.url),
html=traceback.render_summary(),
sender="*****@*****.**",
recipients=senders)
mail.send(msg)
def send_mail(subject, html, recipients):
sender = app.config.get('MAILS_SENDER_NAME', 'BDR Help Desk')
message = Message(subject=subject, recipients=recipients, html=html,
sender=sender)
mail = Mail(app)
try:
mail.send(message)
return True
except smtplib.SMTPAuthenticationError:
print('Wrong username/password. ' \
'Please review their values in settings.py')
return False
def email_scheduler(email_html):
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
mail = Mail(app)
msg = Message(subject='Test Email Job Task Breakdown',
sender=app.config['FLASKY_MAIL_SENDER'],
recipients=recipent_list)
msg.body = email_html
mail.send(msg)
def mail_test():
from flask.ext.mail import Mail, Message as Msg
mail = Mail(app)
msg = Msg('A test message', sender=app.config['MAIL_SENDER '], recipients=['*****@*****.**'])
msg.body = 'Hello and welcome!'
msg.html = 'No html available'
print 'Sending an email from '+app.config['MAIL_USERNAME']+ \
' on the server '+app.config['MAIL_SERVER']+':'+str(app.config['MAIL_PORT']) + \
' using: SSL - '+str(app.config['MAIL_USE_SSL'])+', TLS - '+str(app.config['MAIL_USE_TLS'])
with(app.app_context()):
mail.send(msg)
def send_mail(subject, recipients, html, attachment=False, **kwargs):
sender = 'Eau de Web <%s>' % app.config.get('MAIL_USERNAME')
message = Message(subject=subject, recipients=recipients, html=html,
sender=sender)
if attachment:
attach(message, **kwargs)
mail = Mail(app)
try:
mail.send(message)
return True
except smtplib.SMTPAuthenticationError:
print 'Wrong username/password. ' + \
'Please review their values in settings.py'
return False
def get_mail(app):
mail = Mail()
#app.secret_key = 'development key'
app.config["MAIL_SERVER"] = "smtp.gmail.com"
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_PORT'] = 465
app.config["MAIL_USERNAME"] = '******'
app.config["MAIL_PASSWORD"] = '******'
mail.init_app(app)
return mail
def email_appkey(prj_id, member_email):
memkey = ProjectMemberKey.find_one(prj_id=prj_id, member_email=member_email)
if settings.MAIL_SERVER:
mail = Mail(current_app._get_current_object())
message = Message("Your new appkey for 4k mobile app",
sender='*****@*****.**',
recipients=[member_email])
message.body = ( 'Project ID: %s \nAppkey: %s' %
(prj_id, memkey.appkey) )
mail.send(message)
flash("New appkey has been send to your email.", category='info')
else:
flash("Can not email because email server is not availalbe. " +
"Contact administrator", category='error')
return redirect(url_for('.view_project', prj_id=prj_id))
def send_email(user):
from flask.ext.mail import Mail, Message
mail = Mail(app)
msg = Message("Gamma Computations Complete",
recipients=[user.email])
msg.body = """A simulation has been completed by the Flask Gamma app. Please log in at
http://localhost:5000/login
to see the results.
---
This email has been automatically generated by the Gamma app created by
Parampool. If you don't want email notifications when a result is found, please
register a new user and leave the 'notify' field unchecked."""
mail.send(msg)
def post(self,evento_id):
invitado_id = request.form['invitado']
adapter.crear_invitacion(evento_id,invitado_id)
current_app.logger.info('El usuario '+ invitado_id + ' fue invitado con exito al evento ' + evento_id)
user = adapter.get_user_by_id(invitado_id)
#
mail = Mail()
mail.init_app(current_app)
email.send_email(mail, current_app, "Arreglamos Eh", "*****@*****.**", [user.email], "Te han invitado a un evento", "<b>Mira!!, el usuario: " + current_user.username + " Te han invitado a un evento</b></br><a href='http:\\glacial-scrubland-6807.herokuapp.com'>Ir a Arreglamos Eh</a>")
#mail = Mail()
#mail.init_app(current_app)
#msg = Message("Arreglamos Eh", sender="*****@*****.**", recipients=[user.email])
#msg.html = "<b>Mira!!, el usuario: " + current_user.username + " Te han invitado a un evento</b>"
#mail.send(msg)
#
return {'invitado': invitado_id}
def email_appkey(prj_id, member_email):
debug_set = current_app.config["DEBUG"]
if debug_set == True:
print "\n\n\n==========> account->views.py -> email_appkey() "
memkey = ProjectMemberKey.find_one(prj_id=prj_id, member_email=member_email)
if settings.MAIL_SERVER:
mail = Mail(current_app._get_current_object())
message = Message(
"Your new appkey for 4k mobile app", sender="*****@*****.**", recipients=[member_email]
)
message.body = "Project ID: %s \nAppkey: %s" % (prj_id, memkey.appkey)
mail.send(message)
flash("New appkey has been send to your email.", category="info")
else:
flash("Can not email because email server is not availalbe. " + "Contact administrator", category="error")
return redirect(url_for(".view_project", prj_id=prj_id))
def mandaemail2((email, assunto, content)): app.config.update(dict( DEBUG = True, MAIL_SERVER = 'smtp.gmail.com', MAIL_PORT = 587, MAIL_USE_TLS = True, MAIL_USE_SSL = False, MAIL_USERNAME = '******', MAIL_PASSWORD = '******', )) mail = Mail(app) msg = Message( assunto, sender = '*****@*****.**', recipients = [email]) msg.body = content mail.send(msg)
def send_email(title, content, to_list, cc_list=None, bcc_list=None, sender=None):
"""
发送邮件
"""
mail = Mail(current_app)
extra = {
"Accept-Charset": "ISO-8859-1,utf-8"
}
try:
msg = Message(subject=title, html=content, recipients=to_list, sender=sender, cc=cc_list, bcc=bcc_list, extra_headers=extra)
mail.send(msg)
return True
except SMTPRecipientsRefused as e:
raise e
except Exception as e:
current_app.logger.exception(e)
return False
def send_email_invites(event):
if event.is_email_involved():
contacts_to_invite = list(event.contacts_email_to_invite)
mail = Mail(app)
if contacts_to_invite:
with db.transaction:
for contact in contacts_to_invite:
hash = contact.invitation_hash(event)
msg = Message('Inviation to %s' % event.name)
msg.sender = '%s <%s>' % (current_user.name, current_user.email)
msg.add_recipient('%s <%s>' % (contact.name, contact.email))
msg.html = render_template('_invitation.html', event=event, hash=hash)
mail.send(msg)
event.set_invitation_sent(contact)
#!/usr/bin/env python
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.mail import Mail
Mdb = Flask(__name__,template_folder="../../templates")
Mdb.config.from_envvar('MDB_CONFIG')
Mdb.secret_key = Mdb.config['SECRET_KEY']
db = SQLAlchemy(Mdb)
mail = Mail(Mdb)
from Mdb import models,views
import os
##########################################################################
# Initialize the Flask application
app = Flask(__name__)
# Configuring Flask Mail with gmail
app.config['MAIL_SERVER']= 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_DEBUG'] = True
mailbox = Mail(app) # Initialize mail
# Defining a route for the default URL, which loads the form
@app.route('/')
def form():
return render_template('layout.html')
# accepting: POST requests
@app.route('/confirmation/', methods=['POST'])
def entry():
# assigning form input to variables
name = request.form['Name']
email = request.form['Email']
btc = request.form['BTC']
operator = None
def create_app():
# Create app
app = Flask(__name__)
mail = Mail(app)
app.config.from_object('config')
mail = Mail(app)
mail.init_app(app)
# db instance is created in models.py (for factory pattern)
from models import db
db.init_app(app)
# Setup Flask-Security
from models import roles_users, Role, User
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
# importmore Moules here
from models import InvoiceDocument
# Import modules here
from app.mod_api.api import api_mod as api_module
from app.mod_crew.controllers import crew_mod as crew_module
app.register_blueprint(api_module)
app.register_blueprint(crew_module)
# Views
# # Create a user to test with
@app.before_first_request
def create_user():
db.create_all()
#user_datastore.create_user(email='*****@*****.**', password='******')
#user_datastore.create_user(email='test', password='******')
db.session.commit()
@app.route('/')
@login_required
def index():
return render_template('pickoption.html')
@app.route('/hourly_rate', methods=['GET', 'POST'])
@login_required
def hourly_rate():
form = HourlyRateForm(request.form)
entry = None
if request.method == 'POST':
if form.validate_on_submit():
entry = FreelanceEntry(
hourly_rate=form.hours_worked.data,
hours=form.hours_worked.data,
)
if "submit" in request.form:
flash("button 1 was pressed")
return render_template('hourly_rate.html',
form=form,
entry=entry)
if "save_invoice" in request.form:
flash("Data Saved ")
invoice_saved = InvoiceDocument(
option_selected="hourly_rate",
hours=form.hours_worked.data,
hourly_rate=form.hourly_rate.data,
creation_date=timenow)
db.session.add(invoice_saved)
db.session.commit()
return render_template('hourly_rate.html',
form=form,
entry=entry)
else:
flash("Fill Out both fields")
return render_template('hourly_rate.html',
form=form,
entry=entry)
elif request.method == 'GET':
return render_template('hourly_rate.html', form=form, entry=entry)
@app.route('/guaranteedhours', methods=['GET', 'POST'])
@login_required
def guaranteed_hours():
form = GuaranteedHoursForm(request.form)
entry = None
if form.validate_on_submit():
entry = FreelanceEntry(
guaranteed_rate=form.guaranteed_rate.data,
guaranteed_hours=form.guaranteed_hours.data,
hours_worked=form.actual_hours_worked.data,
)
return render_template('guaranteedhours.html', form=form, entry=entry)
@app.route('/about')
def about():
return render_template('about.html')
@app.route('/blog')
def blog():
return render_template('blog.html')
@app.route('/contact')
def contact():
return render_template('contact.html')
@app.route('/accountsettings')
@login_required
def accountsettings():
return render_template('accountsettings.html')
return app
def init_app(init=None,
config=None,
pyfile=None,
template_folder='templates',
index=False,
error=True,
is_web=False,
is_api=False,
manager=False):
""" 创建应用 """
app = Flask(__name__, template_folder=template_folder)
if os.environ.get('LOGGER_DEBUG'):
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
handler.setFormatter(logging.Formatter(DEBUG_LOG_FORMAT))
app.logger.addHandler(handler)
app.logger.setLevel(logging.DEBUG)
init_db(db)
if config:
app.config.from_object(config)
if pyfile:
app.config.from_pyfile(pyfile)
ENVVAR = app.config.get('ENVVAR')
if ENVVAR and os.environ.get(ENVVAR):
env = os.environ.get(ENVVAR)
for pyfile in env.split('|'):
if pyfile.startswith('./'):
pyfile = os.path.join(os.getcwd(), pyfile)
app.logger.info('load config pyfile: %s' % pyfile)
app.config.from_pyfile(pyfile)
if app.debug:
app.config.setdefault('DEBUG_TB_ENABLED', True)
app.config.setdefault('DEBUG_TB_PANELS', DEBUG_TB_PANELS)
app.config.setdefault('DEBUG_TB_INTERCEPT_REDIRECTS', False)
DebugToolbarExtension(app)
app.config.setdefault('SESSION_REFRESH_EACH_REQUEST', False)
app.is_web = is_web
app.is_api = is_api
app.is_admin = not is_web and not is_api
app.is_back = os.environ.get('CHIKI_BACK') == 'true'
app.static_folder = app.config.get('STATIC_FOLDER')
app.mail = Mail(app)
def get_data_path(name):
return os.path.abspath(
os.path.join(app.config.get('DATA_FOLDER'), name))
if app.config.get('USER_AGENT_LIMIT', False):
@app.before_request
def before_request():
if request.path == current_app.config.get('WEROBOT_ROLE'):
return
ua = request.headers['User-Agent'].lower()
if not app.debug and 'micromessenger' not in ua:
return error_msg('请用微信客户端扫一扫')
app.get_data_path = get_data_path
init_babel(app)
init_redis(app)
if not app.config.get('CACHE_TYPE'):
app.config['CACHE_TYPE'] = 'simple'
cache.init_app(app)
if app.config.get('SESSION_TYPE'):
Session(app)
init_jinja(app)
init_logger(app)
init_oauth(app)
init_third(app)
init_page(app)
db.init_app(app)
media.init_app(app)
if app.is_admin and not manager:
with app.app_context():
cm.init_app(app)
Choices.init()
global inits
for i in inits:
i(app)
if callable(init):
init(app)
@app.context_processor
def context_processor():
return dict(Item=Item, Menu=Menu, url_for=url_for, ImageItem=ImageItem)
if error:
init_error_handler(app)
if index:
@app.route('/')
def index():
return redirect(app.config.get('INDEX_REDIRECT'))
blueprint = Blueprint('chiki',
__name__,
template_folder=os.path.join(TEMPLATE_ROOT, 'chiki'))
app.register_blueprint(blueprint)
if app.is_back:
@app.route('/chiki_back')
def chiki_back():
return 'true'
if app.is_admin and not manager:
with app.app_context():
if hasattr(app, 'user_manager'):
user = um.models.User.objects(id=100000).first()
if not user:
user = um.models.User(id=100000,
phone='13888888888',
password='******',
nickname=app.config.get('SITE_NAME'))
user.tid = user.create_tid()
user.save()
if not user.avatar and os.path.exists(
app.get_data_path('imgs/logo.jpg')):
with open(app.get_data_path('imgs/logo.jpg')) as fd:
user.avatar = dict(stream=StringIO(fd.read()),
format='jpg')
user.save()
@app.route('/1.gif')
def gif():
return send_file(DATA_ROOT + '/1.gif',
cache_timeout=0,
add_etags=False,
mimetype='image/gif')
@app.route('/test/error')
def test_error():
raise ValueError('testing!!!')
@app.route('/trace/log', methods=['POST'])
def trace_log():
user = None
if current_user.is_authenticated():
user = current_user.id
if current_app.config.get('FAST_MODE') is True:
return json_success()
TraceLog(
user=user,
key=request.form.get('key', ''),
tid=request.form.get('tid', ''),
label=request.form.get('label', ''),
value=request.form.get('value', ''),
).save()
return json_success()
@app.route('/complaint/choose')
@login_required
def complaint_choose():
complaint = sorted(Complaint.TYPE.DICT.iteritems(),
key=lambda x: x[1],
reverse=True)
return render_template('complaint/choose.html', type=complaint)
@app.route('/complaint/desc/')
@login_required
def complaint_desc():
types = request.args.get('type', '')
return render_template('complaint/desc.html', types=types)
@app.route('/complaint/refer', methods=['POST'])
@login_required
def complaint_refer():
types = request.form.get('type', '')
content = request.form.get('content', '')
complaints = Complaint(
user=current_user.id,
content=content,
type=types,
active=True,
)
complaints.create()
complaints.save()
return json_success(msg='success', num=complaints.id)
@app.route('/complaint/save/')
@login_required
def complaint_save():
num = request.args.get('num', '')
return render_template('complaint/refer.html', num=num)
@app.route('/complaint/active')
@login_required
def complaint_active():
complaints = Complaint.objects(user=current_user.id,
active=True).first()
if complaints:
complaints.user.complaint = True
complaints.user.save()
return ''
init_db(db)
return app
from flask_wtf.csrf import CsrfProtect
csrf = CsrfProtect()
db = SQLAlchemy()
# After defining `db`, import auth models due to
# circular dependency.
from mhn.auth.models import User, Role, ApiKey
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
mhn = Flask(__name__)
mhn.config.from_object('config')
csrf.init_app(mhn)
# Email app setup.
mail = Mail()
mail.init_app(mhn)
# Registering app on db instance.
db.init_app(mhn)
# Setup flask-security for auth.
Security(mhn, user_datastore)
# Registering blueprints.
from mhn.api.views import api
mhn.register_blueprint(api)
from mhn.ui.views import ui
mhn.register_blueprint(ui)
# Create application
app = Flask(__name__)
app.config['SECRET_KEY'] = '123456790'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///fground.sqlite'
app.config['SQLALCHEMY_ECHO'] = True
db = SQLAlchemy(app)
#secrets...
import creds
app.config.from_pyfile('creds.py')
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from flask.ext.mail import Message, Mail
mail = Mail()
app.config["MAIL_SERVER"] = "smtp.live.com"
app.config["MAIL_PORT"] = 587
app.config["MAIL_USE_TLS"] = True
app.config["MAIL_USERNAME"] = creds.cred['mailu']
app.config["MAIL_PASSWORD"] = creds.cred['mailpass']
mail.init_app(app)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Model
class List(db.Model):
id = db.Column(db.Integer, primary_key=True)
name_a = db.Column(db.Unicode(64))
tag_f1 = db.Column(db.String(255))
def __unicode__(self):
def create_app(testing=False, live=False):
from bhs_api.models import User, Role
from bhs_api.forms import LoginForm
app = Flask(__name__)
app.testing = testing
# load the config file
conf = get_conf()
app.conf = conf
# Our config - need to move everything here
app.config['VIDEO_BUCKET_URL'] = "https://storage.googleapis.com/bhs-movies"
app.config['IMAGE_BUCKET_URL'] = "https://storage.googleapis.com/bhs-flat-pics"
# Set app config
app.config['DEBUG'] = True
app.config['FRONTEND_SERVER'] = conf.frontend_server
app.config['DEFAULT_NEXT'] = '/mjs'
# Security Config
app.config['SECRET_KEY'] = conf.secret_key
app.config['WTF_CSRF_ENABLED'] = False
app.config['SECURITY_PASSWORDLESS'] = True
app.config['SECURITY_EMAIL_SENDER'] = 'BH Databases<*****@*****.**>'
app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = 'email'
app.config['SECURITY_EMAIL_SUBJECT_PASSWORDLESS'] = 'Login link for Your Jewish Story'
app.config['SECURITY_POST_LOGIN_VIEW'] = '/mjs'
app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = ('email', 'username', 'hash')
# Mail Config
app.config['MAIL_SERVER'] = conf.mail_server
app.config['MAIL_PORT'] = conf.mail_port
# Mail optional username and password
try:
app.config['MAIL_USERNAME'] = conf.mail_username
app.config['MAIL_PASSWORD'] = conf.mail_password
except AttributeError:
pass
# DB Config
app.config['MONGODB_DB'] = conf.user_db_name
app.config['MONGODB_HOST'] = conf.user_db_host
app.config['MONGODB_PORT'] = conf.user_db_port
# Redis
app.config['REDIS_HOST'] = conf.redis_host
app.config['REDIS_PORT'] = conf.redis_port
app.config['REDIS_PASSWORD'] = getattr(conf, 'redis_password', None)
# CACHING
app.config['CACHING_TTL'] = conf.caching_ttl
app.mail = Mail(app)
app.db = MongoEngine(app)
app.user_datastore = MongoEngineUserDatastore(app.db, User, Role)
app.security = Security(app, app.user_datastore,
passwordless_login_form=LoginForm)
# Create database connection object
app.client_data_db = pymongo.MongoClient(conf.data_db_host, conf.data_db_port,
read_preference=pymongo.ReadPreference.SECONDARY_PREFERRED)
app.data_db = app.client_data_db[conf.data_db_name]
# Create the elasticsearch connection
app.es = elasticsearch.Elasticsearch(conf.elasticsearch_host)
app.es_data_db_index_name = getattr(conf, "elasticsearch_data_index", app.data_db.name)
# Add the user's endpoints
from bhs_api.user import user_endpoints
app.register_blueprint(user_endpoints)
# Add the v1 endpoint
from bhs_api.v1_endpoints import v1_endpoints
app.register_blueprint(v1_endpoints, url_prefix='/v1')
# Initialize autodoc - https://github.com/acoomans/flask-autodoc
#allow CORS
cors = CORS(app, origins=['*'], headers=['content-type', 'accept',
'authentication-token', 'Authorization'])
# logging
if live:
app.config['PROPAGATE_EXCEPTIONS'] = True
try:
fh = logging.FileHandler(conf.log_file)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
app.logger.addHandler(fh)
except AttributeError:
pass
# redis
try:
app.redis = redis.StrictRedis(host=conf.redis_host,
port=conf.redis_port,
password = app.config['REDIS_PASSWORD'],
db=0)
except AttributeError:
app.redis = None
return app, conf
# Bootstrap
from flask_bootstrap import Bootstrap
Bootstrap(app)
# Assets
from flask.ext.assets import Environment
assets = Environment(app)
# Ensure output directory exists
assets_output_dir = os.path.join(FLASK_APP_DIR, '..', 'static', 'gen')
if not os.path.exists(assets_output_dir):
os.mkdir(assets_output_dir)
# Email
from flask.ext.mail import Mail
app.mail = Mail(app)
# Memcache
from flask.ext.cache import Cache
app.cache = Cache(app)
# MongoEngine
from flask_application.models import db
app.db = db
app.db.init_app(app)
from flask.ext.security import Security, MongoEngineUserDatastore
from flask_application.users.models import User, Role
# Setup Flask-Security
app.user_datastore = MongoEngineUserDatastore(app.db, User, Role)
def get_app(config=None, media_storage=None, config_object=None):
"""App factory.
:param config: configuration that can override config from `default_settings.py`
:param media_storage: media storage class to use
:param config_object: config object to load (can be module name, module or an object)
:return: a new SuperdeskEve app instance
"""
abs_path = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
app_config = flask.Config(abs_path)
app_config.from_object('superdesk.default_settings')
app_config.setdefault('APP_ABSPATH', abs_path)
app_config.setdefault('DOMAIN', {})
app_config.setdefault('SOURCES', {})
if config_object:
app_config.from_object(config_object)
try:
app_config.update(config or {})
except TypeError:
app_config.from_object(config)
if not media_storage and app_config.get('AMAZON_CONTAINER_NAME'):
media_storage = AmazonMediaStorage
elif not media_storage:
media_storage = SuperdeskGridFSMediaStorage
app = eve.Eve(data=SuperdeskDataLayer,
auth=TokenAuth,
media=media_storage,
settings=app_config,
json_encoder=MongoJSONEncoder,
validator=SuperdeskValidator,
template_folder=os.path.join(abs_path, 'templates'))
superdesk.app = app
custom_loader = jinja2.ChoiceLoader([
jinja2.FileSystemLoader('templates'),
jinja2.FileSystemLoader(
os.path.join(
os.path.dirname(os.path.dirname(os.path.realpath(__file__))),
'templates'))
])
app.jinja_loader = custom_loader
app.mail = Mail(app)
app.sentry = SuperdeskSentry(app)
@app.errorhandler(SuperdeskError)
def client_error_handler(error):
"""Return json error response.
:param error: an instance of :attr:`superdesk.SuperdeskError` class
"""
return send_response(None,
(error.to_dict(), None, None, error.status_code))
@app.errorhandler(500)
def server_error_handler(error):
"""Log server errors."""
app.sentry.captureException()
superdesk.logger.exception(error)
return_error = SuperdeskApiError.internalError()
return client_error_handler(return_error)
init_celery(app)
installed = set()
def install_app(module_name):
if module_name in installed:
return
installed.add(module_name)
app_module = importlib.import_module(module_name)
try:
app_module.init_app(app)
except AttributeError:
pass
for module_name in app.config.get('INSTALLED_APPS', []):
install_app(module_name)
for module_name in app.config.get('CORE_APPS', []):
install_app(module_name)
for resource in superdesk.DOMAIN:
app.register_resource(resource, superdesk.DOMAIN[resource])
for blueprint in superdesk.BLUEPRINTS:
prefix = app.api_prefix or None
app.register_blueprint(blueprint, url_prefix=prefix)
for name, jinja_filter in superdesk.JINJA_FILTERS.items():
app.jinja_env.filters[name] = jinja_filter
if not app_config.get('TESTING', False):
# we can only put mapping when all resources are registered
app.data.init_elastic(app)
# instantiate registered provider classes (leave non-classes intact)
for key, provider in registered_feeding_services.items():
registered_feeding_services[key] = provider() if isinstance(
provider, type) else provider
configure_logging(app.config['LOG_CONFIG_FILE'])
return app
if settings.USE_SENTRY:
sentry = Sentry(app)
sockets = Sockets(app)
redis = redis.from_url(settings.BROKER_URL)
manager = Manager(app)
server = Server(host="0.0.0.0", port=5000, use_debugger=True, use_reloader=True)
serverProd = Server(host="0.0.0.0", port=5000, use_debugger=False, use_reloader=False)
manager.add_command('runserver', server)
manager.add_command('runserverprod', serverProd)
mail = Mail(app) # Initialize Flask-Mail
babel = Babel(app) # Initialize Flask-Babel
vote_backend = VoteBackend()
vote_backend.start()
loginManager = LoginManager(app=app)
class AdminCommand(Command):
option_list = (
Option('--addadmin', '-a', dest='addname'),
)
def run(self, addname = None):
if addname is not None:
def get_app(config=None, media_storage=None):
"""App factory.
:param config: configuration that can override config from `settings.py`
:return: a new SuperdeskEve app instance
"""
if config is None:
config = {}
abs_path = os.path.abspath(os.path.dirname(__file__))
config.setdefault('APP_ABSPATH', abs_path)
for key in dir(superdesk.factory.settings):
if key.isupper():
config.setdefault(key, getattr(superdesk.factory.settings, key))
if media_storage is None:
media_storage = SuperdeskGridFSMediaStorage
config.setdefault('DOMAIN', {})
configure_logging(config)
app = eve.Eve(data=SuperdeskDataLayer,
auth=TokenAuth,
media=media_storage,
settings=config,
json_encoder=MongoJSONEncoder,
validator=SuperdeskValidator)
superdesk.app = app
custom_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.FileSystemLoader([abs_path + '/../templates'])
])
app.jinja_loader = custom_loader
app.mail = Mail(app)
@app.errorhandler(SuperdeskError)
def client_error_handler(error):
"""Return json error response.
:param error: an instance of :attr:`superdesk.SuperdeskError` class
"""
return send_response(None,
(error.to_dict(), None, None, error.status_code))
@app.errorhandler(500)
def server_error_handler(error):
"""Log server errors."""
app.sentry.captureException()
superdesk.logger.exception(error)
return_error = SuperdeskApiError.internalError()
return client_error_handler(return_error)
init_celery(app)
for module_name in app.config['INSTALLED_APPS']:
app_module = importlib.import_module(module_name)
try:
app_module.init_app(app)
except AttributeError:
pass
for resource in superdesk.DOMAIN:
app.register_resource(resource, superdesk.DOMAIN[resource])
for blueprint in superdesk.BLUEPRINTS:
prefix = app.api_prefix or None
app.register_blueprint(blueprint, url_prefix=prefix)
# we can only put mapping when all resources are registered
app.data.elastic.put_mapping(app)
app.sentry = sentry
sentry.init_app(app)
# instantiate registered provider classes (leave non-classes intact)
for key, provider in providers.items():
providers[key] = provider() if isinstance(provider, type) else provider
return app
__author__ = 'Xu Zhao'
from flask import Flask
from flask.ext.mail import Mail, Message
app = Flask(__name__)
app.config['MAIL_SERVER'] = 'smtp.163.com'
app.config['MAIL_PORT'] = 25
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
mail = Mail(app)
msg = Message('Notification',
recipients=['*****@*****.**'],
sender='*****@*****.**')
msg.body = 'Please notify your department to attend the conference.'
#msg.html = '<b>Please </b>'
with app.app_context():
mail.send(msg)
print 'send ok'
def setUp(self):
taikoa.app.config['TESTING'] = True
taikoa.mail = Mail(taikoa.app)
self.app = taikoa.app.test_client()
def create_app(config):
app = Flask(__name__)
app.debug = True
app.config['SECRET_KEY'] = 'secret'
app.config['TESTING'] = True
for key, value in config.items():
app.config[key] = value
mail = Mail(app)
app.extensions['mail'] = mail
@app.route('/')
def index():
return render_template('index.html', content='Home Page')
@app.route('/profile')
@login_required
def profile():
return render_template('index.html', content='Profile Page')
@app.route('/post_login')
@login_required
def post_login():
return render_template('index.html', content='Post Login')
@app.route('/http')
@http_auth_required
def http():
return 'HTTP Authentication'
@app.route('/http_custom_realm')
@http_auth_required('My Realm')
def http_custom_realm():
return render_template('index.html', content='HTTP Authentication')
@app.route('/token')
@auth_token_required
def token():
return render_template('index.html', content='Token Authentication')
@app.route('/multi_auth')
@auth_required('session', 'token', 'basic')
def multi_auth():
return render_template('index.html',
content='Session, Token, Basic auth')
@app.route('/post_logout')
def post_logout():
return render_template('index.html', content='Post Logout')
@app.route('/post_register')
def post_register():
return render_template('index.html', content='Post Register')
@app.route('/admin')
@roles_required('admin')
def admin():
return render_template('index.html', content='Admin Page')
@app.route('/admin_and_editor')
@roles_required('admin', 'editor')
def admin_and_editor():
return render_template('index.html', content='Admin and Editor Page')
@app.route('/admin_or_editor')
@roles_accepted('admin', 'editor')
def admin_or_editor():
return render_template('index.html', content='Admin or Editor Page')
@app.route('/unauthorized')
def unauthorized():
return render_template('unauthorized.html')
@app.route('/coverage/add_role_to_user')
def add_role_to_user():
u = ds.find_user(email='*****@*****.**')
r = ds.find_role('admin')
ds.add_role_to_user(u, r)
return 'success'
@app.route('/coverage/remove_role_from_user')
def remove_role_from_user():
u = ds.find_user(email='*****@*****.**')
ds.remove_role_from_user(u, 'admin')
return 'success'
@app.route('/coverage/deactivate_user')
def deactivate_user():
u = ds.find_user(email='*****@*****.**')
ds.deactivate_user(u)
return 'success'
@app.route('/coverage/activate_user')
def activate_user():
u = ds.find_user(email='*****@*****.**')
ds.activate_user(u)
return 'success'
@app.route('/coverage/invalid_role')
def invalid_role():
return 'success' if ds.find_role('bogus') is None else 'failure'
return app
from flask import Flask
from flask.ext.bootstrap import Bootstrap
from flask.ext.mail import Mail
from flask.ext.moment import Moment
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask_oauthlib.client import OAuth
from config import config, GITHUB_SETTINGS
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
oauth = OAuth()
github = oauth.remote_app('github', **GITHUB_SETTINGS)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
oauth.init_app(app)
def get_app(config=None):
"""App factory.
:param config: configuration that can override config from `settings.py`
:return: a new SuperdeskEve app instance
"""
if config is None:
config = {}
for key in dir(settings):
if key.isupper():
config.setdefault(key, getattr(settings, key))
media_storage = SuperdeskGridFSMediaStorage
if config['AMAZON_CONTAINER_NAME']:
from superdesk.storage.amazon.amazon_media_storage import AmazonMediaStorage
from superdesk.storage.amazon.import_from_amazon import ImportFromAmazonCommand
media_storage = AmazonMediaStorage
superdesk.command('import:amazon', ImportFromAmazonCommand())
config['DOMAIN'] = {}
app = eve.Eve(data=superdesk.SuperdeskDataLayer,
auth=TokenAuth,
media=media_storage,
settings=config,
json_encoder=MongoJSONEncoder,
validator=SuperdeskValidator)
custom_loader = jinja2.ChoiceLoader(
[app.jinja_loader,
jinja2.FileSystemLoader(['superdesk/templates'])])
app.jinja_loader = custom_loader
app.mail = Mail(app)
app.on_fetched_resource += signals.proxy_resource_signal('read', app)
app.on_fetched_item += signals.proxy_item_signal('read', app)
app.on_inserted += signals.proxy_resource_signal('created', app)
@app.errorhandler(superdesk.SuperdeskError)
def client_error_handler(error):
"""Return json error response.
:param error: an instance of :attr:`superdesk.SuperdeskError` class
"""
return send_response(None,
(error.to_dict(), None, None, error.status_code))
@app.errorhandler(500)
def server_error_handler(error):
"""Log server errors."""
app.sentry.captureException()
logger.exception(error)
return_error = superdesk.SuperdeskError(status_code=500)
return client_error_handler(return_error)
init_celery(app)
for module_name in app.config['INSTALLED_APPS']:
app_module = importlib.import_module(module_name)
try:
app_module.init_app(app)
except AttributeError:
pass
for resource in superdesk.DOMAIN:
app.register_resource(resource, superdesk.DOMAIN[resource])
for blueprint in superdesk.BLUEPRINTS:
prefix = app.api_prefix or None
app.register_blueprint(blueprint, url_prefix=prefix)
# we can only put mapping when all resources are registered
app.data.elastic.put_mapping(app)
app.sentry = sentry
sentry.init_app(app)
superdesk.app = app
return app
from flask import Flask, g, session, url_for, send_from_directory
from flask.ext.mail import Mail, Message
from sphinx.websupport import WebSupport
app = Flask(__name__)
app.config.from_envvar('SPHINXWEB_SETTINGS')
@app.route('/static/_<section>/<path:name>')
def sphinx_statics(section, name):
directory = path.join(app.config['BUILD_DIR'], 'static', '_' + section)
return send_from_directory(directory, name)
mail = Mail(app)
from sphinxweb.models import db_session, User
NEW_COMMENT_MAIL = '''\
A new comment has been submitted for moderation:
Document: %(document)s
Author: %(username)s
Text:
%(text)s
Proposal:
%(proposal)s
Moderate: %(url)s
def init_app(init=None,
config=None,
pyfile=None,
template_folder='templates',
index=False,
error=True,
is_web=False,
is_api=False):
""" 创建应用 """
app = Flask(__name__, template_folder=template_folder)
if config:
app.config.from_object(config)
if pyfile:
app.config.from_pyfile(pyfile)
ENVVAR = app.config.get('ENVVAR')
if ENVVAR and os.environ.get(ENVVAR):
app.config.from_envvar(app.config['ENVVAR'])
if app.debug:
app.config.setdefault('DEBUG_TB_ENABLED', True)
app.config.setdefault('DEBUG_TB_PANELS', DEBUG_TB_PANELS)
app.config.setdefault('DEBUG_TB_INTERCEPT_REDIRECTS', False)
DebugToolbarExtension(app)
app.config.setdefault('SESSION_REFRESH_EACH_REQUEST', False)
app.is_web = is_web
app.is_api = is_api
app.is_back = os.environ.get('CHIKI_BACK') == 'true'
app.static_folder = app.config.get('STATIC_FOLDER')
app.mail = Mail(app)
def get_data_path(name):
return os.path.abspath(
os.path.join(app.config.get('DATA_FOLDER'), name))
if app.config.get('USER_AGENT_LIMIT'):
@app.before_request
def before_request():
if request.path == current_app.config.get('WEROBOT_ROLE'):
return
if not app.debug and 'micromessenger' not in request.headers[
'User-Agent'].lower():
return error_msg('请用微信客户端扫一扫')
app.get_data_path = get_data_path
init_babel(app)
init_redis(app)
if app.config.get('SESSION_TYPE'):
Session(app)
init_jinja(app)
init_logger(app)
init_oauth(app)
init_page(app)
db.init_app(app)
media.init_app(app)
with app.app_context():
cm.init_app(app)
Choices.init()
if callable(init):
init(app)
@app.context_processor
def context_processor():
return dict(Item=Item, Menu=Menu)
if error:
init_error_handler(app)
if index:
@app.route('/')
def index():
return redirect(app.config.get('INDEX_REDIRECT'))
blueprint = Blueprint('chiki',
__name__,
template_folder=os.path.join(TEMPLATE_ROOT, 'chiki'))
app.register_blueprint(blueprint)
if app.is_back:
@app.route('/chiki_back')
def chiki_back():
return 'true'
with app.app_context():
if hasattr(app, 'user_manager'):
user = um.models.User.objects(id=100000).first()
if not user:
user = um.models.User(id=100000,
phone='13888888888',
password='******',
nickname=app.config.get('SITE_NAME'))
user.save()
if not user.avatar and os.path.exists(
app.get_data_path('imgs/logo.jpg')):
with open(app.get_data_path('imgs/logo.jpg')) as fd:
user.avatar = dict(stream=StringIO(fd.read()),
format='jpg')
user.save()
return app
def create_app(**kwargs_config):
"""
Create the flask app
:param kwargs_config: overwrite any base level config
:return: flask.Flask instance
"""
app = factory.create_app(
app_name=__name__.replace('.app', ''),
**kwargs_config
)
api = Api(app)
api.unauthorized = lambda noop: noop #Overwrite WWW-Authenticate challenge on 401
csrf = CsrfProtect(app)
mail = Mail(app)
cors = CORS(app,
origins=app.config.get('CORS_DOMAINS'),
allow_headers=app.config.get('CORS_HEADERS'),
methods=app.config.get('CORS_METHODS'),
supports_credentials=True,
)
app.json_encoder = JSONEncoder
api.add_resource(Bootstrap, '/bootstrap')
api.add_resource(StatusView, '/status')
api.add_resource(OAuthProtectedView, '/protected')
api.add_resource(CSRFView, '/csrf')
api.add_resource(UserAuthView, '/user')
api.add_resource(DeleteAccountView, '/user/delete')
api.add_resource(UserRegistrationView, '/register')
api.add_resource(LogoutView, '/logout')
api.add_resource(PersonalTokenView, '/token')
api.add_resource(UserInfoView, '/info/<string:account_data>')
api.add_resource(ChangePasswordView, '/change-password')
api.add_resource(ChangeEmailView, '/change-email')
api.add_resource(VerifyEmailView, '/verify/<string:token>')
api.add_resource(ForgotPasswordView, '/reset-password/<string:token>')
app.ts = URLSafeTimedSerializer(app.config["SECRET_KEY"])
@app.login_manager.unauthorized_handler
def unauthorized():
"""
flask_login callback when @login_required is not met.
This overrides the default behavior or re-directing to a login view
"""
abort(401)
# Register custom error handlers
if not app.config.get('DEBUG'):
app.errorhandler(AdsWSError)(on_adsws_error)
app.errorhandler(AdsWSFormError)(on_adsws_form_error)
@csrf.error_handler
def csrf_error(reason):
app.logger.warning("CSRF Blocked: {reason}".format(reason=reason))
return jsonify(dict(error="Invalid CSRF token")), 400
return app
import os
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.principal import Principal, Permission, RoleNeed
from flask.ext.mail import Mail
from config import basedir
from sqlalchemy import *
####PDF library-> pip3 install --pre xhtml2pdf
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
principals = Principal(app)
# Create a permission with a single Need, in this case a RoleNeed.
admin_permission = Permission(RoleNeed('admin'))
lm.init_app(app)
lm.login_view = 'login'
mail_ext = Mail(app)
from app import login, prendas, pedido, accesorios, cliente, prospectos, buscar, municipio, excel, abonos
from app.model import user
from app.model import prenda
from app.model import color
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try: app.config.from_object('local_settings')
except: pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
babel = Babel(app) # Initialize Flask-Babel
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
mail = Mail(app) # Initialize Flask-Mail
@babel.localeselector
def get_locale():
translations = [str(translation) for translation in babel.list_translations()]
return request.accept_languages.best_match(translations)
# Define User model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean(), nullable=False, default=False)
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, default='')
# Removed email field
# Removed confirmed_at field
reset_password_token = db.Column(db.String(100), nullable=False, default='')
# Define UserEmail model.
class UserEmail(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
is_primary = db.Column(db.Boolean(), nullable=False, default=False)
user = db.relationship("User", uselist=False)
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User, # Select database adapter
UserEmailClass=UserEmail) # Allow Multiple Emails per User
user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app
# Display Login page or Profile page
@app.route('/')
def home_page():
if current_user.is_authenticated():
return redirect(url_for('profile_page'))
else:
return redirect(url_for('user.login'))
# The '/profile' page requires a logged-in user
@app.route('/profile')
@login_required # Use of @login_required decorator
def profile_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Profile Page{%endtrans%}</h2>
<p> {%trans%}Hello{%endtrans%}
{{ current_user.username or current_user.email }},</p>
<p> <a href="{{ url_for('user.change_username') }}">
{%trans%}Change username{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.change_password') }}">
{%trans%}Change password{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.manage_emails') }}">
{%trans%}Manage emails{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
return app
# 命令行可执行启动参数
manager = Manager(app)
# 调试模式
# manager.add_command("runserver", Server(use_debugger=True))
# 用户界面插件
bootstrap = Bootstrap(app)
# 本地化时间
moment = Moment(app)
# 数据库实例
db = SQLAlchemy(app)
# 数据库迁移
migrate = Migrate(app=app, db=db, directory='migrations')
manager.add_command('db', MigrateCommand)
# 邮件
mail = Mail(app=app)
# 定义模型
class Role(db.Model):
"""docstring for Role"""
# 定义数据库使用的表名, 若未定义, 会生成默认名称
__tablename__ = 'roles'
# 模型属性
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
# users属性代表此关系的面向对象视角
# 返回与角色关联的用户组列表
# 第一个参数, 另一端是哪个模型
# backref, 向User添加role属性, 可替代role.id访问Role, 得到的是对象, 而非外键值
users = db.relationship('User', backref='role', lazy='dynamic')
def create_app(config=None):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__,
static_folder=os.path.join(ROOT_DIR, "..", "static"))
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY',
os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(
sorted(
os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH)
if x.endswith(".yml")))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'postgresql://localhost/{0}'.format(app.config['app_name'])))
if os.path.exists("/dev/log"):
syslog_handler = logbook.SyslogHandler(app.config['app_name'],
"/dev/log")
syslog_handler.push_application()
del app.logger.handlers[:]
redirect_logging()
app.logger.info("Started")
Mail(app)
from . import models
models.db.init_app(app)
from . import auth
Security(app, auth.user_datastore)
from .views import views
from .setup import setup
blueprints = [views, setup]
from .errors import errors
for blueprint in blueprints:
app.register_blueprint(blueprint)
for code in errors:
app.errorhandler(code)(errors[code])
return app
def create_app():
""" Flask application factory """
# Setup Flask app and app.config
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
mail = Mail(app) # Initialize Flask-Mail
# Define User model. Make sure to add flask.ext.user UserMixin !!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean(), nullable=False, default=False)
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, default='')
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
reset_password_token = db.Column(db.String(100),
nullable=False,
default='')
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<p><a href="{{ url_for('home_page') }}">Home page</a> |
<a href="{{ url_for('profile_page') }}">Profile page</a></p>
<h2>Home page</h2>
{% if current_user.is_authenticated() %}
<p><a href="{{ url_for('user.logout') }}">Sign out</a></p>
{% else %}
<p><a href="{{ url_for('user.login') }}">Sign in</a></p>
{% endif %}
{% endblock %}
""")
# The Profile page requires a logged-in user
@app.route('/profile')
@login_required # Use of @login_required decorator
def profile_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<p><a href="{{ url_for('home_page') }}">Home page</a> |
<a href="{{ url_for('profile_page') }}">Profile page</a></p>
<h2>Profile page</h2>
<p>Username: {{ current_user.username }}</p>
<p>Email: {{ current_user.email }} </p>
<p><a href="{{ url_for('user.change_username') }}">Change username</a></p>
<p><a href="{{ url_for('user.change_password') }}">Change password</a></p>
<p><a href="{{ url_for('user.logout') }}">Sign out</a></p>
{% endblock %}
""")
return app
def mail_bulk_connection():
mail = Mail(app)
return mail.connect()
def init_app(app, test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app.config.from_object(__name__ + '.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try:
app.config.from_object('local_settings')
except:
pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
babel = Babel(app) # Initialize Flask-Babel
mail = Mail(app) # Initialize Flask-Mail
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db,
User,
UserInvitationClass=UserInvitation)
user_manager = UserManager(db_adapter, app)
# Create regular 'member' user
if not User.query.filter(User.username == 'member').first():
user = User(username='******',
email='*****@*****.**',
active=True,
password=user_manager.hash_password('Password1'),
confirmed_at=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username == 'user007').first():
user1 = User(username='******',
email='*****@*****.**',
active=True,
password=user_manager.hash_password('Password1'))
user1.roles.append(Role(name='secret'))
user1.roles.append(Role(name='agent'))
db.session.add(user1)
db.session.commit()
# The '/' page is accessible to anyone
@app.route('/')
def home_page():
# if current_user.is_authenticated:
# return user_profile_page()
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Home Page{%endtrans%}</h2>
<p><a href="{{ url_for('user.login') }}">{%trans%}Sign in{%endtrans%}</a></p>
{% endblock %}
""")
# The '/profile' page requires a logged-in user
@app.route('/user/profile')
@login_required # Use of @login_required decorator
@confirm_email_required
def user_profile_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Profile Page{%endtrans%}</h2>
<p> {%trans%}Hello{%endtrans%}
{{ current_user.username or current_user.email }},</p>
<p> <a href="{{ url_for('user.change_username') }}">
{%trans%}Change username{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.change_password') }}">
{%trans%}Change password{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.invite') }}">
{%trans%}Invite User{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The '/special' page requires a user that has the 'special' AND ('sauce' OR 'agent') role.
@app.route('/special')
@roles_required('secret',
['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Special Page{%endtrans%}</h2>
{% endblock %}
""")
# For testing only
app.db = db
app.UserEmailClass = UserEmail
return app
app = Flask(__name__) # create Flask WSGI application
app.config['SECRET_KEY'] = environ.get('SECRET_KEY')
# mail configuration settings
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = environ.get('MAIL_PASSWORD')
app.config['AROWF_MAIL_SUBJECT_PREFIX'] = '[AROWF]'
app.config['AROWF_MAIL_SENDER'] = 'AROWF Admin'
app.config['AROWF_ADMIN'] = environ.get('AROWF_ADMIN')
bootstrap = Bootstrap(app) # create Bootstrap instance
mail = Mail(app) # create Mail instances
def send_async_email(app, msg):
with app.app_context():
mail.send(msg)
def send_email(to, subject, template, **kwargs):
msg = Message(app.config['AROWF_MAIL_SUBJECT_PREFIX'] + ' ' + subject,
sender=app.config['AROWF_ADMIN'],
recipients=[to])
msg.body = render_template(template + '.txt', **kwargs)
msg.html = render_template(template + '.html', **kwargs)
thr = Thread(target=send_async_email, args=[app, msg])
thr.start()
return fn(*args, **kwargs)
return decorated_view
# CSRF Protection
csrf_protect = flask_wtf.CsrfProtect(app)
# Initalize DB object
db = SQLAlchemy(app)
# Initalize Bcrypt object for password hashing
bcrypt = Bcrypt(app)
# Initalize flask mail object for email notifications
flask_mail = Mail(app)
# Decorator for Token Auth on API Requests
from sleepypuppy.admin.admin.models import Admin as AdminModel
# The dectorat function for API token auth
def require_appkey(view_function):
@wraps(view_function)
def decorated_function(*args, **kwargs):
if request.headers.get('Token'):
for keys in AdminModel.query.all():
print keys.api_key
if request.headers.get('Token') == keys.api_key:
return view_function(*args, **kwargs)
abort(401)
def create_app(config=None):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__, static_folder=os.path.join(ROOT_DIR, "..", "static"))
app.config['COMBADGE_CONTACT_TIMEOUT'] = 60 * 60
app.config['SHA512SUM'] = '/usr/bin/sha512sum'
app.config['STORAGE_PATH'] = os.environ.get('STORAGE_PATH')
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY', os.path.join(ROOT_DIR, "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(sorted(os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH) if x.endswith(".yml")))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get('SQLALCHEMY_DATABASE_URI', 'postgresql://localhost/{0}'.format(app.config['app_name'])))
del app.logger.handlers[:]
redirect_logging()
app.logger.info("Started")
Mail(app)
if os.environ.get("SQLALCHEMY_LOG_QUERIES"):
logging.getLogger("sqlalchemy.engine").setLevel(logging.INFO)
app.raven = Sentry(
app,
client=raven.Client(
dsn=app.config.get("SENTRY_DSN"),
ignore_exceptions=[
SSHException,
JIRAError
],
),
)
from . import models
models.db.init_app(app)
from .errors import errors
from .blueprints import auth, beams, files, issues, trackers, user_datastore, users, views, keys
Security(app, user_datastore, register_blueprint=False)
app.register_blueprint(auth)
app.register_blueprint(beams, url_prefix="/beams")
app.register_blueprint(files, url_prefix="/files")
app.register_blueprint(issues, url_prefix="/issues")
app.register_blueprint(trackers, url_prefix="/trackers")
app.register_blueprint(users, url_prefix="/users")
app.register_blueprint(keys, url_prefix="/keys")
app.register_blueprint(views)
if app.config.get('DEBUG'):
from .blueprints import test_methods
app.register_blueprint(test_methods)
for code in errors:
app.errorhandler(code)(errors[code])
return app
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try:
app.config.from_object('local_settings')
except:
pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
babel = Babel(app) # Initialize Flask-Babel
mail = Mail(app) # Initialize Flask-Mail
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
return request.accept_languages.best_match(translations)
# Define User model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean(), nullable=False, default=False)
username = db.Column(db.String(50), nullable=False, unique=True)
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, default='')
reset_password_token = db.Column(db.String(100),
nullable=False,
default='')
# Relationships
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
# Define Role model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define UserRoles model
class UserRoles(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE'))
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username == 'user007').first():
user1 = User(username='******',
email='*****@*****.**',
active=True,
password=user_manager.hash_password('Password1'))
user1.roles.append(Role(name='secret'))
user1.roles.append(Role(name='agent'))
db.session.add(user1)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Home Page{%endtrans%}</h2>
<p> <a href="{{ url_for('profile_page') }}">{%trans%}Profile Page{%endtrans%}</a> (requires sign-in)</p>
<p> <a href="{{ url_for('special_page') }}">{%trans%}Special Page{%endtrans%}</a> (requires username 'user007' with password 'Password1')</p>
{% if current_user.is_authenticated() %}
<p> <a href="{{ url_for('user.logout') }}">{%trans%}Logout{%endtrans%}</a></p>
{% else %}
<p> <a href="{{ url_for('user.login') }}">{%trans%}Sign in{%endtrans%}</a> or
<a href="{{ url_for('user.register') }}">{%trans%}Register{%endtrans%}</a></p>
{% endif %}
{% endblock %}
""")
# The Profile page requires a logged-in user
@app.route('/profile')
@login_required # Use of @login_required decorator
def profile_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Profile Page{%endtrans%}</h2>
<p> {%trans%}Hello{%endtrans%}
{{ current_user.username or current_user.email }},</p>
<p> <a href="{{ url_for('home_page') }}">{%trans%}Home Page{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.change_username') }}">
{%trans%}Change username{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.change_password') }}">
{%trans%}Change password{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The Special page requires a user that has the 'special' AND ('sauce' OR 'agent') role.
@app.route('/special')
@roles_required('secret',
['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Special Page{%endtrans%}</h2>
{% endblock %}
""")
return app
