def mail(self):
from flask.ext.mail import Mail
return Mail()
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.login import LoginManager
from flask.ext.bootstrap import Bootstrap
from flask.ext.mail import Mail
import os
app = Flask(__name__)
app.config.from_object("config")
db = SQLAlchemy(app)
migrate = Migrate(app, db)
login_manager = LoginManager()
bootstrap = Bootstrap(app)
mail = Mail(app)
from app import views, models
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
login_manager.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 = {}
config['APP_ABSPATH'] = os.path.abspath(os.path.dirname(__file__))
config['CONTENT_STATE'] = 'state'
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)
superdesk.app = app
custom_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.FileSystemLoader(['superdesk/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()
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)
return app
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'
@app.route('/page1')
def page_1():
return 'Page 1'
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
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
babel = Babel(app) # Initialize Flask-Babel
mail = Mail(app) # Initialize Flask-Mail
# Define the User data model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
# User authentication information
username = db.Column(db.String(50), nullable=True, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
# User email information
email = db.Column(db.String(255), nullable=True, unique=True)
confirmed_at = db.Column(db.DateTime())
# User information
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
first_name = db.Column(db.String(100), nullable=False, server_default='')
last_name = db.Column(db.String(100), nullable=False, server_default='')
# Relationships
roles = db.relationship('Role', secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
# Define UserEmail DataModel.
class UserEmail(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# User email information
email = db.Column(db.String(255), nullable=True, unique=True)
confirmed_at = db.Column(db.DateTime())
is_primary = db.Column(db.Boolean(), nullable=False, default=False)
# Relationship
user = db.relationship('User', uselist=False)
class UserInvitation(db.Model):
__tablename__ = 'user_invite'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), nullable=False)
# save the user of the invitee
invited_by_user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# token used for registration page to identify user registering
token = db.Column(db.String(100), nullable=False, server_default='')
# Define the Role data model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles data 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, 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
def register_mail(app):
mail = Mail(app)
'[in %(pathname)s:%(lineno)d]'
))
handler.setLevel(app.config.get('LOG_LEVEL'))
app.logger.addHandler(handler)
# 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)
else:
abort(401)
from flask import Flask
from flask.ext.mail import Mail, Message
import os
app = Flask(__name__)
app.config.update(DEBUG=True,
MAIL_SERVER='smtp.live.com',
MAIL_PROT=25,
MAIL_USE_TLS=True,
MAIL_USE_SSL=False,
MAIL_USERNAME='******',
MAIL_PASSWORD='******',
MAIL_DEBUG=True)
mail = Mail(app) #顺便从app.config中获取配置并执行一些实例化...
@app.route('/')
def index():
# sender 发送方哈，recipients 邮件接收方列表
msg = Message("Hi!This is a test ",
sender='*****@*****.**',
recipients=['*****@*****.**'])
msg.body = "This is a first email" # msg.body 邮件正文
with app.open_resource("F:\2281393651481.jpg") as fp: # msg.attach 邮件附件添加
msg.attach("image.jpg", "image/jpg",
fp.read()) # msg.attach("文件名", "类型", 读取文件）
mail.send(msg)
print "Mail sent"
return "Sent"
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
# Over-write app config # For automated tests
if test_config:
for key, value in test_config.items():
app.config[key] = value
# Setup Flask-Mail, Flask-Babel and Flask-SQLAlchemy
app.mail = Mail(app)
app.babel = babel = Babel(app)
app.db = db = SQLAlchemy(app)
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
return request.accept_languages.best_match(translations)
# Define the User-Roles pivot table
user_roles = db.Table(
'user_roles', db.Column('id', db.Integer(), primary_key=True),
db.Column('user_id', db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE')),
db.Column('role_id', db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE')))
# Define Role model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define User model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_profile_id = db.Column(db.Integer,
db.ForeignKey('user_profile.id'),
nullable=True,
default=None)
# Flask-User fields
active = db.Column(db.Boolean(), nullable=False, default=False)
email = db.Column(db.String(255), nullable=False, default='')
password = db.Column(db.String(255), nullable=False, default='')
# Relationships
user_profile = db.relationship('UserProfile',
uselist=False,
foreign_keys=[user_profile_id])
roles = db.relationship('Role',
secondary=user_roles,
backref=db.backref('users', lazy='dynamic'))
class UserProfile(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(50), nullable=False, default='')
last_name = db.Column(db.String(50), nullable=False, default='')
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db,
UserClass=User,
UserProfileClass=UserProfile)
user_manager = UserManager(db_adapter, app, register_form=MyRegisterForm)
# The '/' page is accessible to anyone
@app.route('/')
def home_page():
if current_user.is_authenticated():
return 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('/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.user_profile.first_name }},</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 %}
""")
return app
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_third(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, url_for=url_for)
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(config_filename=None):
app = Flask(__name__)
app.request_class = Request
app.url_map.converters['re'] = RegexConverter
if config_filename is None:
HerokuConfig(app)
else:
AppConfig(app, config_filename)
from_envvars(app.config, prefix='')
app.debug = app.config.get('DEBUG')
# TODO: these variables probably aren't unjsonnable anymore
# push all variables into the environment
unjsonnable = (datetime, timedelta)
data = {
k: json.dumps(v)
for k, v in app.config.items() if not isinstance(v, unjsonnable)
}
os.environ.update(data)
# app.logger.info('App is running on port %s', os.environ.get('PORT'))
if app.config['DEBUG'] is not True:
log_level = app.config.get('LOG_LEVEL', 'DEBUG')
app.logger.setLevel(getattr(logging, log_level.upper()))
import bauble.db as db
if 'LOG_SQL' in os.environ:
logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
db.init_app(app)
# register flask extensionsa
SSLify(app, permanent=True)
app.login_manager = LoginManager(app)
app.login_manager.login_view = "auth.login"
app.mail = Mail(app)
app.babel = Babel(app)
from .assets import init_app
init_app(app)
# TODO: just import everything controllers
for controller in ['auth', 'index', 'batch']:
module = import_module('bauble.controllers.{}'.format(controller))
app.register_blueprint(module.blueprint)
from bauble.resource import Resource
controllers = [
'search', 'family', 'genus', 'taxon', 'accession', 'plant', 'location',
'vernacular_name'
]
for controller in controllers:
module = import_module('bauble.controllers.{}'.format(controller))
for attr_name in dir(module):
attr = getattr(module, attr_name)
# find all the blueprints in the files
if isinstance(attr, Blueprint):
app.register_blueprint(attr)
# if isclass(attr) and issubclass(attr, Blueprint) and attr != Resource:
# app.register_blueprint(attr())
from bauble.error import init_errorhandlers
init_errorhandlers(app)
app.json_encoder = JSONEncoder
return app
def from_app(cls, app, sender=None, recipients=[]):
"""Get or create mail extension from app."""
mail = Mail(app) if 'mail' not in app.extensions else \
app.extensions['mail']
return cls(mail, sender, recipients)
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
# Over-write app config # For automated tests
if test_config:
for key, value in test_config.items():
app.config[key] = value
# Setup Flask-Mail, Flask-Babel and Flask-SQLAlchemy
app.mail = Mail(app)
app.babel = babel = Babel(app)
app.db = db = SQLAlchemy(app)
@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)
email = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, default='')
username = db.Column(db.String(50), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
reset_password_token = db.Column(
db.String(100), nullable=False, default='')
tweets = db.relationship('Tweet', backref='user', lazy='dynamic')
app.User = User
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(144), nullable=False, default='')
tweeted_at = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Select database adapter
# Init Flask-User and bind to app
user_manager = UserManager(db_adapter, app)
# Setup forms
class TweetForm(Form):
text = StringField('Message', validators=[Required()])
submit = SubmitField('Submit')
# The '/' page is accessible to anyone
@app.route('/')
def home_page():
if current_user.is_authenticated():
return profile_page()
return render_template("index.html")
# The '/profile' page requires a logged-in user
@app.route('/profile')
# Use of @login_required decorator
@login_required
def profile_page():
return render_template("profile.html")
@app.route('/tweet/new', methods=['GET', 'POST'])
@login_required
def new_tweet():
form = TweetForm()
if form.validate_on_submit():
tweet = Tweet()
form.populate_obj(tweet)
tweet.tweeted_at = datetime.now()
tweet.user = current_user
db.session.add(tweet)
db.session.commit()
flash("Your message is tweeted.")
return redirect(url_for("list_tweet"))
return render_template("new_tweet.html", form=form)
@app.route('/tweet/list')
@login_required
def list_tweet():
tweets = Tweet.query.order_by(Tweet.tweeted_at).limit(50)
print(tweets[0].user.username)
return render_template("list_tweet.html", tweets=tweets)
bootstrap = Bootstrap(app)
return app
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['MAIL_SERVER'] = 'smtp.qq.com'
app.config['MAIL_PORT'] = 587 # 465
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '[Flasky]'
app.config['FLASKY_MAIL_SENDER'] = 'Flasky Admin <' + app.config[
'MAIL_USERNAME'] + '>'
app.config['FLASKY_ADMIN'] = os.environ.get('FLASKY_ADMIN')
manager = Manager(app) # 命令行解析功能
bootstrap = Bootstrap(app) # 集成Bootstrap框架
moment = Moment(app) # 渲染日期和时间
db = SQLAlchemy(app) # 创建数据库
mail = Mail(app) # 初始化Flask-Mail
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
class NameForm(Form):
name = StringField('What is your name?', validators=[Required()])
submit = SubmitField('Submit')
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
users = db.relationship('User', backref='role', lazy='dynamic')
import os
from flask import Flask, request
from werkzeug.routing import Rule
from flask_sslify import SSLify
from flask.ext.babel import Babel
from flask.ext.mail import Mail
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.user import login_required, SQLAlchemyAdapter, UserManager, UserMixin
from flask.ext.user import roles_required
# Setup Flask and acquire configuration
app = Flask(__name__)
gmonki_config = 'config.' + os.environ['GMONKI_CONFIG']
app.config.from_object(gmonki_config)
app.mail = Mail(app)
app.babel = babel = Babel(app)
db = SQLAlchemy(app)
# extend app with Flask-SSLify, forcing https per config setting
if app.config['USE_SSLIFY']:
sslify = SSLify(app)
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(['en', 'nl'])
# jinja2 filters
# help produce bad json formatting
from flask import Flask, render_template, session
from flask.ext.bootstrap import Bootstrap
from flask.ext.mail import Mail
from flask.ext.wtf import Form
from wtforms import StringField, BooleanField, SubmitField, validators
from wtforms.validators import Required
from flask.ext.moment import Moment
from flask.ext.sqlalchemy import SQLAlchemy
from config import config
from flask.ext.login import LoginManager
from flask.ext.pagedown import PageDown
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
pagedown = PageDown()
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)
login_manager.init_app(app)
db.init_app(app)
def send(MessageClass, **kwargs):
# The Flask-Mail extension requires the app context to exist to instantiate
# the message.
with app.test_request_context() as request:
mailer = Mail(app)
mailer.send(MessageClass(**kwargs))
