def test_locale(locale):
try:
app, db, admin = setup()
app.config['BABEL_DEFAULT_LOCALE'] = locale
babel = Babel(app)
Model1, _ = create_models(db)
view = CustomModelView(
Model1, db.session,
column_filters=['test1', 'bool_field', 'date_field', 'datetime_field', 'time_field']
)
admin.add_view(view)
client = app.test_client()
rv = client.get('/admin/model1/')
eq_(rv.status_code, 200)
rv = client.get('/admin/model1/new/')
eq_(rv.status_code, 200)
except:
print("Error on the following locale:", locale)
raise
def init_app(self, app):
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions['appshell'] = self
bp = Blueprint('appshell',
__name__,
template_folder='templates',
static_folder='static',
static_url_path=app.static_url_path + '/appshell')
app.register_blueprint(bp)
@app.context_processor
def context_processor():
return {"appshell": self}
@app.before_request
def check_access():
if not self.endpoint_accessible(request.endpoint, request.args):
return self.handle_forbidden_endpoint()
for n, f in template_globals.iteritems():
app.add_template_global(f, name=n)
Bootstrap(app)
app.config['BOOTSTRAP_SERVE_LOCAL'] = True
Babel(app)
for k, v in self.component_config.iteritems():
self.use_component(app, k, v)
def init_app(app):
Environment(app)
Babel(app)
Sentry(app)
db.init_app(app)
Migrate(app, db)
mail.init_app(app)
def init_babel(app):
""" 初始化语言本地化 """
babel = Babel(app)
@babel.localeselector
def get_locale():
return 'zh_Hans_CN'
from flask.ext.superadmin import Admin, model
from flask.ext.babelex import Babel
# Create application
app = Flask(__name__)
# Create dummy secrey key so we can use sessions
app.config['SECRET_KEY'] = '12345678'
# Create in-memory database
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.sqlite'
app.config['SQLALCHEMY_ECHO'] = True
db = SQLAlchemy(app)
# Initialize babel
babel = Babel(app)
@babel.localeselector
def get_locale():
override = request.args.get('lang')
if override:
session['lang'] = override
return session.get('lang', 'en')
# Create models
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
from flask import request, url_for, redirect
from wtforms import form, fields, validators
from wtforms.widgets import TextArea
from wtforms.fields import TextAreaField
from flask_admin.contrib import sqla
from flask_admin import helpers, expose, BaseView
from flask_admin.form.upload import FileUploadField
import flask_admin as flask_admin
import flask_login as login
from werkzeug.security import check_password_hash
app = Flask(__name__.split('.')[0], static_url_path='/static')
app.config.from_object('config')
db = SQLAlchemy(app)
babel = Babel(app)
#test ajout db
db.create_all()
# Florin - patch : Flask-babelex
babel.domain = 'flask_user'
babel.translation_directories = 'translations'
application = app
#import views
import models
import views
import admin
admin.init()
from flask.ext.assets import Environment, Bundle
from flask.ext.cache import Cache
from flask.ext.babelex import Babel, Domain
from flask.ext.mustache import FlaskMustache
from ._version import *
from .assets import assets, Version
from . import translations
__all__ = [
'baseframe', 'baseframe_js', 'baseframe_css', 'assets', 'Version', '_',
'__'
]
networkbar_cache = Cache(with_jinja2_ext=False)
cache = Cache()
babel = Babel()
baseframe_translations = Domain(translations.__path__[0], domain='baseframe')
_ = baseframe_translations.gettext
__ = baseframe_translations.lazy_gettext
class BaseframeBlueprint(Blueprint):
def init_app(self,
app,
requires=[],
bundle_js=None,
bundle_css=None,
assetenv=None):
"""
Initialize an app and load necessary assets.
from werkzeug.contrib.fixers import ProxyFix
coin = Flask(__name__, instance_relative_config=True) # __name__
coin.wsgi_app = ProxyFix(coin.wsgi_app)
# load the default configuration
coin.config.from_object('config.default')
# load the configuration from the instance folder
coin.config.from_pyfile('config.py')
# load the file specified by the APP_CONFIG_FILE environment variable
# variables defined here will override those in the default configuration
coin.config.from_envvar('APP_CONFIG_FILE', silent=True)
debugger = DebugToolbarExtension(coin)
babel = Babel(coin)
import admin
import security
import api
import views
import mail
cache.init_app(app)
assets = Environment(app)
assets.register('css',Bundle('source/style.less',depends='source/*.less',filters=['less','cleancss']),output='css/style.css')
assets.register('js',Bundle('js/jquery-2.1.1.min.js','js/bootstrap.min.js'),output='js/all.js')
app.register_blueprint(main)
app.register_blueprint(blog)
app.register_blueprint(docs)
app.register_blueprint(parts)
app.register_blueprint(search)
app.register_blueprint(rest)
babel = Babel(app,default_domain=website.translation.messages_domain)
app.jinja_env.filters['markdown_docs'] = website.cms.markdown_docs
app.jinja_env.filters['markdown_blog'] = website.cms.markdown_blog
app.jinja_env.globals['gettext_parts'] = website.translation.gettext_parts
app.jinja_env.globals['gettext_docs'] = website.translation.gettext_docs
@babel.localeselector
def get_locale():
lang_code = getattr(g,'lang_code',None)
if lang_code is None:
#the four most popular languages from the website
lang_code = request.accept_languages.best_match(website.translation.languages,'en')
return lang_code
rebuild_index(app)
module = import_module(module_name)
translations_dir = join(dirname(module.__file__),
'translations')
if exists(translations_dir):
domain = '-'.join((self.domain, plugin_name))
plugins_translations = Translations.load(
translations_dir, locale, domain=domain)
translations.merge(plugins_translations)
cache[str(locale)] = translations
return translations
domain = PluggableDomain(domain='udata')
babel = Babel(default_domain=domain)
# Create shortcuts for the default Flask domain
def gettext(*args, **kwargs):
return domain.gettext(*args, **kwargs)
_ = gettext
def ngettext(*args, **kwargs):
return domain.ngettext(*args, **kwargs)
N_ = ngettext
def pgettext(*args, **kwargs):
return domain.pgettext(*args, **kwargs)
# -*- code: utf-8 -*-
from __future__ import unicode_literals
from flask.ext.babelex import Babel
from studio.core.flask.app import StudioFlask
app = StudioFlask(__name__)
Babel(app=app, default_locale='zh')
with app.app_context():
from score import views
from score.panel import admin
from score.blueprints import blueprint_www
admin.init_app(app)
assert views
app.register_blueprint(blueprint_www)
app.add_url_rule('/apps/%s/<path:filename>' %
app.name, endpoint='static', #subdomain='static',
view_func=app.send_static_file)
def make_app(debug=False, **app_options):
global db, app, admin
app = Flask(__name__)
logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)
logg.debug("creating flask app %s", __name__)
try:
import arguments.config
app.config.from_object(arguments.config)
except ImportError:
pass
if app_options:
app.config.update(app_options)
app.config["RESTFUL_JSON"] = {'ensure_ascii': False}
app.config["SECRET_KEY"] = "dev"
app.config["DEBUG"] = debug
logg.debug("app config is:\n%s", pformat(dict(app.config)))
if debug:
app.debug = True
from werkzeug.debug import DebuggedApplication
app.wsgi_app = DebuggedApplication(app.wsgi_app, True)
app.jinja_env.add_extension('arguments.helper.templating.PyJadeExtension')
# initialize extensions
# flask-sqlalchemy
db = SQLAlchemy(app)
import arguments.database.datamodel
# flask-admin
admin = Admin(app, name="Arguments", template_mode="bootstrap3")
# markdown via flask-misaka
# TODO: markdown options should be configurable
markdown_opts = dict(
autolink=True,
fenced_code=True,
no_intra_emphasis=True,
strikethrough=True,
tables=True,
safelink=True,
escape=True,
smartypants=True
)
Misaka(app, **markdown_opts)
# user management provided by flask_login
login_manager = LoginManager(app)
login_manager.login_view = 'ekklesia.login'
# XXX: for testing: just use first user from the DB as anon user
# login_manager.anonymous_user = lambda: User.query.first()
from arguments.database.datamodel import User
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
# i18n via flask-babelex
babel = Babel(app)
@babel.localeselector
def get_locale():
return session["locale"]
# OAuth2 using flask-dance
init_oauth_ext(app)
# ajax lib flask-sijax
path = os.path.join('.', os.path.dirname(__file__), 'static/js/sijax/')
app.config['SIJAX_STATIC_PATH'] = path
app.config['SIJAX_JSON_URI'] = '/static/js/sijax/json2.js'
flask_sijax.Sijax(app)
@app.before_request
def set_locale():
locale = session.get("locale")
if locale:
logg.debug("locale from session: %s", locale)
else:
locale = request.accept_languages.best_match(['de', 'en', 'fr'])
logg.debug("locale from request: %s", locale)
session["locale"] = locale
g.locale = locale
import arguments.views
import arguments.views.admin
# import arguments_rest.api
# needed when running behind a reverse proxy.
app.wsgi_app = ProxyFix(app.wsgi_app)
return app
