def register_bundles(app):
assets = Environment(app)
assets.debug = app.config.get('ASSETS_DEBUG', False)
##
# CSS
css_global = Bundle(
'css/shared/normalize.scss',
'css/global.scss',
filters='scss, cssmin',
output='gen/global.css')
assets.register('css_global', css_global)
css_home = Bundle(
'css/home.scss',
filters='scss, cssmin',
#otheCssBundled
output='gen/home.css')
assets.register('css_home', css_home)
##
# Javascript
js_global = Bundle('js/jquery-1.9.1.js', 'js/global.js','js/someUtil.js')
js_global = Bundle(
Bundle(js_global),
#otherJsBundled,
output='gen/script.js'
)
assets.register('js_global', js_global)
def init_webassets(flask_app, config):
""" Initialize Flask-Assets extension. """
assets = Environment(flask_app)
assets.debug = flask_app.debug
dart_root = 'dart/web' if flask_app.debug else 'dart/build/web'
assets.register("less", Bundle(
"less/bootstrap/bootstrap.less",
"less/font-awesome/font-awesome.less",
filters="less",
output="combined/bootstrap.css",
depends="less/*.less"
))
assets.register('dart', Bundle(
dart_root + '/main.dart'
))
assets.register("javascript", Bundle(
'js/d3.js',
'js/markdown.js',
dart_root + '/packages/web_components/dart_support.js',
dart_root + '/packages/browser/dart.js',
output='combined/combined.js'
))
def assets_env(app):
env = Environment(app)
env.url = "/static"
# App Engine doesn't support automatic rebuilding.
env.auto_build = False
# This file needs to be shipped with your code.
env.manifest = ('file:' + os.path.join(root_dir, 'webassets.manifest'))
env.versions = 'hash:32'
# create static bundles
env.register('new_js',
'js/hiro.js',
filters='yui_js',
output="javascript/hiro.%(version)s.js")
env.register('hoc_js',
'js/hoc.js',
filters='yui_js',
output="javascript/hoc.%(version)s.js")
env.register('new_css',
'css/hiro.css',
filters='cssmin',
output="stylesheets/hiro.%(version)s.css")
env.register('hoc_css',
'css/hoc.css',
filters='cssmin',
output="stylesheets/hoc.%(version)s.css")
env.debug = app.config['DEBUG']
return env
def init_webassets(flask_app, config):
""" Initialize Flask-Assets extension. """
assets = Environment(flask_app)
assets.debug = flask_app.debug
dart_root = 'dart/web' if flask_app.debug else 'dart/build/web'
assets.register("less", Bundle(
"less/bootstrap/bootstrap.less",
"less/font-awesome/font-awesome.less",
filters="less",
output="combined/bootstrap.css",
depends="less/*.less"
))
assets.register('dart', Bundle(
dart_root + '/main.dart'
))
assets.register("javascript", Bundle(
'js/d3.js',
'js/markdown.js',
dart_root + '/packages/web_components/dart_support.js',
dart_root + '/packages/browser/dart.js',
output='combined/combined.js'
))
def init_app(app):
webassets = Environment(app)
webassets.register('apollo_css', apollo_css)
webassets.register('apollo_js', apollo_js)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def register_web_ui(mgr):
global manager, assets
manager = mgr
assets_cache = os.path.join(manager.config_base, '.webassets-cache')
if not os.path.isdir(assets_cache):
os.mkdir(assets_cache)
assets = Environment(webui_app)
assets.directory = assets_cache
for p in _get_plugin_paths():
assets.append_path(p, url="%s/plugin" % webui_app.url_path)
assets.cache = assets_cache
assets.url = '%s/cache' % webui_app.url_path
if 'debug' in manager.args:
assets.debug = True
load_assets()
load_ui_plugins()
register_app(webui_app.url_path, webui_app)
register_home('%s/' % webui_app.url_path)
def register_web_ui(mgr):
global manager, assets
manager = mgr
assets_cache = os.path.join(manager.config_base, '.webassets-cache')
if not os.path.isdir(assets_cache):
os.mkdir(assets_cache)
assets = Environment(webui_app)
assets.directory = assets_cache
for p in _get_plugin_paths():
assets.append_path(p, url="%s/plugin" % webui_app.url_path)
assets.cache = assets_cache
assets.url = '%s/cache' % webui_app.url_path
if 'debug' in manager.args:
assets.debug = True
load_assets()
load_ui_plugins()
register_app(webui_app.url_path, webui_app)
register_home('%s/' % webui_app.url_path)
def init_app(app):
webassets = Environment(app)
webassets.register("apollo_css", apollo_css)
webassets.register("apollo_js", apollo_js)
webassets.manifest = "cache" if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def init_app(app):
assets = Environment(app)
assets.debug = app.config.get('DEBUG', False)
assets.directory = app.static_folder
assets.url = app.static_url_path
assets.directory = app.static_folder
assets.append_path(assets_directory)
assets.append_path(app.static_folder)
def init_app(app):
webassets = Environment(app)
webassets.register('css_all', css_all)
webassets.register('js_vendor', js_vendor)
webassets.register('js_ie', js_ie)
webassets.register('js_main', js_main)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def create_app(config='dev'):
""" Flask application factory
:param str config: type of app to build, either "prod" or "dev"
"""
# Create flask application
app = Flask(__name__)
app.config.from_object('settings')
app.config['ENV'] = config
app.jinja_env.trim_blocks = True
# Debug toolbar (when debug=true)
debug_toolbar = DebugToolbarExtension(app)
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# Register Blueprints
app.register_blueprint(views_base.base)
app.register_blueprint(views_blog.blog)
# Flask-Assets; bundles all css/js files in minifed file
assets = Environment(app)
css_all = Bundle('css/bootstrap-flatly.min.css', 'css/highlightjs.min.css', 'css/font-awesome.css', 'css/main.css',
filters='cssmin', output='gen/style.css')
js_all = Bundle('js/vendor/jquery.min.js', 'js/vendor/bootstrap.min.js', 'js/vendor/showdown-gfm.min.js',
'js/vendor/highlight.min.js', 'js/main.js', filters='jsmin', output='gen/libs.js')
assets.register('css_all', css_all)
assets.register('js_all', js_all)
if app.config['DEBUG']:
assets.debug = True
app.config['ASSETS_DEBUG'] = True
# Set up Flask-User
babel = Babel(app)
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app
# Init the cache
cache.init_app(app)
Moment(app) # moment.js
Misaka(app, autolink=True, # Misaka Markdown
fenced_code=True, lax_html=True, strikethrough=True,
superscript=True, tables=True, wrap=True)
# Init Admin page
admin = Admin(app, index_view=AdminMain(endpoint='admin'))
admin.add_view(PostAdminView())
admin.add_view(NewPostView())
admin.add_view(ModelView(Comment, db.session))
static_path = os.path.join(BASE_DIR, 'app', 'static')
admin.add_view(FileAdminView(static_path, '/static/', name='Static Files'))
# Initialize DB
db.init_app(app)
return app
def bundle(app):
assets = Environment(app)
assets.debug = True
theme_bundle(assets)
base_bundle(assets)
app_bundle(assets)
return assets
def setup_assets(app):
assets = Environment(app)
assets.debug = app.debug
static_base = os.path.join(app.root_path, 'static')
bootstrap_files = [os.path.relpath(path, static_base) for path in
glob(os.path.join(static_base, 'js/lib/bootstrap-*.js'))]
bootstrap = Bundle(*bootstrap_files)
js = Bundle('js/lib/jquery-2.0.2.js', 'js/lib/underscore.js', bootstrap, 'js/dict8or.js',
filters='rjsmin', output='assets/bundle.%(version)s.js')
css = Bundle('less/lib/bootstrap.less', 'less/core.less',
filters=('less', 'cssrewrite', 'cssmin'), output='assets/bundle.%(version)s.css')
assets.register('js_all', js)
assets.register('css_all', css)
def setup_bundles(app):
assets_env = Environment(app)
assets_env.url = '/statics'
assets_env.manifest = 'file:Compiled/static-manifest-version'
assets_env.cache = False
assets_env.auto_build = False
assets_env.debug = app.config.get('DEVELOPMENT') == True
# load and register bundles
config_path = app.instance_path + '/config/asset_bundles.yaml'
bundles = YAMLLoader(config_path).load_bundles()
for name, bundle in bundles.iteritems():
assets_env.register(name, bundle)
app.assets_env = assets_env
def init_app(app):
assets = Environment(app)
assets.debug = app.config.get('DEBUG', False)
assets.directory = app.static_folder
assets.url = app.static_url_path
assets.directory = app.static_folder
assets.append_path(assets_directory)
assets.append_path(app.static_folder)
assets.register("h5bp_css", h5bp_css)
assets.register("h5bp_shiv", h5bp_shiv)
assets.register("h5bp_head_js", h5bp_head_js)
if assets.debug:
assets.register("h5bp_body_js", h5bp_body_js_devel)
else:
assets.register("h5bp_body_js", h5bp_body_js_production)
def register_assets(app):
assets = Environment(app)
ALL_ASSETS = {
'core_js': Bundle('js/lib/jquery.js',
'js/lib/jquery.highlight.js',
'js/lib/jquery.mobile.js',
'js/lib/underscore.js',
'js/lib/backbone.js',
'js/lib/inifiniScroll.js',
'js/lib/moment.js',
'js/model/modelsForEvents.js',
'js/utils.js',
'js/view/PageView.js',
'js/view/ListView.js',
'js/add_favorites.js',
'js/routes.js',
filters='rjsmin', output='core_%(version)s.js'),
'home_js': Bundle('js/home.js',
filters='rjsmin', output='home_%(version)s.js'),
'goingon_js': Bundle('js/goingon.js',
filters='rjsmin', output='goingon_%(version)s.js'),
'events_js': Bundle('js/events.js',
filters='rjsmin', output='events_%(version)s.js'),
'favorites_js': Bundle('js/favorites.js',
filters='rjsmin', output='favorites_%(version)ss.js'),
'history_js': Bundle('js/history.js',
filters='rjsmin', output='history_%(version)s.js'),
'search_js': Bundle('js/search.js',
filters='rjsmin', output='search_%(version)s.js'),
'statistics_js': Bundle('js/statistics.js',
filters='rjsmin', output='statistics_%(version)s.js'),
'maps_js': Bundle('js/lib/gmaps.js',
'js/maps.js',
filters='rjsmin', output='maps_%(version)s.js'),
'style_css': Bundle('style/jquery.mobile.css',
'style/icons.css',
'style/core.css',
filters='cssmin', output='style/style_%(version)s.css')
}
assets.debug = app.config["DEBUG"]
for bundle_id, bundle in ALL_ASSETS.iteritems():
assets.register(bundle_id, bundle)
return assets
def setup_app(app):
"""Initialize Assets extension."""
app.config.setdefault("LESS_RUN_IN_DEBUG", False)
assets = Environment(app)
assets.url = app.static_url_path + "/"
assets.directory = app.static_folder
commands = (("LESS_BIN", "lessc"),
("CLEANCSS_BIN", "cleancss"))
import subprocess
for key, cmd in commands:
try:
command = app.config.get(key, cmd)
subprocess.call([command, "--version"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except OSError:
app.logger.error("Executable `{0}` was not found. You can specify "
"it via {1}."
.format(cmd, key))
app.config["ASSETS_DEBUG"] = True
assets.debug = True
def _jinja2_new_bundle(tag, collection, name=None, filters=None):
if len(collection):
name = "invenio" if name is None else name
sig = hash(",".join(collection) + "|" + str(filters))
kwargs = {
"output": "{0}/{1}-{2}.{0}".format(tag, name, sig),
"filters": filters,
"extra": {"rel": "stylesheet"}
}
# If LESS_RUN_IN_DEBUG is set to False, then the filters are
# removed and each less file will be parsed by the less JavaScript
# library.
if assets.debug and not app.config.get("LESS_RUN_IN_DEBUG", True):
kwargs["extra"]["rel"] = "stylesheet/less"
kwargs["filters"] = None
return Bundle(*collection, **kwargs)
app.jinja_env.extend(new_bundle=_jinja2_new_bundle,
default_bundle_name='90-invenio')
app.jinja_env.add_extension(CollectionExtension)
return app
def register_assets(app):
assets = Environment(app)
ALL_ASSETS = {
"core_js": Bundle(
"js/lib/jquery.js",
"js/lib/jquery.highlight.js",
"js/lib/jquery.mobile.js",
"js/lib/underscore.js",
"js/lib/backbone.js",
"js/lib/inifiniScroll.js",
"js/lib/moment.js",
"js/model/modelsForEvents.js",
"js/utils.js",
"js/view/PageView.js",
"js/view/ListView.js",
"js/add_favorites.js",
"js/routes.js",
filters="rjsmin",
output="core_%(version)s.js",
),
"home_js": Bundle("js/home.js", filters="rjsmin", output="home_%(version)s.js"),
"goingon_js": Bundle("js/goingon.js", filters="rjsmin", output="goingon_%(version)s.js"),
"events_js": Bundle("js/events.js", filters="rjsmin", output="events_%(version)s.js"),
"favorites_js": Bundle("js/favorites.js", filters="rjsmin", output="favorites_%(version)ss.js"),
"history_js": Bundle("js/history.js", filters="rjsmin", output="history_%(version)s.js"),
"search_js": Bundle("js/search.js", filters="rjsmin", output="search_%(version)s.js"),
"maps_js": Bundle("js/lib/gmaps.js", "js/maps.js", filters="rjsmin", output="maps_%(version)s.js"),
"style_css": Bundle(
"style/jquery.mobile.css",
"style/icons.css",
"style/core.css",
filters="cssmin",
output="style/style_%(version)s.css",
),
}
assets.debug = app.config["DEBUG"]
for bundle_id, bundle in ALL_ASSETS.iteritems():
assets.register(bundle_id, bundle)
return assets
def register(app):
assets = Environment(app)
assets.debug = False
css_overrides = Bundle("css/jquery-ui.css",
"css/google_open_sans.css",
"css/app.css",
"css/timepicker.css",
"css/select2.css",
output="gen/overrides.css")
assets.register("css_overrides", css_overrides)
boards_js = Bundle("js/select2.js",
"js/socket.io.js",
"js/jquery-ui.js",
"js/timepicker.js",
"js/raty/jquery.raty.js",
output="gen/boards_js.js")
assets.register("boards_js", boards_js)
def build_assets(app):
"""
build assets with webassets
"""
js = Bundle(
*js_assets,
filters='rjsmin',
output='gen/packed.js'
)
css = Bundle(
*css_assets,
filters=(custom_cssmin, 'cssrewrite'),
output='gen/packed.css'
)
assets = Environment(app)
assets.debug = True
# FIXME
# assets.debug = True
assets.register('js_all', js)
assets.register('css_all', css)
def register_assets(app, debug=False):
"""We add the app's root path to assets search path. However, the
output directory is relative to `app.static_folder`.
"""
assets = Environment(app)
assets.debug = debug
assets.auto_build = True
assets.manifest = 'file'
assets.append_path(app.root_path)
site_js = Bundle(
'static/app.js',
filters=('uglifyjs',),
output='js/bundle.js'
)
assets.register('site_js', site_js)
site_css = Bundle(
'static/style.css',
filters=('cssmin',),
output='css/bundle.css'
)
assets.register('site_css', site_css)
def init_app(app):
# Initialize webassets, the asset pipeline
assets = Environment(app)
assets.debug = app.config['DEBUG']
cur_path = os.path.dirname(os.path.abspath(__file__))
assets_load_path = os.path.join(cur_path, 'static')
if ('WEBASSETS_PATH' in app.config):
assets_load_path = app.config['WEBASSETS_PATH']
logger.debug('Using asset directory specified in config.')
logger.debug('Using asset directory of: {0}.'.format(assets_load_path))
# Output path for compiled assets
assets.directory = os.path.join(cur_path, 'static')
assets.url = '/static/'
assets.from_yaml(os.path.join(cur_path, 'assets.yml'))
assets.config['closure_compressor_optimization'] = 'SIMPLE_OPTIMIZATIONS'
assets.config['closure_extra_args'] = ['--language_in', 'ECMASCRIPT5']
assets.append_path(assets_load_path)
return assets
trackId = track[0].id
submissions = Submission.query.filter(Submission.trackId==trackId).all();
resp = make_response(render_template('tracks_listing.html', user=g.user,show=len(track)<=0, submissions=submissions))
return resp
# static asset versioning and packaging
assets = Environment(app)
js = Bundle('jquery-1.11.0.js',
'bootstrap-3.1.1/dist/js/bootstrap.js',
'bootstrap-selectpicker/bootstrap-select.js',
'typeahead.bundle.js',
'lodash.min.js',
'can.jquery.js',
'modal.js',
filters='rjsmin', output='build/tuxtrax-%(version)s.js')
css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css')
assets.debug = constants.DEBUG
assets.versions = "hash"
assets.register('js_base', js)
assets.register('css_base', css)
@app.route('/dev')
def index():
tags = [tag.name for tag in Tag.query.all()]
resp = make_response(render_template('index.html', user=g.user, showhidden=False, tags=tags))
resp.set_cookie('submission_ver', str(submission_dataset_ver()))
return resp
# load config
app.config.update(
DEBUG=debug,
SHOW_GA=show_ga,
SECRET_KEY=os.environ.get('SECRET_KEY', ''),
# GOOGLE_LOGIN_CLIENT_ID=os.environ.get('GOOGLE_LOGIN_CLIENT_ID', ''),
# GOOGLE_LOGIN_CLIENT_SECRET=os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET', ''),
# GOOGLE_LOGIN_REDIRECT_URI=os.environ.get('GOOGLE_LOGIN_REDIRECT_URI', ''),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'postgres://*****:*****@localhost/beer'),
)
db = SQLAlchemy(app)
# setup assetbundle
assets = Environment(app)
assets.debug = False # app.debug # (debug=True f***s up jsx)
bundles = PythonLoader('web.assetbundles').load_bundles()
for name, bundle in bundles.iteritems():
assets.register(name, bundle)
# add various views
from web import views
from web import api
app.db_session = db.session
@app.before_first_request
def setup_logging():
if not app.debug:
app.logger.addHandler(logging.StreamHandler())
app.logger.setLevel(logging.INFO)
# Getting the supported languages from SUMO
LANGUAGES = requests.get(
(app.config['SUMO_URL'] + 'offline/get-languages')).json()
LANGUAGES = json.dumps(LANGUAGES['languages'])
# Sets up the assets
assets = Environment(app)
assets.auto_build = app.debug
assets.debug = app.debug
# we don't need this as manifest.appcache will change
assets.url_expire = False
css = Bundle('css/develop/gaia.css',
'css/develop/doc.css',
'css/develop/installer.css',
'css/develop/nav.css',
'css/develop/app.css',
filters='cssmin',
output='css/app.min.css')
assets.register('css_all', css)
scripts = ['js/develop/app.js']
for root, subdir, fnames in os.walk('static/js/develop'):
for filename in fnames:
from dexter.app import app
# setup assets
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
assets.url_expire = False
assets.debug = app.config['ENV'] == 'development'
assets.directory = '%s/public' % app.config.root_path
assets.load_path = ['assets']
assets.url = '/public'
assets.register('css',
Bundle(
'css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
'css/font-awesome-4.3.0.min.css',
'css/datepicker3.css',
'css/bootstrap-datetimepicker.min.css',
'css/daterangepicker-bs3.css',
'css/select2-3.4.8.css',
'css/select2-bootstrap-3.4.8.css',
'css/dropzone-3.10.2.css',
Bundle(
'css/*.scss',
filters='pyscss',
output='css/app.%(version)s.css'),
output='css/all.%(version)s.css'))
assets.register('mine-css',
Bundle(
'css/bootstrap-3.2.0.min.css',
def init(app):
"""Initialize CSS and JavaScript asset bundles
"""
js_libs = Bundle("js/libs/jquery-1.6.2.min.js",
"js/libs/jquery.dropkick-1.0.0.js",
"js/libs/json2.js",
"js/libs/underscore.js",
"js/libs/backbone.js",
"js/libs/swfobject.js",
"js/libs/spin-1.2.2.js",
filters="jsmin",
output="libs.js")
js_common = Bundle("js/app/tools.js",
"js/app/common.js",
filters="jsmin",
output="common.js")
js_home = Bundle("js/app/stats.js",
"js/app/home.js",
filters="jsmin",
output="home.js")
js_profile = Bundle("js/app/profile.js",
filters="jsmin",
output="profile.js")
css_less = Bundle("css/style.less",
filters="less",
output="style.css",
debug=False)
css_main = Bundle(Bundle("css/lib/screen.css", "css/lib/dropkick.css"),
css_less,
filters="cssmin",
output="main.css")
css_ie8 = Bundle("css/ie8.css", filters="cssmin", output="ie8.css")
# Admin Assets
js_admin_libs = Bundle("js/libs/jquery-1.6.2.min.js",
"js/libs/jquery-ui-1.8.16.min.js",
"js/libs/json2.js",
"js/libs/underscore.js",
"js/libs/backbone.js",
filters="jsmin",
output="admin_libs.js")
js_admin_common = Bundle("js/app/admin_tools.js",
"js/app/admin.js",
filters="jsmin",
output="admin_common.js")
css_admin_less = Bundle("css/admin.less",
filters="less",
output="admin.css",
debug=False)
css_admin_main = Bundle("css/lib/screen.css",
"css/lib/smoothness/jquery-ui-1.8.16.css",
css_admin_less,
filters="cssmin",
output="admin_main.css")
assets = Environment(app)
assets.debug = app.config['ENVIRONMENT'] in ['development', 'staging']
assets.register('js_libs', js_libs)
assets.register('js_common', js_common)
assets.register('js_home', js_home)
assets.register('js_profile', js_profile)
assets.register("css_main", css_main)
assets.register("css_ie8", css_ie8)
assets.register("js_admin_libs", js_admin_libs)
assets.register("js_admin_common", js_admin_common)
assets.register("css_admin_main", css_admin_main)
def init(app):
assets = Environment(app)
if app.config.get('CARAVELA_ENV') == 'production':
assets.debug=False
assets.auto_build=False
#else:
# assets.debug = True
assets.url = app.static_url_path
assets.register('common.js', Bundle(
'lib/jquery-1.9.1.min.js',
'lib/bootstrap.js',
'lib/modernizr-2.6.1.min.js',
'lib/underscore-min.js',
'lib/less-1.3.0.min.js',
'lib/jquery-ui-1.10.1.custom.min.js',
'lib/jquery.mousewheel.js',
'lib/handlebars-1.0.0.js',
'lib/ember-1.0.0.js',
'lib/ember-data.js',
'lib/ember-table.js',
'lib/d3.v3.min.js',
'lib/vega.js',
'lib/d3.geo.projection.min.js',
'lib/codemirror.js',
'lib/mode/javascript/javascript.js',
'js/app.js',
'js/routes/*.js',
'js/controllers/*.js',
'js/models/*.js',
'js/views/*.js',
#filters='rjsmin',
output='assets/common.js'
))
sass = Bundle(
'**/*.sass',
filters='compass',
output='assets/sass.css'
)
assets.register('sass.css', sass)
assets.register('common.css', Bundle(
sass,
'css/bootstrap.min.css',
'lib/codemirror.css',
'css/persona-buttons.css',
'css/style.css',
output='assets/common.css'
))
assets.config.update(dict(
jst_compiler = "Em.Handlebars.compile",
jst_namespace= "Em.TEMPLATES"
))
assets.register('app.handlebars', Bundle(
'templates/*.handlebars',
'templates/**/*.handlebars',
filters='jst',
output='assets/app.handlebars'
))
if 'PC_FAKE_OID' in os.environ:
session['openid'] = os.environ['PC_FAKE_OID']
# static asset versioning and packaging
assets = Environment(app)
js = Bundle('jquery-1.11.0.js',
'bootstrap-3.1.1/dist/js/bootstrap.js',
'bootstrap-selectpicker/bootstrap-select.js',
'typeahead.bundle.js',
'lodash.min.js',
'can.jquery.js',
filters='rjsmin',
output='build/tuxtrax-%(version)s.js')
css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css')
try:
os.environ["DEBUG"]
except KeyError:
debug = False
else:
debug = True
assets.debug = debug
assets.versions = "hash"
assets.register('js_base', js)
assets.register('css_base', css)
def create_app(config=None, debug=False):
'''
Inicializa la aplicación Flask. Carga los siguientes módulos:
- index: página de inicio
- page: páginas estáticas
- user: gestión del usuario
- files: búsqueda y obtención de ficheros
- status: servicio de monitorización de la aplicación
Y además, inicializa los siguientes servicios:
- Configuración: carga valores por defecto y modifica con el @param config
- Web Assets: compilación y compresión de recursos estáticos
- i18n: detección de idioma en la URL y catálogos de mensajes
- Cache y auth: Declarados en el módulo services
- Files: Clases para acceso a datos
'''
app = Flask(__name__)
app.config.from_object(defaults)
app.debug = debug
app.session_interface = NoSessionInterface()
# Configuración
if config:
app.config.from_object(config)
# Runtime config
app.config["DOWNLOADER_FILES"] = {
k: os.path.join(os.path.abspath(os.path.join(app.root_path,"../downloads")), v)
for k, v in app.config["DOWNLOADER_FILES"].iteritems()
}
# Gestión centralizada de errores
if app.config["SENTRY_DSN"]:
sentry.init_app(app)
logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO)
# Configuración dependiente de la versión del código
revision_filename_path = os.path.join(os.path.dirname(app.root_path), "revision")
if os.path.exists(revision_filename_path):
f = open(revision_filename_path, "r")
data = f.read()
f.close()
revisions = tuple(
tuple(i.strip() for i in line.split("#")[0].split())
for line in data.strip().split("\n")
if line.strip() and not line.strip().startswith("#"))
revision_hash = md5(data).hexdigest()
app.config.update(
CACHE_KEY_PREFIX = "%s%s/" % (
app.config["CACHE_KEY_PREFIX"] if "CACHE_KEY_PREFIX" in app.config else "",
revision_hash
),
REVISION_HASH = revision_hash,
REVISION = revisions
)
else:
app.config.update(
REVISION_HASH = None,
REVISION = ()
)
# Registra valores/funciones para plantillas
app.jinja_env.globals["u"] = u
# Blueprints
print "Registering blueprints."
app.register_blueprint(index)
register_files_converters(app)
app.register_blueprint(news)
app.register_blueprint(files)
for blueprint in downloader_blueprints:
app.register_blueprint(blueprint)
# Registra filtros de plantillas
register_filters(app)
# Web Assets
print "Web assets."
if not os.path.isdir(app.static_folder+"/gen"): os.mkdir(app.static_folder+"/gen")
assets = Environment(app)
app.assets = assets
assets.debug = app.debug
assets.versions = "timestamp"
register_filter(JsSlimmer)
register_filter(CssSlimmer)
assets.register('css_torrents', Bundle('main.css', 'jquery.treeview.css', filters='pyscss', output='gen/main.css', debug=False), '960_24_col.css', filters='css_slimmer', output='gen/torrents.css')
assets.register('js_torrents', Bundle('modernizr.js', 'jquery.js', 'jquery.treeview.js', 'jquery.cookie.js', 'jquery.colorbox-min.js', 'torrents.js', 'cookies.js', filters='rjsmin', output='gen/torrents.js'), )
print "Initializing services."
# CSRF protection
csrf.init_app(app)
# Traducciones
babel.init_app(app)
@babel.localeselector
def get_locale():
return "en"
# Cache
cache.init_app(app)
# Mail
mail.init_app(app)
print "Database accesses:"
# Acceso a bases de datos
filesdb.init_app(app)
print "* files"
torrentsdb.init_app(app, searchd)
print "* torrents"
pagesdb.init_app(app)
print "* pages"
#feedbackdb.init_app(app)
#print "* feedback"
configdb.init_app(app)
print "* config"
entitiesdb.init_app(app)
print "* entities"
for service_name, params in app.config["DATA_SOURCE_SHARING"].iteritems():
eval(service_name).share_connections(**{key:eval(value) for key, value in params.iteritems()})
configdb.register_action("flush_cache", cache.clear, _unique=True)
print "Blacklists."
# Blacklists
if app.debug:
blacklists.debug=True
blacklist_data = torrentsdb.get_blacklists()
blacklists.load_data(blacklist_data)
blacklists.clone_into(blacklists_adult, lambda x:x!="misconduct")
def refresh_blacklists():
'''
Refresh blacklists.
'''
blacklists.load_data(torrentsdb.get_blacklists())
configdb.register_action("refresh_blacklists", refresh_blacklists)
def update_downloader_properties():
'''
Downloader updated.
'''
local_cache["downloader_properties"] = get_downloader_properties()
configdb.register_action("update_downloader", update_downloader_properties)
with app.app_context():
local_cache["downloader_properties"] = get_downloader_properties()
# IPs españolas
spanish_ips.load(os.path.join(os.path.dirname(app.root_path),app.config["SPANISH_IPS_FILENAME"]))
@app.before_first_request
def init_process():
if not eventmanager.is_alive():
# Fallback inicio del eventManager
eventmanager.start()
print "Event manager."
# Profiler
# profiler.init_app(app, feedbackdb)
# Servicio de búsqueda
eventmanager.once(searchd.init_app, hargs=(app, filesdb, entitiesdb, profiler))
# Refresco de conexiones
eventmanager.once(filesdb.load_servers_conn)
eventmanager.interval(app.config["FOOCONN_UPDATE_INTERVAL"], filesdb.load_servers_conn)
# Refresco de configuración
eventmanager.once(configdb.pull)
eventmanager.interval(app.config["CONFIG_UPDATE_INTERVAL"], configdb.pull)
# Categorias
categories_cache.init_app(app.config["TORRENTS_CATEGORIES"], app.config["SUBCATEGORIES_MIN_OCCURS"])
categories_cache.update_subcategories(torrentsdb.get_subcategories())
def refresh_subcategories():
'''
Refresh subcategories.
'''
categories_cache.update_subcategories(torrentsdb.get_subcategories())
configdb.register_action("refresh_subcategories", refresh_subcategories)
eventmanager.interval(app.config["CATEGORIES_REFRESH_INTERVAL"], refresh_subcategories)
@app.before_request
def before_request():
g.cache_code = ""
g.last_modified = None
# No preprocesamos la peticiones a static
if request.path.startswith("/static/"):
g.must_cache = False
return
g.blacklisted_content = False
init_g(current_app)
if not g.domain:
return multidomain.redirect_to_domain(g.domains_family[0], 301)
# ignora peticiones sin blueprint
if request.blueprint is None and request.path.endswith("/"):
if "?" in request.url:
root = request.url_root[:-1]
path = request.path.rstrip("/")
query = request.url
if not isinstance(query, unicode):
query = query.decode("utf-8")
query = query[query.find(u"?"):]
return redirect(root+path+query, 301)
return redirect(request.url.rstrip("/"), 301)
@app.after_request
def after_request(response):
if request.user_agent.browser == "msie": response.headers["X-UA-Compatible"] = "IE-edge"
if g.must_cache:
response.headers["X-Cache-Control"] = "max-age=%d"%g.must_cache
if g.cache_code:
response.headers["X-Cache-Code"] = g.cache_code
if g.last_modified:
response.headers["Last-Modified"] = utils.formatdate(time.mktime(max(g.last_modified, current_app.config["APP_LAST_MODIFIED"]).timetuple()), False, True)
return response
# Páginas de error
errors = {
404: ("Page not found", "The requested address does not exists."),
410: ("File not available", "The file you are trying to access has been removed."),
500: ("An error happened", "We had some problems displaying this page. Maybe later we can show it to you."),
503: ("Service unavailable", "This page is temporarily unavailable. Please try again later.")
}
@allerrors(app, 400, 401, 403, 404, 405, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 500, 501, 502, 503)
def all_errors(e):
error = e.code if hasattr(e,"code") else 500
title, description = errors[error if error in errors else 500]
init_g(current_app)
if not g.domain:
return multidomain.redirect_to_domain(g.domains_family[0], 301)
g.title.append(title)
return render_template('error.html', code=str(error), title=title, description=description), error
print "App ready."
return app
'bootstrap-selectpicker/bootstrap-select.js',
'typeahead.bundle.js',
'lodash.min.js',
'can.jquery.js',
filters='rjsmin', output='build/tuxtrax-%(version)s.js')
css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css')
try:
os.environ["DEBUG"]
except KeyError:
debug = False
else:
debug = True
assets.debug = debug
assets.versions = "hash"
assets.register('js_base', js)
assets.register('css_base', css)
app = flask.Flask(__name__)
app.root_path = os.path.join(os.path.dirname(__file__), '..')
# Load webassets bundles from a config file.
BUNDLES_FILENAME = 'bundles.yaml'
bundles = webassets.loaders.YAMLLoader(BUNDLES_FILENAME).load_bundles()
# Merge files in debug mode, but don't apply filters.
assets = Environment(app)
# assets.cache = False
# assets.updater = 'always'
if DEBUG:
assets.debug = 'merge'
for name, bundle in bundles.iteritems():
# Register bundles, so we can include them in templates.
assets.register(name, bundle)
# Disable debug mode for JST filters.
JSTFilter = webassets.filter.jst.JSTFilter
if any([isinstance(f, JSTFilter) for f in bundle.filters]):
bundle.debug = False
# Import views.
from views import *
from quotes import *
from flask.ext.assets import Environment
from flask.ext.assets import Bundle
import psycopg2.extras
import json
import os
# Define the WSGI application object
app = Flask(__name__)
# Configurations
app.config.from_object('config')
# Define the assets environment
assets = Environment(app)
assets.debug = app.config["DEBUG"]
# Setup the secret key
app.secret_key = app.config["SECRET_KEY"]
# add CSRF protection (http://flask-wtf.readthedocs.org/en/latest/csrf.html)
app.WTF_CSRF_TIME_LIMIT = 86400
csrf_protection = CsrfProtect(app)
# import handlers
import db
import application.handlers.admin
import application.handlers.public
import application.handlers.welcome
import application.handlers.dashboard
# load config
app.config.update(
DEBUG=os.environ.get('DEBUG', False),
SECRET_KEY=os.environ.get('SECRET_KEY', ''),
GOOGLE_LOGIN_CLIENT_ID=os.environ.get('GOOGLE_LOGIN_CLIENT_ID', ''),
GOOGLE_LOGIN_CLIENT_SECRET=os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET',
''),
GOOGLE_LOGIN_REDIRECT_URI=os.environ.get('GOOGLE_LOGIN_REDIRECT_URI', ''),
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI', ''),
)
db = SQLAlchemy(app)
# setup assetbundle
assets = Environment(app)
assets.debug = True if app.debug == 'True' else False
bundles = PythonLoader('newbeercellar.assetbundles').load_bundles()
for name, bundle in bundles.iteritems():
assets.register(name, bundle)
# setup login stuff
login_manager = LoginManager()
login_manager.init_app(app)
googlelogin = GoogleLogin(app, login_manager)
# add various views
from newbeercellar import login
from newbeercellar import views
from newbeercellar import api
app.db_session = db.session
js_bundle = Bundle('js/vendor/jquery.autocomplete.js',
'js/vendor/jquery.min.js',
'js/vendor/jquery-ui.min.js',
'js/custom/dom_ajax.js',
'js/vendor/foundation.min.js',
'js/vendor/jquery.sidr.min.js',
'js/vendor/sweet-alert.min.js',
'js/vendor/knockout-3.2.0.js',
'js/vendor/perfect-scrollbar.js',
output='gen/all.js')
css_bundle = Bundle('css/custom/style.css',
'css/vendor/font-awesome.css',
'css/vendor/foundation.css',
'css/vendor/sidr.dark.css',
'css/vendor/sweet-alert.css',
'css/vendor/perfect-scrollbar.css',
output='gen/all.css')
assets.register('js_all', js_bundle)
assets.register('css_all', css_bundle)
assets.debug = True
app.config['ASSETS_DEBUG'] = True
app.config.from_pyfile('configs/production.py')
app.jinja_env.add_extension(HamlishTagExtension)
app.jinja_env.hamlish_enable_div_shortcut = True
db = SQLAlchemy(app)
from oddsportal import views
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.script import Manager
from flask.ext.sqlalchemy import SQLAlchemy
from webassets.loaders import PythonLoader
import project.asset_bundles
app = Flask(__name__)
app.config.from_object('project.config')
db = SQLAlchemy(app)
migrate = Migrate(app, db)
import routes
# from models import *
assets = Environment(app)
assets.versions = "hash:32"
assets.auto_build = app.config["SERVER_ENV"] == 'development'
assets.debug = False
bundles = PythonLoader(project.asset_bundles).load_bundles()
for name, bundle in bundles.iteritems():
assets.register(name, bundle)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('assets', ManageAssets)
if __name__ == '__main__':
manager.run()
original_send = mail.send
def send_email_with_subaccount(message):
message.extra_headers = {
'X-MC-Subaccount': app.config['MANDRILL_TRANSACTIONAL_SUBACCOUNT'],
'X-MC-Template': app.config['MANDRILL_TRANSACTIONAL_TEMPLATE'],
'X-MC-GoogleAnalytics': 'pmg.org.za',
}
original_send(message)
app.extensions.get('mail').send = send_email_with_subaccount
# setup assets
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
assets.url_expire = False
assets.debug = app.debug
# source files
assets.load_path = ['%s/static' % app.config.root_path]
from webassets.filter.pyscss import PyScss
assets.register('css',
Bundle(
'font-awesome-4.2.0/css/font-awesome.min.css',
'chosen/chosen.min.css',
Bundle(
'resources/css/style.scss',
'resources/css/committees.scss',
'resources/css/bill-progress.scss',
filters=PyScss(load_paths=assets.load_path),
output='stylesheets/styles.%(version)s.css'),
# static asset versioning and packaging
assets = Environment(app)
js = Bundle('jquery-1.11.0.js',
'bootstrap-3.1.1/dist/js/bootstrap.js',
'bootstrap-selectpicker/bootstrap-select.js',
'typeahead.bundle.js',
'lodash.min.js',
'can.jquery.js',
'modal.js',
filters='rjsmin',
output='build/tuxtrax-%(version)s.js')
css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css')
assets.debug = constants.DEBUG
assets.versions = "hash"
assets.register('js_base', js)
assets.register('css_base', css)
@app.route('/dev')
def index():
tags = [tag.name for tag in Tag.query.all()]
resp = make_response(
render_template('index.html', user=g.user, showhidden=False,
tags=tags))
resp.set_cookie('submission_ver', str(submission_dataset_ver()))
return resp
def create_app(config=None, debug=False):
'''
Inicializa la aplicación Flask. Carga los siguientes módulos:
- index: página de inicio
- page: páginas estáticas
- user: gestión del usuario
- files: búsqueda y obtención de ficheros
- status: servicio de monitorización de la aplicación
Y además, inicializa los siguientes servicios:
- Configuración: carga valores por defecto y modifica con el @param config
- Web Assets: compilación y compresión de recursos estáticos
- i18n: detección de idioma en la URL y catálogos de mensajes
- Cache y auth: Declarados en el módulo services
- Files y users: Clases para acceso a datos
'''
app = Flask(__name__)
app.config.from_object(defaults)
app.debug = debug
# Configuración
if config:
app.config.from_object(config)
# Gestión centralizada de errores
logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO)
if app.config["SENTRY_DSN"]:
sentry.init_app(app)
# Configuración dependiente de la versión del código
revision_filename_path = os.path.join(os.path.dirname(app.root_path), "revision")
if os.path.exists(revision_filename_path):
f = open(revision_filename_path, "r")
data = f.read()
f.close()
revisions = tuple(
tuple(i.strip() for i in line.split("#")[0].split())
for line in data.strip().split("\n")
if line.strip() and not line.strip().startswith("#"))
revision_hash = md5(data).hexdigest()
app.config.update(
CACHE_KEY_PREFIX = "%s%s/" % (
app.config["CACHE_KEY_PREFIX"] if "CACHE_KEY_PREFIX" in app.config else "",
revision_hash
),
REVISION_HASH = revision_hash,
REVISION = revisions
)
else:
app.config.update(
REVISION_HASH = None,
REVISION = ()
)
# Registra filtros de plantillas
register_filters(app)
# Registra valores/funciones para plantillas
app.jinja_env.globals["u"] = u
# Oauth
init_oauth(app)
# Blueprints
app.register_blueprint(index)
app.register_blueprint(page)
app.register_blueprint(user)
app.register_blueprint(files)
app.register_blueprint(api)
add_labs(app) # Labs (blueprints y alternativas en pruebas)
# Web Assets
if not os.path.isdir(app.static_folder+"/gen"): os.mkdir(app.static_folder+"/gen")
assets = Environment(app)
assets.debug = app.debug
assets.url=app.static_url_path
register_filter(JsSlimmer)
register_filter(CssSlimmer)
assets.register('css_all', 'css/jquery-ui.css', Bundle('css/main.css', filters='pyscss', output='gen/main.css', debug=False), filters='css_slimmer', output='gen/foofind.css')
assets.register('css_ie', 'css/ie.css', filters='css_slimmer', output='gen/ie.css')
assets.register('css_ie7', 'css/ie7.css', filters='css_slimmer', output='gen/ie7.css')
assets.register('css_search', 'css/jquery-ui.css', Bundle('css/search.css', filters='pyscss', output='gen/s.css', debug=False), filters='css_slimmer', output='gen/search.css')
assets.register('css_labs', 'css/jquery-ui.css', Bundle('css/labs.css', filters='pyscss', output='gen/l.css', debug=False), filters='css_slimmer', output='gen/labs.css')
assets.register('css_admin', Bundle('css/admin.css', filters='css_slimmer', output='gen/admin.css'))
assets.register('js_all', Bundle('js/jquery.js', 'js/jquery-ui.js', 'js/jquery.ui.selectmenu.js', 'js/files.js', filters='rjsmin', output='gen/foofind.js'), )
assets.register('js_ie', Bundle('js/html5shiv.js', 'js/jquery-extra-selectors.js', 'js/selectivizr.js', filters='rjsmin', output='gen/ie.js'))
assets.register('js_labs', Bundle('js/jquery.js', 'js/jquery-ui.js', 'js/labs.js', filters='rjsmin', output='gen/labs.js'))
assets.register('js_admin', Bundle('js/jquery.js', 'js/admin.js', filters='rjsmin', output='gen/admin.js'))
# Detección de idioma
@app.url_defaults
def add_language_code(endpoint, values):
'''
Añade el código de idioma a una URL que lo incluye.
'''
if 'lang' in values or not g.lang:
return
if app.url_map.is_endpoint_expecting(endpoint, 'lang'):
values['lang'] = g.lang
pull_lang_code_languages = tuple(
(code,localedata.load(code)["languages"][code].capitalize(), code in app.config["BETA_LANGS"])
for code in app.config["ALL_LANGS"])
@app.url_value_preprocessor
def pull_lang_code(endpoint, values):
'''
Carga el código de idioma en la variable global.
'''
# obtiene el idioma de la URL
g.url_lang = None
if values is not None:
g.url_lang = values.pop('lang', None)
# si esta lista de idiomas permitidos
if g.url_lang and g.url_lang in app.config["ALL_LANGS"]:
g.lang = g.url_lang
# si el usuario esta logueado y tiene establecido el idioma se asigna ese
elif "user" in session and "lang" in session["user"]:
g.lang = session["user"]["lang"]
# si no esta logueado y ha elegido un idioma
elif "lang" in session:
g.lang = session["lang"]
else:
accept = request.accept_languages.values()
# si viene, se coge el que mas convenga dependiendo del que tenga establecido en su navegador o el idioma por defecto
locale = Locale.negotiate((option.replace("-","_") for option in accept), app.config["ALL_LANGS"]) if accept else None
if locale:
g.lang = locale.language
else:
g.lang = app.config["LANGS"][0] # valor por defecto si todo falla
# se carga la lista de idiomas como se dice en cada idioma
g.languages = pull_lang_code_languages
g.beta_lang = g.lang in app.config["BETA_LANGS"]
# Traducciones
babel.init_app(app)
@babel.localeselector
def get_locale():
'''
Devuelve el código del idioma activo.
'''
try: return g.lang
except: return "en"
# Cache
cache.init_app(app)
# Autenticación
auth.setup_app(app)
auth.login_view="user.login"
auth.login_message="login_required"
@auth.user_loader
def load_user(userid):
user = User(userid)
if not user.has_data:
data = usersdb.find_userid(userid)
if data is None:
return None
user.set_data(data)
return user
# Mail
mail.init_app(app)
# Acceso a bases de datos
filesdb.init_app(app)
usersdb.init_app(app)
pagesdb.init_app(app)
feedbackdb.init_app(app)
configdb.init_app(app)
# Servicio de búsqueda
@app.before_first_request
def init_search():
searchd_servers = [(server["_id"], str(server["sp"]), int(server["spp"])) for server in filesdb.get_servers() if "sp" in server]
stats = {server[0]:filesdb.get_server_stats(server[0]) for server in searchd_servers}
searchd.init_app(app, searchd_servers, stats)
init_search_stats()
# Taming
taming.init_app(app)
# Refresco del contador de ficheros
lastcount = [filesdb.count_files()]
def countupdater():
lastcount[0] = long(filesdb.count_files())
eventmanager.interval(app.config["COUNT_UPDATE_INTERVAL"], countupdater)
# Refresco de conexiones
eventmanager.interval(app.config["FOOCONN_UPDATE_INTERVAL"], filesdb.load_servers_conn)
# Refresco de configuración
configdb.pull()
eventmanager.interval(app.config["CONFIG_UPDATE_INTERVAL"], configdb.pull)
# Profiler
profiler.init_app(app, feedbackdb)
# Carga la traducción alternativa
fallback_lang = support.Translations.load(os.path.join(app.root_path, 'translations'), ["en"])
# Unittesting
unit.init_app(app)
# Inicializa
init_labs(app)
if app.config["UNITTEST_INTERVAL"]:
eventmanager.timeout(20, unit.run_tests)
eventmanager.interval(app.config["UNITTEST_INTERVAL"], unit.run_tests)
# Inicio del eventManager
eventmanager.start()
@app.before_request
def before_request():
# No preprocesamos la peticiones a static
if request.path.startswith("/static"):
return
# si el idioma de la URL es inválido, devuelve página no encontrada
if g.url_lang and not g.url_lang in app.config["ALL_LANGS"]:
abort(404)
# ignora peticiones sin blueprint
if request.blueprint is None:
if request.path.endswith("/"):
if "?" in request.url:
return redirect(request.url_root[:-1] + request.path + request.url[request.url.find("?"):], 301)
return redirect(request.url[:-1], 301)
return
# si no es el idioma alternativo, lo añade por si no se encuentra el mensaje
if g.lang!="en":
get_translations().add_fallback(fallback_lang)
# dominio de la web
g.domain = request.url_root[8:-1] if request.url_root.startswith("https") else request.url_root[7:-1]
# título de la página por defecto
g.title = g.domain
# contador de archivos totales
g.count_files = lastcount[0]
# Páginas de error
@app.errorhandler(400)
@app.errorhandler(401)
@app.errorhandler(403)
@app.errorhandler(404)
@app.errorhandler(405)
@app.errorhandler(408)
@app.errorhandler(409)
@app.errorhandler(410)
@app.errorhandler(411)
@app.errorhandler(412)
@app.errorhandler(413)
@app.errorhandler(414)
@app.errorhandler(415)
@app.errorhandler(416)
@app.errorhandler(417)
@app.errorhandler(418)
@app.errorhandler(500)
@app.errorhandler(501)
@app.errorhandler(502)
@app.errorhandler(503)
def all_errors(e):
error = str(e.code) if hasattr(e,"code") else "500"
message_msgid = "error_%s_message" % error
message_msgstr = _(message_msgid)
if message_msgstr == message_msgid:
message_msgstr = _("error_500_message")
description_msgid = "error_%s_description" % error
description_msgstr = _(description_msgid)
if description_msgstr == description_msgid and hasattr(e,"description"):
message_msgstr = _("error_500_description")
try:
g.title = "%s %s" % (error, message_msgstr)
g.count_files = lastcount[0]
return render_template('error.html', zone="errorhandler", error=error, description=description_msgstr), int(error)
except Exception as ex: #si el error ha llegado sin contexto se encarga el servidor de él
logging.warn(ex)
return make_response("",error)
return app
'db1': app.config['SQLALCHEMY_DATABASE_URI'],
}
root_path = os.path.abspath("%s/.." % os.path.dirname(__file__))
tmp_path = "%s/tmp" % root_path
os.environ['BOTO_ENDPOINTS'] = os.path.abspath(
"%s/config/boto_endpoints.json" % root_path)
###################
# ASSETS SETTINGS #
###################
assets = Environment(app)
loader = YAMLLoader("%s/assets/assets.yml" % root_path)
bundles = loader.load_bundles()
assets.register(bundles)
assets.set_directory("%s/public" % root_path)
assets.load_path.append('./assets/')
assets.url = '/'
assets.manifest = "json:%s/public/gen/webassets-manifest.json" % root_path
development_mode = not environment.equals('production')
assets.cache = development_mode
assets.auto_build = development_mode
assets.debug = development_mode
# MD Feb-2015 Allow created files to be group writeable. This will fix some problems with files created in the /tmp
# directory that are accessed both by Celery and duesty scripts. The /tmp directory should have set "chmod g+s tmp"
os.umask(0o002)
def create_invenio_flask_app(**kwargs_config):
"""
Prepare WSGI Invenio application based on Flask.
Invenio consists of a new Flask application with legacy support for
the old WSGI legacy application and the old Python legacy
scripts (URLs to *.py files).
An incoming request is processed in the following manner:
* The Flask application first routes request via its URL routing
system (see LegacyAppMiddleware.__call__()).
* One route in the Flask system, will match Python legacy
scripts (see static_handler_with_legacy_publisher()).
* If the Flask application aborts the request with a 404 error, the request
is passed on to the WSGI legacy application (see page_not_found()). E.g.
either the Flask application did not find a route, or a view aborted the
request with a 404 error.
"""
def decorate_build(f):
@wraps(f)
def decorator(*args, **kwargs):
scheme_url = {
'http': current_app.config['CFG_SITE_URL'],
'https': current_app.config['CFG_SITE_SECURE_URL']
}
force_external = kwargs.get('force_external', True)
url_scheme = getattr(f.im_self, 'url_scheme', 'http')
kwargs['force_external'] = False
url = f(*args, **kwargs)
if force_external:
url = scheme_url.get(url_scheme) + url
return url
return decorator
class InvenioFlask(Flask):
def create_url_adapter(self, request):
url_adapter = super(InvenioFlask, self).create_url_adapter(request)
if url_adapter is not None and hasattr(url_adapter, 'build'):
url_adapter.build = decorate_build(url_adapter.build)
return url_adapter
## The Flask application instance
_app = InvenioFlask(
__name__,
## Static files are usually handled directly by the webserver (e.g. Apache)
## However in case WSGI is required to handle static files too (such
## as when running simple server), then this flag can be
## turned on (it is done automatically by wsgi_handler_test).
## We assume anything under '/' which is static to be server directly
## by the webserver from CFG_WEBDIR. In order to generate independent
## url for static files use func:`url_for('static', filename='test')`.
static_url_path='',
static_folder=CFG_WEBDIR)
## Update application config from parameters.
_app.config.update(kwargs_config)
if 'SQLALCHEMY_DATABASE_URI' not in _app.config:
from sqlalchemy.engine.url import URL
# Global variables
from invenio.dbquery import CFG_DATABASE_HOST, CFG_DATABASE_PORT,\
CFG_DATABASE_NAME, CFG_DATABASE_USER, CFG_DATABASE_PASS, \
CFG_DATABASE_TYPE
_app.config['SQLALCHEMY_DATABASE_URI'] = URL(
CFG_DATABASE_TYPE,
username=CFG_DATABASE_USER,
password=CFG_DATABASE_PASS,
host=CFG_DATABASE_HOST,
database=CFG_DATABASE_NAME,
port=CFG_DATABASE_PORT,
)
## Let's initialize database.
from invenio.sqlalchemyutils import db
db.init_app(_app)
## First check that you have all rights to logs
from invenio.bibtask import check_running_process_user
check_running_process_user()
from invenio.pluginutils import PluginContainer
from invenio.session_flask import InvenioSessionInterface
from invenio.webuser_flask import InvenioLoginManager, current_user, UserInfo
from invenio.messages import wash_language, gettext_set_language, \
language_list_long, is_language_rtl
from invenio.urlutils import create_url, get_canonical_and_alternates_urls
from invenio.cache import cache
from invenio.jinja2utils import CollectionExtension, \
LangExtension, hack_jinja2_utf8decoding, \
extend_application_template_filters
from flask.ext.assets import Environment, Bundle
from invenio.webinterface_handler_flask_utils import unicodifier, InvenioRequest
from flaskext.gravatar import Gravatar
from werkzeug.wrappers import BaseResponse
from werkzeug.exceptions import HTTPException
from invenio.flask_sslify import SSLify
from invenio.webinterface_handler_wsgi import application as legacy_application
from invenio.webinterface_handler_wsgi import is_mp_legacy_publisher_path, \
mp_legacy_publisher
# See note on Jinja2 string decoding using ASCII codec instead of UTF8 in
# function documentation
hack_jinja2_utf8decoding()
# Handle both url with and without trailing slashe by Flask.
# @blueprint.route('/test')
# @blueprint.route('/test/') -> not necessary when strict_slashes == False
_app.url_map.strict_slashes = False
# SECRET_KEY is needed by Flask Debug Toolbar
SECRET_KEY = _app.config.get('SECRET_KEY') or CFG_SITE_SECRET_KEY
if not SECRET_KEY or SECRET_KEY == '':
fill_secret_key = """
Set variable CFG_SITE_SECRET_KEY with random string in invenio-local.conf.
You can use following commands:
$ %s
$ %s
""" % (CFG_BINDIR + os.sep + 'inveniocfg --create-secret-key',
CFG_BINDIR + os.sep + 'inveniocfg --update-config-py')
try:
raise Exception(fill_secret_key)
except Exception:
register_exception(alert_admin=True,
subject="Missing CFG_SITE_SECRET_KEY")
raise Exception(fill_secret_key)
_app.config["SECRET_KEY"] = SECRET_KEY
# Enable Flask Debug Toolbar early to also catch HTTPS redirects
if 'debug-toolbar' in getattr(config, 'CFG_DEVEL_TOOLS', []):
_app.config["DEBUG_TB_ENABLED"] = True
_app.config[
"DEBUG_TB_INTERCEPT_REDIRECTS"] = 'intercept-redirects' in getattr(
config, 'CFG_DEVEL_TOOLS', [])
from flask_debugtoolbar import DebugToolbarExtension
class InvenioDebugToolbarExtension(DebugToolbarExtension):
def _show_toolbar(self):
user_info = UserInfo(session.get('user_id'))
# Enable debug toolbar only for super admin.
if not user_info.is_super_admin:
return False
return super(InvenioDebugToolbarExtension,
self)._show_toolbar()
InvenioDebugToolbarExtension(_app)
# Set email backend for Flask-Email plugin
from invenio.mailutils import initialize_email_backend
initialize_email_backend(_app)
if CFG_HAS_HTTPS_SUPPORT:
# Makes request always run over HTTPS.
_sslify = SSLify(_app)
if not CFG_FULL_HTTPS:
@_sslify.criteria_handler
def criteria():
"""Extends criteria when to stay on HTTP site."""
_force_https = False
if request.blueprint in current_app.blueprints:
_force_https = current_app.blueprints[request.blueprint].\
_force_https
view_func = current_app.view_functions.get(request.endpoint)
if view_func is not None and hasattr(view_func,
'_force_https'):
_force_https = view_func._force_https
return not (_force_https or session.need_https())
class LegacyAppMiddleware(object):
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
if remote_debugger:
remote_debugger.start()
with self.app.request_context(environ):
g.start_response = start_response
try:
response = self.app.full_dispatch_request()
except Exception as e:
register_exception(req=request, alert_admin=True)
response = self.app.handle_exception(e)
return response(environ, start_response)
_app.wsgi_app = LegacyAppMiddleware(_app)
@_app.errorhandler(404)
def page_not_found(error):
try:
response = legacy_application(request.environ, g.start_response)
if not isinstance(response, BaseResponse):
response = current_app.make_response(str(response))
return response
except HTTPException:
return render_template("404.html"), 404
@_app.errorhandler(401)
def do_login_first(error=401):
"""Displays login page when user is not authorised."""
if request.is_xhr:
return _("Authorization failure"), 401
flash(_("Authorization failure"), 'error')
from invenio.webaccount_blueprint import login
return login(referer=request.url), 401
@_app.endpoint('static')
@_app.route(_app.static_url_path + '/<path:filename>',
methods=['POST', 'PUT'])
def static_handler_with_legacy_publisher(*args, **kwargs):
"""
Adds support for legacy publisher.
NOTE: It changes order of url page lookup. First, the invenio_handler
will be called and on 404 error the mp_legacy_publisher is called.
"""
possible_module, possible_handler = is_mp_legacy_publisher_path(
request.environ['PATH_INFO'])
if possible_module is not None:
legacy_publisher = lambda req: \
mp_legacy_publisher(req, possible_module, possible_handler)
return legacy_application(request.environ,
g.start_response,
handler=legacy_publisher)
# Static file serving for devserver
# ---------------------------------
# Apache normally serve all static files, but if we are using the
# devserver we need to serve static files here. Werkzeugs default
# behaviour is to return a '405 Method not allowed' for POST requests
# to static files. However, if we abort all POST requests with 405, the
# legacy_application (see page_not_found()) will not be given a chance
# to serve static files as it only get's invokved when we abort with a
# 404. Hence, on POST requests, we first check if the static file exists,
# and if it does we return we abort the request with a 405.
if not CFG_FLASK_SERVE_STATIC_FILES:
abort(404)
else:
static_file_response = _app.send_static_file(*args, **kwargs)
if request.method in ['POST', 'PUT']:
abort(405)
else:
return static_file_response
if CFG_FLASK_CACHE_TYPE not in [None, 'null']:
_app.jinja_options = dict(_app.jinja_options,
auto_reload=False,
cache_size=-1,
bytecode_cache=MemcachedBytecodeCache(
cache, prefix="jinja::", timeout=3600))
## Let's customize the template loader to first look into
## /opt/invenio/etc-local/templates and then into
## /opt/invenio/etc/templates
_app.jinja_loader = FileSystemLoader([
join(CFG_ETCDIR + '-local', 'templates'),
join(CFG_ETCDIR, 'templates')
])
## Let's attach our session handling (which is bridging with the native
## Invenio session handling
_app.session_interface = InvenioSessionInterface()
## Set custom request class
_app.request_class = InvenioRequest
## Let's load the whole invenio.config into Flask :-) ...
_app.config.from_object(config)
## ... and map certain common parameters
_app.config['SESSION_COOKIE_NAME'] = CFG_WEBSESSION_COOKIE_NAME
_app.config['PERMANENT_SESSION_LIFETIME'] = \
CFG_WEBSESSION_EXPIRY_LIMIT_REMEMBER * CFG_WEBSESSION_ONE_DAY
_app.config['USE_X_SENDFILE'] = CFG_BIBDOCFILE_USE_XSENDFILE
_app.config['DEBUG'] = CFG_DEVEL_SITE > 0
_app.debug = CFG_DEVEL_SITE > 0
language_list_long = language_list_long()
language_labordoc_list = [
ln for ln in language_list_long if ln[0] in ['en', 'es', 'fr']
]
_app.config['CFG_LANGUAGE_LIST_LONG'] = [
(lang, longname.decode('utf-8'))
for (lang, longname) in language_list_long
]
_app.config['CFG_LANGUAGE_LABORDOC_LIST'] = [
(lang, longname.decode('utf-8'))
for (lang, longname) in language_labordoc_list
]
## Invenio is all using str objects. Let's change them to unicode
_app.config.update(unicodifier(dict(_app.config)))
## Cache
_app.config['CACHE_TYPE'] = CFG_FLASK_CACHE_TYPE
# FIXME problem in Flask-Cache==0.11.1
cache.app = _app
cache.init_app(_app)
if CFG_FLASK_CACHE_TYPE == 'redis':
def with_try_except_block(f):
def decorator(*args, **kwargs):
try:
return f(*args, **kwargs)
except Exception:
register_exception(alert_admin=True)
pass
return decorator
## When the redis is down, we would like to keep the site running.
cache.cache._client.execute_command = with_try_except_block(
cache.cache._client.execute_command)
# FIXME problem in Flask-Cache==0.11.1
cache.app = current_app
_flask_log_handler = RotatingFileHandler(
os.path.join(CFG_LOGDIR, 'flask.log'))
_flask_log_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
_app.logger.addHandler(_flask_log_handler)
# Let's create login manager.
_login_manager = InvenioLoginManager(_app)
_login_manager.login_view = 'webaccount.login'
_login_manager.anonymous_user = UserInfo
_login_manager.unauthorized_handler(do_login_first)
# Let's create main menu.
class Menu(object):
def __init__(self,
id='',
title='',
url='',
order=None,
children=None,
display=lambda: True):
self.id = id
self.title = title
self.url = url
self.children = children or {}
self.order = order or 100
self.display = display
# Let's create assets environment.
_assets = Environment(_app)
_assets.debug = 'assets-debug' in getattr(config, 'CFG_DEVEL_TOOLS', [])
_assets.directory = config.CFG_WEBDIR
def _jinja2_new_bundle(tag, collection, name=None):
if not _assets.debug:
files = [
f for f in collection
if os.path.isfile(os.path.join(_assets.directory, f))
]
if len(files) != len(collection):
## Turn on debuging to generate 404 request on missing files.
_assets.debug = True
current_app.logger.error(
'Missing files: ' + ','.join(set(collection) - set(files)))
if len(collection):
return Bundle(output="%s/%s-%s.%s" %
(tag, 'invenio' if name is None else name,
hash('|'.join(collection)), tag),
*collection)
_app.jinja_env.extend(new_bundle=_jinja2_new_bundle,
default_bundle_name='90-invenio')
_app.jinja_env.add_extension(CollectionExtension)
_app.jinja_env.add_extension(LangExtension)
_app.jinja_env.add_extension('jinja2.ext.do')
# Let's extend application with custom template filters.
extend_application_template_filters(_app)
# Let's create Gravatar bridge.
_gravatar = Gravatar(_app,
size=100,
rating='g',
default='retro',
force_default=False,
force_lower=False)
del _gravatar
# Let's set the user language
from invenio.webinterface_handler_flask_utils import guess_language
_app.before_request(guess_language)
# Let's extend application with more custom templete filters
from invenio.jinja2utils import inject_utils
_app.context_processor(inject_utils)
@_login_manager.user_loader
def _load_user(uid):
"""
Function should not raise an exception if uid is not valid
or User was not found in database.
"""
return UserInfo(int(uid))
@_app.before_request
def reset_template_context_processor():
g._template_context_processor = []
@_app.context_processor
def _inject_template_context():
context = {}
if not hasattr(g, '_template_context_processor'):
reset_template_context_processor()
for func in g._template_context_processor:
context.update(func())
return context
def _invenio_blueprint_plugin_builder(plugin):
"""
Handy function to bridge pluginutils with (Invenio) blueprints.
"""
if plugin.__name__ in CFG_FLASK_DISABLED_BLUEPRINTS or \
plugin.__name__.split('.')[-1] in CFG_FLASK_DISABLED_BLUEPRINTS:
_app.logger.info(
'%s is excluded by CFG_FLASK_DISABLED_BLUEPRINTS' %
plugin_name)
return
from invenio.webinterface_handler_flask_utils import InvenioBlueprint
if 'blueprint' in dir(plugin):
candidate = getattr(plugin, 'blueprint')
if isinstance(candidate, InvenioBlueprint):
return candidate
_app.logger.error('%s is not a valid blueprint plugin' % plugin_name)
## Let's load all the blueprints that are composing this Invenio instance
_BLUEPRINTS = [
m for m in map(
_invenio_blueprint_plugin_builder,
autodiscover_modules(['invenio'],
related_name_re='.+_blueprint.py',
ignore_exceptions=True)) if m is not None
]
_app.config['breadcrumbs_map'] = {}
_app.config['menubuilder_map'] = {}
## Let's attach all the blueprints
from invenio.webinterface_handler_flask_utils import _
for plugin in _BLUEPRINTS:
_app.register_blueprint(plugin)
if plugin.config:
## Let's include the configuration parameters of the config file.
## E.g. if the blueprint specify the config string
## 'invenio.webmessage_config' any uppercase variable defined in
## the module invenio.webmessage_config is loaded into the system.
_app.config.from_object(plugin.config)
if plugin.breadcrumbs:
_app.config['breadcrumbs_map'][plugin.name] = plugin.breadcrumbs
_app.config['breadcrumbs_map'].update(plugin.breadcrumbs_map)
## Let's build global menu. Each blueprint can plug its own menu items.
if plugin.menubuilder:
_app.config['menubuilder_map'].update(
(m[0], Menu(*m)) for m in plugin.menubuilder)
_app.config['menubuilder_map'].update(plugin.menubuilder_map)
_app.config['menubuilder_map'].update({
'main.admin':
Menu('main.admin', _('Administration'), 'help.admin', 9998, [],
lambda: current_user.is_admin if current_user else False),
'main.help':
Menu('main.help', _('Help'), 'help', 9999)
})
menu = {
'main': Menu('main', '', ''),
'personalize': Menu('personalize', '', '')
}
for key, item in _app.config['menubuilder_map'].iteritems():
start = menu
if '.' not in key:
if key in menu:
menu[key] = item.children.update(menu[key].children)
else:
menu[key] = item
continue
keys = key.split('.')
for k in keys[:-1]:
try:
start = start[k].children
except:
start[k] = Menu()
start = start[k].children
if keys[-1] in start:
item.children.update(start[keys[-1]].children)
start[keys[-1]] = item
_app.config['menubuilder_map'] = menu
# Flask-Admin
from invenio.adminutils import register_admin
register_admin(_app)
try:
## When deploying Invenio, one can prepare a module called
## webinterface_handler_local.py to be deployed under
## CFG_PYLIBDIR/invenio directory, and containing a function called
## customize_app which should accept a Flask application.
## This function has a chance to modify the application as needed
## including changing the URL routing map.
# pylint: disable=E0611
from invenio.webinterface_handler_local import customize_app
# pylint: enable=E0611
customize_app(_app)
except ImportError:
## No customization needed.
pass
return _app
def register_assets(app):
assets = Environment(app)
ALL_ASSETS = {
'core_js':
Bundle('js/lib/jquery.js',
'js/lib/jquery.highlight.js',
'js/lib/jquery.mobile.js',
'js/lib/underscore.js',
'js/lib/backbone.js',
'js/lib/inifiniScroll.js',
'js/lib/moment.js',
'js/model/modelsForEvents.js',
'js/utils.js',
'js/view/PageView.js',
'js/view/ListView.js',
'js/add_favorites.js',
'js/routes.js',
filters='rjsmin',
output='core_%(version)s.js'),
'home_js':
Bundle('js/home.js', filters='rjsmin', output='home_%(version)s.js'),
'goingon_js':
Bundle('js/goingon.js',
filters='rjsmin',
output='goingon_%(version)s.js'),
'events_js':
Bundle('js/events.js',
filters='rjsmin',
output='events_%(version)s.js'),
'favorites_js':
Bundle('js/favorites.js',
filters='rjsmin',
output='favorites_%(version)ss.js'),
'history_js':
Bundle('js/history.js',
filters='rjsmin',
output='history_%(version)s.js'),
'search_js':
Bundle('js/search.js',
filters='rjsmin',
output='search_%(version)s.js'),
'statistics_js':
Bundle('js/statistics.js',
filters='rjsmin',
output='statistics_%(version)s.js'),
'maps_js':
Bundle('js/lib/gmaps.js',
'js/maps.js',
filters='rjsmin',
output='maps_%(version)s.js'),
'style_css':
Bundle('style/jquery.mobile.css',
'style/icons.css',
'style/core.css',
filters='cssmin',
output='style/style_%(version)s.css')
}
assets.debug = app.config["DEBUG"]
for bundle_id, bundle in ALL_ASSETS.iteritems():
assets.register(bundle_id, bundle)
return assets
show_ga = not debug
# load config
app.config.update(
DEBUG=debug,
SHOW_GA=show_ga,
SECRET_KEY=os.environ.get('SECRET_KEY', ''),
# GOOGLE_LOGIN_CLIENT_ID=os.environ.get('GOOGLE_LOGIN_CLIENT_ID', ''),
# GOOGLE_LOGIN_CLIENT_SECRET=os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET', ''),
# GOOGLE_LOGIN_REDIRECT_URI=os.environ.get('GOOGLE_LOGIN_REDIRECT_URI', ''),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI', 'postgres://*****:*****@localhost/beer'),
)
db = SQLAlchemy(app)
# setup assetbundle
assets = Environment(app)
assets.debug = False # app.debug # (debug=True f***s up jsx)
bundles = PythonLoader('web.assetbundles').load_bundles()
for name, bundle in bundles.iteritems():
assets.register(name, bundle)
# add various views
from web import views
from web import api
app.db_session = db.session
from os.path import dirname, join, realpath, normpath
from flask.ext.assets import Environment, Bundle
from app import app
environment = Environment(app)
environment.versions = 'hash'
manifest_path = normpath(realpath(join(dirname(__file__), '.static-manifest')))
environment.manifest = 'file:%s' % manifest_path
environment.cache = False
environment.debug = False
css_main = Bundle('css/main.css',
Bundle('less/main.less', filters='less'),
filters='cssmin',
output='css/main.%(version)s.css')
js_head = Bundle(
'https://cdnjs.cloudflare.com/ajax/libs/modernizr/2.6.2/modernizr.min.js',
output='js/head.%(version)s.js')
js_foot = Bundle(
'https://ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js',
Bundle('js/scripts.js', filters='jsmin'),
output='js/main.%(version)s.js')
from modules.models import (
page, proxy, result, statistics_memory, statistics_request,
)
from modules.log import initialize
initialize()
application = Flask(
__name__, static_folder=join(abspath(dirname(__file__)), 'resources'),
)
application.config.from_pyfile('settings.py')
assets = Environment(application)
assets.cache = not application.config['DEBUG']
assets.debug = application.config['DEBUG']
assets.directory = application.static_folder
assets.manifest = 'json:assets/versions.json'
assets.url = application.static_url_path
assets.url_expire = True
assets.versions = 'hash'
assets.register('javascripts', Bundle(
'vendor/jquery/dist/jquery.js',
'vendor/angular/angular.min.js',
'vendor/bootstrap/dist/js/bootstrap.js',
'vendor/highcharts/highcharts-all.js',
'javascripts/all.js',
filters='rjsmin' if not application.config['DEBUG'] else None,
output='assets/compressed.js',
))
assets.register('stylesheets', Bundle(
from modules import models
application = Flask(__name__,
static_folder=join(abspath(dirname(__file__)),
'resources'))
application.config.from_pyfile('settings/__init__.py')
application.config.from_pyfile(
'settings/%(environment)s.py' % {
'environment': environ.get('environment', 'serve'),
},
silent=True)
assets = Environment(application)
assets.cache = False
assets.debug = application.config['DEBUG']
assets.directory = application.static_folder
assets.manifest = 'json:assets/versions.json'
assets.url = application.static_url_path
assets.url_expire = True
assets.versions = 'hash'
assets.register(
'javascripts',
Bundle(
'vendor/jquery/dist/jquery.js',
'vendor/bootstrap/dist/js/bootstrap.js',
filters='rjsmin' if not application.config['DEBUG'] else None,
output='assets/compressed.js',
))
assets.register(
'stylesheets',
stream_handler.setLevel(logging.DEBUG)
loggers = [app.logger, logging.getLogger('elasticsearch')]
for logger in loggers:
logger.setLevel(logging.WARNING)
logger.addHandler(stream_handler)
# When I'm ready to fix this with bower and stuff
# look at http://adambard.com/blog/fresh-flask-setup/
assets = Environment(app)
assets.directory = 'eheritage/static/'
assets.url = '/static/'
assets.debug = True
js = Bundle('app.js',
filters='jsmin', output='gen/packed.js')
assets.register('js_all', js)
# scss = Bundle('*.scss', filters='scss', output='gen/scss.css')
# css = Bundle('style.css', # scss,
# filters='pyscss,cssmin', output='gen/style.css')
# assets.register('css_all', css)
app.json_encoder = IterableAwareEncoder
# Create the Flask app.
app = flask.Flask(__name__)
app.root_path = os.path.join(os.path.dirname(__file__), '..')
# Load webassets bundles from a config file.
BUNDLES_FILENAME = 'bundles.yaml'
bundles = webassets.loaders.YAMLLoader(BUNDLES_FILENAME).load_bundles()
# Merge files in debug mode, but don't apply filters.
assets = Environment(app)
# assets.cache = False
# assets.updater = 'always'
if DEBUG:
assets.debug = 'merge'
for name, bundle in bundles.iteritems():
# Register bundles, so we can include them in templates.
assets.register(name, bundle)
# Disable debug mode for JST filters.
JSTFilter = webassets.filter.jst.JSTFilter
if any([isinstance(f, JSTFilter) for f in bundle.filters]):
bundle.debug = False
# Import views.
from views import *
from quotes import *
if __name__ == '__main__':
from dexter.app import app
# setup assets
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
assets.url_expire = False
assets.debug = app.config['ENV'] == 'development'
assets.directory = '%s/public' % app.config.root_path
assets.load_path = ['assets']
assets.url = '/public'
assets.register(
'css',
Bundle('css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
'css/font-awesome-4.3.0.min.css',
'css/datepicker3.css',
'css/bootstrap-datetimepicker.min.css',
'css/daterangepicker-bs3.css',
'css/select2-3.4.8.css',
'css/select2-bootstrap-3.4.8.css',
'css/dropzone-3.10.2.css',
Bundle('css/*.scss',
filters='pyscss',
output='css/app.%(version)s.css'),
output='css/all.%(version)s.css'))
assets.register(
'mine-css',
Bundle('css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
import os
from flask import Flask
from flask import render_template
from flask.ext.assets import Bundle
from flask.ext.assets import Environment
DEBUG = True
app = Flask(__name__)
app.debug = DEBUG
assets = Environment(app)
assets.debug = DEBUG
assets.load_path = [
os.path.join(os.path.dirname(__file__), 'sass'),
os.path.join(os.path.dirname(__file__), 'coffee'),
os.path.join(os.path.dirname(__file__), 'bower_components'),
]
assets.register(
'css',
Bundle(
'**/*.css',
Bundle(
'*.sass',
filters="sass",
output="sass.css"
),
filters="cssmin",
