def init_app(app):
webassets = Environment(app)
webassets.register('css_all', css_all)
webassets.register('js_vendor', js_vendor)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
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):
webassets = Environment(app)
webassets.register('css_all', css_all)
webassets.register('js_vendor', js_vendor)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def create_app():
app = Flask(__name__,\
static_folder="static/",\
template_folder="templates/",\
static_url_path="/static")
# set config
# app_settings = os.getenv('APP_SETTINGS', 'app.config.DevelopmentConfig')
app.config.from_object('config')
# set up extensions
db.init_app(app)
app.register_blueprint(charts_blueprint)
app.register_blueprint(webapi)
# Scss
assets = Environment(app)
assets.versions = 'timestamp'
assets.url_expire = True
assets.manifest = 'file:/tmp/manifest.to-be-deployed' # explict filename
assets.cache = False
assets.auto_build = True
assets.url = app.static_url_path
scss = Bundle('scss/__main__.scss',
filters='pyscss',
output='css/main.css',
depends=['scss/*.scss'])
assets.register('scss_all', scss)
assets.debug = False
app.config['ASSETS_DEBUG'] = False
return app
def create_app():
app = Flask(__name__,\
static_folder="static/",\
template_folder="templates/",\
static_url_path="/static")
set_config(app)
# set up extensions
cache.init_app(app)
db.init_app(app)
datepicker(app)
mail.init_app(app)
# blueprints
app.register_blueprint(auth)
app.register_blueprint(admin_blueprint)
app.register_blueprint(charts_blueprint)
app.register_blueprint(webapi)
app.register_blueprint(monitor_blueprint)
# login_manager
login_manager = LoginManager()
login_manager.login_view = 'charts.now'
login_manager.init_app(app)
from .models import User
@login_manager.user_loader
def load_user(user_id):
# since the user_id is just the primary key of our user table, use it in the query for the user
return User.query.get(int(user_id))
# form csrf
csrf.init_app(app)
# Scss
assets = Environment(app)
assets.versions = 'timestamp'
assets.url_expire = True
assets.manifest = 'file:/tmp/manifest.to-be-deployed' # explict filename
assets.cache = False
assets.auto_build = True
assets.url = app.static_url_path
scss = Bundle('scss/__main__.scss',
filters='pyscss',
output='css/main.css',
depends=['scss/*.scss'])
assets.register('scss_all', scss)
assets.debug = False
app.config['ASSETS_DEBUG'] = False
with app.app_context():
init_db_admin_config()
toolbar = DebugToolbarExtension(app)
return (app)
def init_app(app):
webassets = Environment(app)
webassets.register('css_all', css_all)
# webassets.register('js_quote', js_quote)
# webassets.register('js_main', js_customer)
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.register("css_vendor", css_vendor)
assets.register("js_vendor", js_vendor)
assets.register("css_linkedlist", css_linkedlist)
assets.manifest = 'cache' if not app.debug else False
assets.cache = not app.debug
assets.debug = app.debug
def init_app(self, app):
env = Environment(app)
env.url_expire = True
env.register('css_app', css_app)
env.register('js_app', js_app)
env.manifest = 'cache' if not app.debug else False
env.cache = not app.debug
env.debug = app.debug
def init_app(app):
webassets = Environment(app)
webassets.url = app.static_url_path
webassets.register('js_lodjers', js_lodjers)
webassets.register('js_mixpanel', js_mixpanel)
webassets.register('css_lodjers', css_lodjers)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def create_app():
""" Create a HubGrep Flask-app. """
app = Flask(__name__, static_url_path="/static", static_folder="static")
assets = Environment(app)
# disable cache, because that breaks
# prod build for some reason.
# maybe add to the flask config?
assets.cache = False
assets.manifest = False
@app.after_request
def add_gnu_tp_header(response):
# www.gnuterrypratchett.com
response.headers.add("X-Clacks-Overhead", "GNU Terry Pratchett")
return response
config_mapping = {
constants.APP_ENV_BUILD: "hubgrep.config.BuildConfig",
constants.APP_ENV_DEVELOPMENT: "hubgrep.config.DevelopmentConfig",
constants.APP_ENV_PRODUCTION: "hubgrep.config.ProductionConfig",
constants.APP_ENV_TESTING: "hubgrep.config.TestingConfig",
}
app_env = os.environ.get("APP_ENV", constants.APP_ENV_DEVELOPMENT)
print(f"starting in {app_env} config")
app.config.from_object(config_mapping[app_env])
if app.config['WATCH_SCSS']:
app.wsgi_app = SassMiddleware(app.wsgi_app, app.config["SASS_MANIFEST"])
babel = Babel(app)
init_logging(loglevel=app.config["LOGLEVEL"])
db.init_app(app)
migrate.init_app(app, db=db)
from hubgrep.frontend_blueprint import frontend
from hubgrep.cli_blueprint import cli_bp
app.register_blueprint(frontend)
app.register_blueprint(cli_bp)
@babel.localeselector
def get_locale():
lang = request.accept_languages.best_match(app.config["LANGUAGES"].keys())
return lang
app.jinja_env.globals["get_locale"] = get_locale
app.jinja_env.globals["constants"] = constants
app.jinja_env.globals["timeago"] = timeago
app.jinja_env.globals["datetime_now"] = datetime.datetime.now()
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True
return app
def init_app(app):
"""
Initilize assets.
:param app:
"""
if app.debug:
webassets = Environment(app)
webassets.url = app.static_url_path
webassets.register('css_all', css_all)
webassets.manifest = False
webassets.cache = False
webassets.debug = False
webassets.cache = not app.debug
webassets.debug = app.debug
log = logging.getLogger('webassets')
log.addHandler(logging.StreamHandler())
log.setLevel(logging.DEBUG)
cmdenv = CommandLineEnvironment(webassets, log)
cmdenv.build()
def init_app(app):
webassets = Environment(app)
webassets.register('css_all', css_all)
webassets.register('js_angular', js_angular)
webassets.register('js_foundation', js_foundation)
webassets.register('js_vendor', js_vendor)
webassets.register('js_d3', js_d3)
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 init_app(app):
"""
Initilize assets.
:param app:
"""
webassets = Environment(app)
webassets.url = app.static_url_path
webassets.register('css_all', css_all)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def prepare(app):
web_assets = Environment(app)
web_assets.register('css_all', *prepare_css())
web_assets.register('js_all', *prepare_js())
is_debugging = app.debug
web_assets.manifest = 'cache' if not is_debugging else False
web_assets.cache = not is_debugging
web_assets.debug = is_debugging
return app
def init_app(app):
webassets = Environment(app)
webassets.register('css_cover', css_cover)
webassets.register('css_auth', css_auth)
webassets.register('css_fancybox', css_fancybox)
webassets.register('css_all', css_base)
webassets.register('js_comment', js_comment)
webassets.register('js_all', js_base)
webassets.register('js_fancybox', js_fancybox)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def init_app(app):
webassets = Environment(app)
webassets.register('css_bootstrap', css_bootstrap)
#webassets.register('css_local', css_local)
#webassets.register('js_local', js_local)
#webassets.register('js_jquery', js_jquery)
webassets.register('js_bootstrap', js_bootstrap)
#webassets.register('js_angular', js_angular)
#webassets.register('js_coffee', js_coffee)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def init_app(app):
debug = app.debug
webassets = Environment(app)
# add foundation sass files to sass compiler paths
webassets.config['SASS_LOAD_PATHS'] = ["../bower_components/foundation/scss/",
"."]
webassets.register('css_kb', css_kb)
webassets.register('shivs', shivs)
webassets.register('js_vendor', js_vendor)
webassets.register('js_main', js_main)
webassets.manifest = 'cache' if not debug else False
webassets.cache = not debug
webassets.debug = debug
def init(app) -> None:
"""
Bundle projects assets.
:param app: Main application instance
:type app: flask.Flask
"""
assets = Environment(app)
assets.auto_build = app.config.get('ASSETS_AUTO_BUILD', True)
files_to_watch = []
if 'COLLECT_STATIC_ROOT' in app.config:
assets.cache = app.config['COLLECT_STATIC_ROOT']
collect = Collect()
collect.init_app(app)
collect.collect()
app.static_folder = app.config['COLLECT_STATIC_ROOT']
for key in ['js', 'css']:
assets_key = '%s_ASSETS' % key.upper()
build_files = app.config[assets_key]
files_to_watch.extend(_get_files_for_settings(app, assets_key))
bundle = Bundle(*build_files,
output=app.config['%s_OUTPUT' % assets_key],
filters=app.config['%s_FILTERS' % assets_key]
)
assets.register('%s_all' % key, bundle)
app.logger.debug('Bundling files: %s%s',
os.linesep,
os.linesep.join(build_files))
app.assets = assets
app._base_files_to_watch = files_to_watch
app.logger.info('Base assets are collected successfully.')
db = SQLAlchemy(app) migrate = Migrate(app, db) # Initiate Flask Login to handle # authentication and redirects for # Un logged in users. login = LoginManager(app) login.login_view = 'index' # Flask Assets handles bundling our # CSS and JavaScript files into a # single minified file when we are # not in development mode. assets = Environment(app) assets.debug = Config.DEBUG assets.cache = not Config.DEBUG assets.url_expire = Config.DEBUG # Database Models, and Routes must # be imported after the app object # is defined. from app import models, routes # Define our bundlels for Flask Assets. # These will be used by our base.html # template. routes.make_asset_bundles() # Run our Flask app when this file is # invoked directly. This happens when # gunicorn first calls our app package.
def create_app(config_name=None):
csp_policy = copy.deepcopy(CSP_POLICY)
app = Flask(__name__)
app_config = f'config.{config_name or os.environ.get("APP_SETTINGS", "Config")}'
app.config.from_object(app_config)
if Config.WTF_CSRF_ENABLED:
Talisman(
app,
content_security_policy=csp_policy,
content_security_policy_nonce_in=['script-src'],
force_https=False, # this is handled at the load balancer
legacy_content_security_policy_header=True,
strict_transport_security=True,
strict_transport_security_max_age=ONE_YEAR_IN_SECONDS,
referrer_policy=DEFAULT_REFERRER_POLICY,
frame_options='SAMEORIGIN',
frame_options_allow_from=None,
session_cookie_secure=True,
session_cookie_http_only=True)
app.name = "response_operations_ui"
CSRFProtect(app)
# Load css and js assets
assets = Environment(app)
if app.config['DEBUG'] or app.config['TESTING']:
assets.cache = False
assets.manifest = None
if not app.config['DEBUG']:
app.wsgi_app = GCPLoadBalancer(app.wsgi_app)
assets.url = app.static_url_path
app.jinja_env.add_extension('jinja2.ext.do')
app.register_blueprint(filter_blueprint)
app.url_map.strict_slashes = False
app.secret_key = app.config['RESPONSE_OPERATIONS_UI_SECRET']
logger_initial_config(service_name='response-operations-ui', log_level=app.config['LOGGING_LEVEL'])
logger = wrap_logger(logging.getLogger(__name__))
logger.info('Logger created', log_level=app.config['LOGGING_LEVEL'])
login_manager = LoginManager(app)
login_manager.init_app(app)
login_manager.login_view = "sign_in_bp.sign_in"
@app.context_processor
def inject_availability_message():
redis_avail_msg = app.config['SESSION_REDIS']
if len(redis_avail_msg.keys('AVAILABILITY_MESSAGE_RES_OPS')) == 1:
return {
"availability_message": redis_avail_msg.get('AVAILABILITY_MESSAGE_RES_OPS').decode('utf-8')
}
return {}
@login_manager.user_loader
def user_loader(user_id):
username = session.get('username')
return User(user_id, username)
# wrap in the flask server side session manager and back it by redis
app.config['SESSION_REDIS'] = redis.StrictRedis(host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
db=app.config['REDIS_DB'])
app.jinja_environment.lstrip_blocks = True
if app.config['DEBUG'] or os.environ.get('JINJA_RELOAD'):
app.jinja_env.auto_reload = True
Session(app)
setup_blueprints(app)
return app
from flask import Flask, render_template
from flask_assets import Environment, Bundle
from flask_frozen import Freezer
SITE_ROOT = os.path.dirname(os.path.realpath(__file__))
app = Flask(
import_name=__name__,
static_folder=os.path.join(SITE_ROOT, '..', '..', 'static'),
template_folder=os.path.join(SITE_ROOT, '..', '..', 'templates'),
)
assets = Environment(app)
assets.manifest = False
assets.cache = False
assets.debug = True
freezer = Freezer(app)
app.config.update(
DEBUG=True,
FREEZER_DESTINATION=os.path.join(SITE_ROOT, '..', '..', 'build')
)
assets.register('js_all', Bundle(
'js/website.js',
filters='jsmin',
output='build/website.js'
))
])
app.jinja_loader = my_loader
db = SQLAlchemy(app)
Markdown(app, extensions=['footnotes'])
pages = FlatPages(app)
manager = Manager(app)
# Scss
assets = Environment(app)
assets.url_expire = True
assets.auto_build = True
assets.append_path('sni/assets')
assets.cache = 'sni/assets/.webassets-cache'
scss = Bundle('scss/__main__.scss', filters='pyscss', output='css/main.css',
depends=['scss/*.scss'])
assets.register('scss_all', scss)
assets.debug = False
app.config['ASSETS_DEBUG'] = False
cache = Cache(app, config={'CACHE_TYPE': 'simple'})
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
file_handler = RotatingFileHandler('tmp/snilog.csv',
'a',
def compile_assets(app):
assets = Environment(app)
js = Bundle(
'js/*.js', # 'home_bp/js/*.js', 'admin_bp/js/*.js',
filters='jsmin',
output='gen/packed.js')
css = Bundle('css/*.css',
'css/dash/*.css',
'home_bp/css/*.css',
'admin_bp/css/*.css',
'auth_bp/css/*.css',
'shopping_add_bp/css/*.css',
'shopping_view_bp/css/*.css',
filters='cssmin',
output='gen/packed.css')
jquery = Bundle('js/jquery/jquery.min.js',
filters='jsmin',
output='gen/jquery.js')
chosen_css = Bundle('css/chosen/chosen.min.css',
filters='cssmin',
output='gen/chosen.css')
chosen_js = Bundle('js/chosen/chosen.jquery.js',
filters='jsmin',
output='gen/chosen.js')
jrange_css = Bundle('css/jrange/jquery.range.css',
filters='cssmin',
output='gen/jrange.css')
jrange_js = Bundle('js/jrange/jquery.range.js',
filters='jsmin',
output='gen/jrange.js')
datatables_css = Bundle('css/datatables/jquery.dataTables.css',
'css/datatables/jquery.dataTables_OVERRIDES.css',
filters='cssmin',
output='gen/datatables.css')
datatables_js = Bundle('js/datatables/jquery.dataTables.js',
filters='jsmin',
output='gen/datatables.js')
daterangepicker_css = Bundle('css/daterangepicker/daterangepicker.css',
filters='cssmin',
output='gen/daterangepicker.css')
daterangepicker_js = Bundle('js/daterangepicker/moment.min.js',
'js/daterangepicker/daterangepicker.js',
filters='jsmin',
output='gen/daterangepicker.js')
flexdatalist_css = Bundle('css/flexdatalist/jquery.flexdatalist.css',
filters='cssmin',
output='gen/flexdatalist.css')
flexdatalist_js = Bundle('js/flexdatalist/jquery.flexdatalist.js',
filters='jsmin',
output='gen/flexdatalist.js')
jquerymodal_css = Bundle('css/jquerymodal/jquery.modal.min.css',
filters='cssmin',
output='gen/jquerymodal.css')
jquerymodal_js = Bundle('js/jquerymodal/jquery.modal.min.js',
filters='jsmin',
output='gen/jquerymodal.js')
plotly_js = Bundle('js/plotly/plotly.basic.js',
filters='jsmin',
output='gen/plotly.js')
bundles = {
'js_all': js,
'css_all': css,
'chosen_css': chosen_css,
'chosen_js': chosen_js,
'jrange_css': jrange_css,
'jrange_js': jrange_js,
'jquery': jquery,
'datatables_js': datatables_js,
'datatables_css': datatables_css,
'daterangepicker_js': daterangepicker_js,
'daterangepicker_css': daterangepicker_css,
'flexdatalist_js': flexdatalist_js,
'flexdatalist_css': flexdatalist_css,
'jquerymodal_js': jquerymodal_js,
'jquerymodal_css': jquerymodal_css,
'plotly_js': plotly_js,
}
# selinux prevents flask-assets to dynamically build/access cached files
if app.config['DISABLE_CACHE']:
assets.cache = False
assets.manifest = False
assets.register(bundles)
# assets.register('css_all', css)
return assets
def create_app(config_name=None):
csp_policy = copy.deepcopy(CSP_POLICY)
app = Flask(__name__)
app_config = f'config.{config_name or os.environ.get("APP_SETTINGS", "Config")}'
app.config.from_object(app_config)
if Config.WTF_CSRF_ENABLED:
Talisman(
app,
content_security_policy=csp_policy,
content_security_policy_nonce_in=["script-src"],
force_https=False, # this is handled at the load balancer
strict_transport_security=True,
strict_transport_security_max_age=ONE_YEAR_IN_SECONDS,
referrer_policy=DEFAULT_REFERRER_POLICY,
frame_options="SAMEORIGIN",
frame_options_allow_from=None,
session_cookie_secure=True,
session_cookie_http_only=True,
)
app.name = "response_operations_ui"
csrf = CSRFProtect(app)
# Load css and js assets
assets = Environment(app)
if app.config["DEBUG"] or app.config["TESTING"]:
assets.cache = False
assets.manifest = None
if not app.config["DEBUG"]:
app.wsgi_app = GCPLoadBalancer(app.wsgi_app)
assets.url = app.static_url_path
app.jinja_env.add_extension("jinja2.ext.do")
app.jinja_env.globals["hasPermission"] = user_has_permission
app.register_blueprint(filter_blueprint)
app.url_map.strict_slashes = False
app.secret_key = app.config["RESPONSE_OPERATIONS_UI_SECRET"]
logger_initial_config(service_name="response-operations-ui",
log_level=app.config["LOGGING_LEVEL"])
logger = wrap_logger(logging.getLogger(__name__))
logger.info("Logger created", log_level=app.config["LOGGING_LEVEL"])
login_manager = LoginManager(app)
login_manager.init_app(app)
login_manager.login_view = "sign_in_bp.sign_in"
@app.errorhandler(CSRFError)
def handle_csrf_error(e):
flash("Your session timed out", category="info")
return redirect(url_for("logout_bp.logout"))
@app.before_request
def before_request():
session.permanent = True # set session to use PERMANENT_SESSION_LIFETIME
session.modified = True # reset the session timer on every request
try:
csrf.protect()
except Exception as e:
if e.code == 400:
logger.warning(e.description)
logger.warning(e)
@app.context_processor
def inject_availability_message():
redis_avail_msg = app.config["SESSION_REDIS"]
if len(redis_avail_msg.keys("AVAILABILITY_MESSAGE_RES_OPS")) == 1:
return {
"availability_message":
redis_avail_msg.get("AVAILABILITY_MESSAGE_RES_OPS").decode(
"utf-8")
}
return {}
@login_manager.user_loader
def user_loader(user_id):
username = session.get("username")
return User(user_id, username)
# wrap in the flask server side session manager and back it by redis
app.config["SESSION_REDIS"] = redis.StrictRedis(
host=app.config["REDIS_HOST"],
port=app.config["REDIS_PORT"],
db=app.config["REDIS_DB"])
app.jinja_environment.lstrip_blocks = True
if app.config["DEBUG"] or os.environ.get("JINJA_RELOAD"):
app.jinja_env.auto_reload = True
Session(app)
setup_blueprints(app)
return app
])
app.jinja_loader = my_loader
db = SQLAlchemy(app)
Markdown(app, extensions=['footnotes'])
pages = FlatPages(app)
manager = Manager(app)
# Scss
assets = Environment(app)
assets.url_expire = True
assets.auto_build = True
assets.append_path('sni/assets')
assets.cache = 'sni/assets/.webassets-cache'
scss = Bundle('scss/__main__.scss',
filters='pyscss',
output='css/main.css',
depends=['scss/*.scss'])
assets.register('scss_all', scss)
assets.debug = False
app.config['ASSETS_DEBUG'] = False
cache = Cache(app, config={'CACHE_TYPE': 'simple'})
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
app.register_blueprint(admin.mod, url_prefix='/admin')
app.config['max_content_length'] = config_frontend.get('max_content_length')
if topic_flag:
app.register_blueprint(topics.mod)
csrf = CSRFProtect(app)
assets = Environment(app)
if config_frontend.get('data_path', None):
data_path = config_frontend['data_path']
cache_path = os.path.join(data_path, 'cache', '.webassets-cache')
static_path = os.path.abspath(os.path.join(data_path, 'static'))
pathlib.Path(cache_path).mkdir(parents=True, exist_ok=True)
assets.cache = os.path.abspath(cache_path)
assets.directory = os.path.abspath(static_path)
app.static_folder = static_path
if os.path.exists(static_path):
shutil.rmtree(static_path)
shutil.copytree(os.path.join(app.root_path, 'static'), static_path)
# Do not automatically build assets in deployment for performance
assets.auto_build = False
assets.append_path(os.path.join(app.root_path, 'uncompiled_assets'))
js_bundle = Bundle('javascript/autocomplete.js',
'javascript/evaluation.js',
'javascript/utils.js',
'javascript/forms.js',
import os
from flask_assets import Bundle, Environment
from . import app
# Assets
webassets = Environment(app)
webassets.load_path = [
os.path.join(os.path.dirname(__file__), "static"),
os.path.join(os.path.dirname(__file__), "bower_components")
]
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = True # app.debug
js_main = Bundle("js/src/main.js", output="js/main.js")
css_main = Bundle("css/src/styles.css", output="css/main.css")
js_libs = Bundle("jquery/dist/jquery.min.js",
"semantic-ui/dist/semantic.min.js",
output="js/libs.js")
css_libs = Bundle("font-awesome/web-fonts-with-css/css/fontawesome.min.css",
"semantic-ui/dist/semantic.min.css",
output="css/libs.css")
webassets.register('js_main', js_main)
webassets.register('js_libs', js_libs)
webassets.register('css_main', css_main)
webassets.register('css_libs', css_libs)
application = Flask(__name__,\
static_folder="platus/static/",\
template_folder="platus/templates/",
static_url_path="/static")
application.register_blueprint(web)
application.register_blueprint(api)
application.config.update(config.from_yaml("data/config.yaml"))
# Scss
assets = Environment(application)
assets.versions = 'timestamp'
assets.url_expire = True
assets.manifest = 'file:/tmp/manifest.to-be-deployed' # explict filename
assets.cache = False
assets.auto_build = True
assets.url = application.static_url_path
scss = Bundle('scss/00_main.scss',
filters='pyscss',
output='css/main.css',
depends=['scss/*.scss'])
assets.register('scss_all', scss)
assets.debug = False
application.config['ASSETS_DEBUG'] = False
# Set Logger
log_levels = {
"info": logging.INFO,
FLATPAGES_AUTO_RELOAD = DEBUG
FLATPAGES_EXTENSION = '.md'
# LESS_BIN = os.path.join(SCRIPT_ROOT, '..', 'node_modules', 'less', 'bin', 'lessc')
LESS_LINE_NUMBERS = 'mediaquery'
FREEZER_DESTINATION = os.path.join(SITE_ROOT, '..', '..', 'build')
FLATPAGES_ROOT = os.path.join(SITE_ROOT, '..', '..', 'pages')
app = Flask(
import_name='codingnotes',
static_folder=os.path.join(SITE_ROOT, '..', '..', 'static'),
template_folder=os.path.join(SITE_ROOT, '..', '..', 'templates'),
)
assets = Environment(app)
assets.manifest = False
assets.cache = False
if DEBUG:
assets.manifest = False
assets.cache = None
freezer = Freezer(app)
pages_on_disk = FlatPages(app)
app.config.from_object(__name__)
def is_published(post_date):
return utc.localize(datetime.utcnow()) >= utc.localize(datetime.combine(post_date, time(0, 0, 0)))
published_pages = sorted([p for p in pages_on_disk if is_published(p.meta.get('date', '2099-12-31'))], key=lambda p: p.meta['date'])
def get_latest_pages(limit=10):
def run(datapath):
"""
starts the frontend server
datapath: directory for saving and loading requirement projects
"""
with open(join(dirname(dirname(__file__)), 'VERSION'),
mode='r') as version_file:
stlinspector_version = version_file.read()
app = Flask(__name__)
# interface to the projects and backend
projectList = ProjectList(datapath)
# temporal directory for caching etc.
tempDir = mkdtemp(prefix="STLInspector")
# Bundle the javascript files into one distribution file
# and the css file such that it is reloaded on a change
bundles = {
'STLInspector_js':
Bundle('js/AlertView.js',
'js/BooleanChart.js',
'js/Project.js',
'js/Projects.js',
'js/ProjectsView.js',
'js/ProjectView.js',
'js/RealChart.js',
'js/ServerRequest.js',
'js/SignalView.js',
'js/STLInspector.js',
output='build/STLInspector.js'),
'STLInspector_css':
Bundle('css/STLInspector.css', output='build/STLInspector.css')
}
assets = Environment(app)
assetscachepath = join(tempDir, 'assetscache')
# create directory if not already present
if not access(assetscachepath, F_OK):
mkdir(assetscachepath)
assets.cache = assetscachepath
assetsdirectorypath = join(tempDir, 'assetsdirectory')
# create directory if not already present
if not access(assetsdirectorypath, F_OK):
mkdir(assetsdirectorypath)
assets.directory = assetsdirectorypath
assets.register(bundles)
@app.route("/")
def index():
"""index page loader
loads and renders the index template
"""
return render_template('index.html',
stlinspector_version=stlinspector_version)
@app.route('/static/build/<path:filename>')
def static_build_files(filename):
"""
serve static build files from cache directory
"""
return send_from_directory(join(assetsdirectorypath, 'build'),
filename)
@app.route("/documentation/")
def documentation():
"""renders the documentation page"""
fdoc = open(join(dirname(dirname(__file__)), "doc/documentation.md"),
"r")
doc = markdown.Markdown(extensions=['mdx_math'],
extension_configs={
'mdx_math': {
'enable_dollar_delimiter': True
}
}).convert(fdoc.read())
fdoc.close()
return render_template('documentation.html', doctext=Markup(doc))
@app.route('/documentation/images/<path:filename>')
def documentation_images(filename):
return send_from_directory('../doc/images', filename)
@app.route("/api/projects/list", methods=['POST'])
def api_projects_list():
"""project list loader"""
try:
return Response(json.dumps(projectList.list()),
mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/projects/create", methods=['POST'])
def api_projects_create():
"""create a project with given name"""
try:
projectTitle = request.form['title']
return Response(json.dumps(projectList.create(projectTitle)),
mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/projects/delete", methods=['POST'])
def api_projects_delete():
"""deletes the project file"""
try:
projectId = request.form['id']
projectList.delete(projectId)
return Response('true', mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/project/save", methods=['POST'])
def api_project_save():
"""saves the project to file"""
try:
projectId = request.form['id']
projectList.saveProject(projectId)
return Response('true', mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/project/close", methods=['POST'])
def api_project_close():
"""is called when a project is closed in the frontend"""
try:
projectId = request.form['id']
projectList.close(projectId)
return Response('true', mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/project/load", methods=['POST'])
def api_project_load():
"""returns the data of a project with the given id"""
try:
projectId = request.form['id']
project = projectList.project(projectId)
return Response(json.dumps(project.state()),
mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/project/change", methods=['POST'])
def api_project_change():
"""changes project variables"""
try:
projectId = request.form['id']
project = projectList.project(projectId)
if 'stlCandidate' in request.form:
project.setStlCandidate(request.form['stlCandidate'])
if 'textRequirement' in request.form:
project.setTextRequirement(request.form['textRequirement'])
if 'textNotes' in request.form:
project.setTextNotes(request.form['textNotes'])
return Response('true', mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/project/test", methods=['POST'])
def api_project_test():
"""returns an existing or new test signal"""
try:
projectId = request.form['id']
test_type = request.form['type']
parameter = request.form['parameter']
project = projectList.project(projectId)
if test_type == 'evaluate':
test = project.testForName(parameter)
else:
test = project.testById(int(parameter))
return Response(json.dumps(test), mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
@app.route("/api/project/testEvaluation", methods=['POST'])
def api_project_testEvaluation():
"""returns an existing or new test signal"""
try:
projectId = request.form['id']
testId = int(request.form['testId'])
username = request.form['username']
evaluation = request.form['evaluation'] == 'true'
project = projectList.project(projectId)
project.setTestEvaluation(testId, username, evaluation)
return Response('true', mimetype='application/json')
except Exception as e:
exceptionHandler(e)
abort(500)
webbrowser.open_new_tab('http://localhost:{}'.format(PORT))
app.run(debug=False, port=PORT)
def setup_assets(app):
assets = Environment(app)
assets.url_expire = True
assets.cache = False
assets.manifest = False
assets.load_path = [
os.path.join(app.config['PROJECT_ROOT'], 'static'),
os.path.join(app.config['PROJECT_ROOT'], 'bower_components')
]
css_main = Bundle(
'bootstrap/dist/css/bootstrap.min.css',
'bootstrap-toggle/css/bootstrap-toggle.min.css',
'awesome-bootstrap-checkbox/awesome-bootstrap-checkbox.css',
'datatables/media/css/jquery.dataTables.min.css',
'datatables/media/css/dataTables.bootstrap.min.css',
'bootstrap-datepicker/dist/css/bootstrap-datepicker.min.css',
'clockpicker/dist/bootstrap-clockpicker.min.css',
'eonasdan-bootstrap-datetimepicker/build/css/bootstrap-datetimepicker.min.css', # NOQA
'emojione/assets/css/emojione.min.css',
'emojionearea/dist/emojionearea.min.css',
'js/plugins/export/export.css',
'main.css',
# inspinia theme files
'inspinia_v2.7.1/css/style.css',
'inspinia_v2.7.1/css/animate.css',
'inspinia_v2.7.1/font-awesome/css/font-awesome.min.css',
)
js_main = Bundle(
'jquery/dist/jquery.min.js',
'jquery-ui/jquery-ui.min.js',
'bootstrap/dist/js/bootstrap.min.js',
'bootstrap-toggle/js/bootstrap-toggle.min.js',
'datatables/media/js/jquery.dataTables.min.js',
'datatables/media/js/dataTables.bootstrap.min.js',
'moment/min/moment-with-locales.min.js',
'bootstrap-datepicker/dist/js/bootstrap-datepicker.min.js',
'clockpicker/dist/bootstrap-clockpicker.min.js',
'eonasdan-bootstrap-datetimepicker/build/js/bootstrap-datetimepicker.min.js', # NOQA
'jquery-textcomplete/dist/jquery.textcomplete.min.js',
'emojione/lib/js/emojione.min.js',
'emojionearea/dist/emojionearea.min.js',
# amcharts files
'js/amcharts.js',
'js/serial.js',
'js/pie.js',
'js/plugins/export/export.min.js',
'js/themes/light.js',
# amcharts libs for export
'js/plugins/export/libs/pdfmake/pdfmake.min.js',
'js/plugins/export/libs/pdfmake/vfs_fonts.js',
'js/plugins/export/libs/jszip/jszip.min.js',
'js/plugins/export/libs/fabric.js/fabric.min.js',
'js/plugins/export/libs/FileSaver.js/FileSaver.min.js',
'main.js',
)
js_bulletin_edit = Bundle(
js_main,
'bulletin-edit.js'
)
js_story_edit = Bundle(
js_main,
'story-edit.js'
)
css_landing = Bundle(
'landing.css',
'emojione/assets/css/emojione.min.css',
)
js_landing = Bundle(
'jquery/dist/jquery.min.js',
'hamburger.menu.js',
'typed.js/lib/typed.min.js',
)
assets.register('css_main', css_main, output='dist/css/main.css')
assets.register('js_main', js_main, output='dist/js/main.js')
assets.register('js_bulletin_edit', js_bulletin_edit,
output='dist/js/bulletin-edit.js')
assets.register('js_story_edit', js_story_edit,
output='dist/js/story-edit.js')
assets.register('css_landing', css_landing, output='dist/css/landing.css')
assets.register('js_landing', js_landing, output='dist/js/landing.js')
app.config['RECIPES_FILE'] = 'storage/data/{game_version}/recipes.json'
app.config['ESCAPISTS_WIKI_DOMAIN'] = 'theescapists.gamepedia.com'
app.config['COMPRESS_MIN_SIZE'] = 1024
cache = Cache(app)
assets = Environment(app)
if app.config['ENV'] == 'production':
from flask_compress import Compress
Compress(app)
if has_debug_toolbar_ext:
toolbar = DebugToolbarExtension(app)
assets.cache = 'storage/webassets-cache/'
assets.register(
'js_home',
Bundle('js/common.js',
'js/home.js',
filters='jsmin',
output='js/home.min.js'))
assets.register(
'js_recipes_editor',
Bundle('js/common.js',
'js/recipes_editor.js',
filters='jsmin',
output='js/recipes_editor.min.js'))
assets.register(
'css_app',
'tendril_css': Bundle(
'css/tendril.css',
output='gen/tendril.css',
filters='cssmin'
),
'nvd3_js': Bundle(
'js/d3/d3.js',
'js/d3/nv.d3.js',
output='gen/nv.d3.js',
filters='jsmin'
),
'nvd3_css': Bundle(
'css/nv.d3.css',
output='gen/nv.d3.css',
filters='cssmin'
),
'mixer_js': Bundle(
'js/mixer.js',
output='gen/tendril.js',
filters='jsmin',
)
}
assets = Environment(app)
assets.cache = os.path.join(INSTANCE_CACHE, 'flaskassetcache')
assets.register(bundles)
FLATPAGES_EXTENSION = '.md'
# LESS_BIN = os.path.join(SCRIPT_ROOT, '..', 'node_modules', 'less', 'bin', 'lessc')
LESS_LINE_NUMBERS = 'mediaquery'
FREEZER_DESTINATION = os.path.join(SITE_ROOT, '..', '..', 'build')
FLATPAGES_ROOT = os.path.join(SITE_ROOT, '..', '..', 'pages')
app = Flask(
import_name='codingnotes',
static_folder=os.path.join(SITE_ROOT, '..', '..', 'static'),
template_folder=os.path.join(SITE_ROOT, '..', '..', 'templates'),
)
assets = Environment(app)
assets.debug = DEBUG
assets.manifest = None
assets.cache = None
freezer = Freezer(app)
pages_on_disk = FlatPages(app)
app.config.from_object(__name__)
def is_published(post_date):
return utc.localize(datetime.utcnow()) >= utc.localize(datetime.combine(post_date, time(0, 0, 0)))
published_pages = sorted([p for p in pages_on_disk if is_published(p.meta.get('date', '2099-12-31'))], key=lambda p: p.meta['date'])
def get_latest_pages(limit=10):
pages = published_pages if not request.args.get('preview') else pages_on_disk
# Articles are pages with a publication date
articles = (p for p in pages if 'date' in p.meta)
'js/datatables/vfs_fonts.js',
'js/datatables/dataTables.buttons.js',
'js/datatables/buttons.print.js',
'js/datatables/buttons.html5.js',
'js/datatables/buttons.colVis.js',
'js/datatables/buttons.foundation.js',
'js/datatables/dataTables.select.js',
'js/datatables/dataTables.keyTable.js',
output='gen/datatables.js',
filters='jsmin'),
'tendril_css':
Bundle('css/tendril.css', output='gen/tendril.css', filters='cssmin'),
'nvd3_js':
Bundle('js/d3/d3.js',
'js/d3/nv.d3.js',
output='gen/nv.d3.js',
filters='jsmin'),
'nvd3_css':
Bundle('css/nv.d3.css', output='gen/nv.d3.css', filters='cssmin'),
'mixer_js':
Bundle(
'js/mixer.js',
output='gen/tendril.js',
filters='jsmin',
)
}
assets = Environment(app)
assets.cache = os.path.join(INSTANCE_CACHE, 'flaskassetcache')
assets.register(bundles)
def create_app(config_filename="config"):
"""Flask application factory.
This is the flask application factory for this project. It loads the
other submodules used to runs the collectives website. It also creates
the blueprins and init apps.
:param config_filename: name of the application config file.
:type config_filename: string
:return: A flask application for collectives
:rtype: :py:class:`flask.Flask`
"""
app = Flask(__name__, instance_relative_config=True)
app.wsgi_app = ReverseProxied(app.wsgi_app)
# Config options - Make sure you created a 'config.py' file.
app.config.from_object(config_filename)
app.config.from_pyfile("config.py")
# To get one variable, tape app.config['MY_VARIABLE']
fileConfig(app.config["LOGGING_CONFIGURATION"],
disable_existing_loggers=False)
# Initialize plugins
models.db.init_app(app)
auth.login_manager.init_app(app) # app is a Flask object
api.marshmallow.init_app(app)
profile.images.init_app(app)
extranet.api.init_app(app)
payline.api.init_app(app)
app.context_processor(jinja.helpers_processor)
_migrate = Migrate(app, models.db)
with app.app_context():
# Initialize asset compilation
assets = Environment(app)
filters = "libsass"
if app.config["ENV"] == "production":
filters = "libsass, cssmin"
assets.auto_build = False
assets.debug = False
assets.cache = True
else:
assets.auto_build = True
assets.debug = True
scss = Bundle(
"css/all.scss",
filters=filters,
depends=("/static/css/**/*.scss", "**/*.scss", "**/**/*.scss"),
output="dist/css/all.css",
)
assets.register("scss_all", scss)
if app.config["ENV"] == "production":
scss.build()
# Register blueprints
app.register_blueprint(root.blueprint)
app.register_blueprint(profile.blueprint)
app.register_blueprint(api.blueprint)
app.register_blueprint(administration.blueprint)
app.register_blueprint(auth.blueprint)
app.register_blueprint(event.blueprint)
app.register_blueprint(payment.blueprint)
app.register_blueprint(technician.blueprint)
app.register_blueprint(activity_supervison.blueprint)
# Error handling
app.register_error_handler(werkzeug.exceptions.NotFound,
error.not_found)
app.register_error_handler(werkzeug.exceptions.InternalServerError,
error.server_error)
forms.configure_forms(app)
forms.csrf.init_app(app)
# Initialize DB
# models.db.create_all()
populate_db(app)
return app
def init_app(app):
webassets = Environment(app)
webassets.register('js_build', js_build)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def create_app(config_name=None):
app = Flask(__name__)
app.name = "response_operations_ui"
app_config = f'config.{config_name or os.environ.get("APP_SETTINGS", "Config")}'
app.config.from_object(app_config)
# Load css and js assets
assets = Environment(app)
if app.config['DEBUG'] or app.config['TESTING']:
assets.cache = False
assets.manifest = None
assets.url = app.static_url_path
app.jinja_env.add_extension('jinja2.ext.do')
app.register_blueprint(filter_blueprint)
app.url_map.strict_slashes = False
app.secret_key = app.config['RESPONSE_OPERATIONS_UI_SECRET']
# Zipkin
zipkin = Zipkin(app=app, sample_rate=app.config.get("ZIPKIN_SAMPLE_RATE"))
requestsdefaulter.default_headers(zipkin.create_http_headers_for_new_span)
logger_initial_config(service_name='response-operations-ui',
log_level=app.config['LOGGING_LEVEL'])
logger = wrap_logger(logging.getLogger(__name__))
logger.info('Logger created', log_level=app.config['LOGGING_LEVEL'])
login_manager = LoginManager(app)
login_manager.init_app(app)
login_manager.login_view = "sign_in_bp.sign_in"
@app.context_processor
def inject_availability_message():
redis_avail_msg = app.config['SESSION_REDIS']
if len(redis_avail_msg.keys('AVAILABILITY_MESSAGE_RES_OPS')) == 1:
return {
"availability_message":
redis_avail_msg.get('AVAILABILITY_MESSAGE_RES_OPS').decode(
'utf-8')
}
return {}
@login_manager.user_loader
def user_loader(user_id):
return User(user_id)
if cf.detected:
with app.app_context():
# If deploying in cloudfoundry set config to use cf redis instance
logger.info(
'Cloudfoundry detected, setting service configurations')
service = cf.redis
app.config['REDIS_HOST'] = service.credentials['host']
app.config['REDIS_PORT'] = service.credentials['port']
# wrap in the flask server side session manager and back it by redis
app.config['SESSION_REDIS'] = redis.StrictRedis(
host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
db=app.config['REDIS_DB'])
app.jinja_environment.lstrip_blocks = True
if app.config['DEBUG'] or os.environ.get('JINJA_RELOAD'):
app.jinja_env.auto_reload = True
Session(app)
setup_blueprints(app)
return app
