def create_app():
app = Flask(__name__)
app.config.from_object(BasicConfig)
bootstrap.init_app(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdn.bootcss.com/jquery/1.11.3/')
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN(
'//cdn.bootcss.com/bootstrap/3.3.5/')
db.init_app(app)
login_manager.init_app(app)
moment.init_app(app)
triangle.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .task import task as task_blueprint
app.register_blueprint(task_blueprint)
from .api import api as api_blueprint
app.register_blueprint(api_blueprint)
return app
def change_cdn(app):
cdns = app.extensions['bootstrap']['cdns']
local = cdns['local']
static = cdns['static']
def lwrap(cdn, primary=static):
return ConditionalCDN('BOOTSTRAP_SERVE_LOCAL', primary, cdn)
bootstrap = lwrap(
WebCDN('//cdn.bootcss.com/bootstrap/%s/' %
BOOTSTRAP_VERSION), local)
jquery = lwrap(
WebCDN('//cdn.bootcss.com/jquery/%s/' %
JQUERY_VERSION), local)
html5shiv = lwrap(
WebCDN('//cdn.bootcss.com/html5shiv/%s/' %
HTML5SHIV_VERSION))
respondjs = lwrap(
WebCDN('//cdn.bootcss.com/respond.js/%s/' %
RESPONDJS_VERSION))
app.extensions['bootstrap'] = {
'cdns': {
'local': local,
'static': static,
'bootstrap': bootstrap,
'jquery': jquery,
'html5shiv': html5shiv,
'respond.js': respondjs,
},
}
def bs_init_app(app):
local = StaticCDN('bootstrap.static', rev=True)
static = StaticCDN()
def lwrap(cdn, primary=static):
return ConditionalCDN('BOOTSTRAP_SERVE_LOCAL', primary, cdn)
__version__ = '4.0.0'
bootstrap_version_re = re.compile(r'(\d+\.\d+\.\d+(\-[a-z]+)?)')
popper_version = '1.16.0'
jquery_version = '3.4.1'
fontawesome_version = '5.14.0'
def get_bootstrap_version(version):
return bootstrap_version_re.match(version).group(1)
bootstrap_version = get_bootstrap_version(__version__)
popper = lwrap(
WebCDN('//cdnjs.cloudflare.com/ajax/libs/popper.js/%s/' %
popper_version), local)
bs = lwrap(
WebCDN('//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/%s/' %
bootstrap_version), local)
fontawesome = lwrap(
WebCDN('//cdnjs.cloudflare.com/ajax/libs/font-awesome/%s/' %
fontawesome_version), local)
jquery = lwrap(
WebCDN('//cdnjs.cloudflare.com/ajax/libs/jquery/%s/' %
jquery_version), local)
app.extensions['bootstrap'] = {
'cdns': {
'local': local,
'static': static,
'popper': popper,
'bootstrap': bs,
'fontawesome': fontawesome,
'jquery': jquery,
},
}
# setup support for flask-nav
renderers = app.extensions.setdefault('nav_renderers', {})
renderer_name = (__name__ + '.nav', 'BootstrapRenderer')
renderers['bootstrap'] = renderer_name
# make bootstrap the default renderer
renderers[None] = renderer_name
def register_app_cdn(app):
# DataTable for displaying information in a grid
app.extensions['bootstrap']['cdns']['dataTable'] = WebCDN(
'https://cdn.datatables.net/1.10.16/')
# Buttons for saving/printing
app.extensions['bootstrap']['cdns']['dataTableBtns'] = WebCDN(
'https://cdn.datatables.net/buttons/1.5.1/')
app.extensions['bootstrap']['cdns']['saveJs'] = WebCDN(
'https://cdnjs.cloudflare.com/ajax/libs/')
app.extensions['bootstrap']['cdns']['multiselect'] = WebCDN(
'https://cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.12.4/')
app.extensions['bootstrap']['cdns']['fontAwesome'] = WebCDN(
'https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/')
def get_cdn(key, primary=static):
base_url = app.config.get('BOOTSTRAP_WEB_CDN_BASE_URLS').get(key)
if base_url:
web_cdn = WebCDN(base_url)
return ConditionalCDN('BOOTSTRAP_SERVE_LOCAL', primary, web_cdn)
else:
return None
def change_one(tar_lib, tar_ver, fallback):
# tar_js = ConditionalCDN('BOOTSTRAP_SERVE_LOCAL', fallback,
# WebCDN('//cdn.bootcss.com/' + tar_lib + '/' + tar_ver + '/'))
tar_js = ConditionalCDN('BOOTSTRAP_SERVE_LOCAL', fallback,
WebCDN('/static/'))
tar_app.extensions['bootstrap']['cdns'][tar_lib] = tar_js
def create_app(debug=True):
app = Flask(__name__)
app.config.from_object(config)
app.debug = debug
db.init_app(app)
bootstrap.init_app(app)
redis_store.init_app(app)
login_manager.init_app(app)
make_celery(celery, app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(app.config['CDN'])
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN(
app.config['CDN'])
from .main import main
app.register_blueprint(main)
return app
def create_app():
app = Flask(__name__)
app.config.from_pyfile(get_config_file(app.root_path))
Bootstrap(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.1/')
app.secret_key = app.config['SECRET_KEY']
return app
def create_app():
app = Flask(__name__)
Bootstrap(app)
app.extensions["bootstrap"]["cdns"]["jquery"] = WebCDN(
"//cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/")
app.extensions["bootstrap"]["cdns"]["bootstrap"] = WebCDN(
"//maxcdn.bootstrapcdn.com/bootstrap/4.0.0-beta.3/")
app.config["TEMPLATES_AUTO_RELOAD"] = True
app.jinja_env.auto_reload = True
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True
app.jinja_env.keep_trailing_newline = True
return app
def create_app():
app = Flask(__name__)
app.config.update(SECRET_KEY="devkey")
Bootstrap(app)
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN('https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/')
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN('https://cdn.bootcdn.net/ajax/libs/jquery/1.12.4/')
nav.init_app(app)
login_manager.init_app(app)
app.register_blueprint(frontend)
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdn.bootcss.com/jquery/1.11.3/jquery.min.js'
)
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN(
'//cdn.bootcss.com/bootstrap/3.3.5/'
)
db.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .qsyk import qsyk as qsyk_blueprint
app.register_blueprint(qsyk_blueprint)
return app
def register_extensions(app):
"""Register Flask extensions."""
BCRYPT.init_app(app)
DB.init_app(app)
MAIL.init_app(app)
BOOTSTRAP.init_app(app)
bootstrapcdn = WebCDN(
"https://stackpath.bootstrapcdn.com/bootstrap/3.3.7/")
bootswatchcdn = WebCDN(
"https://stackpath.bootstrapcdn.com/bootswatch/3.3.7/")
app.extensions['bootstrap']['cdns'].update({
'bootstrapcdn': bootstrapcdn,
'bootswatchcdn': bootswatchcdn
})
CSRF.init_app(app)
def create_app(config_name):
app = Flask(__name__)
template_filters = {
name: function
for name, function in getmembers(jinja_filters) if isfunction(function)
}
app.jinja_env.filters.update(template_filters)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
csrf.init_app(app)
celery.conf.update(app.config)
sentry.init_app(app,
dsn=app.config['SENTRY_DSN_SECRET'],
logging=app.config['SENTRY_LOGGING'],
level=app.config['SENTRY_LOGGING_LEVEL'])
# change jquery version with another CDN
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.1/')
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
sslify = SSLify(app)
# info pages
from .info import info as info_blueprint
app.register_blueprint(info_blueprint)
# bot main logic
from .webhook import webhook as webhook_blueprint
app.register_blueprint(webhook_blueprint, url_prefix='/webhook')
# user authentication/registration
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
# administration dashboard
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/dashboard')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
bootstrap.init_app(app)
login_manager.init_app(app)
moment.init_app(app)
global ma
ma = Marshmallow(app) # Hack
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
sslify = SSLify(app)
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix="/auth")
from .frontend import frontend as frontend_blueprint
app.register_blueprint(frontend_blueprint)
from .gallery import gallery as gallery_blueprint
app.register_blueprint(gallery_blueprint, url_prefix="/gallery")
from .battle import battle as battle_blueprint
app.register_blueprint(battle_blueprint, url_prefix="/battles")
from .api import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api')
from .frontend import nav
nav.init_app(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.2.4/' # Use jquery 2
)
return app
def create_app(config_name):
app = Flask(__name__)
# import config here rather than at module level to ensure that .env values
# are loaded into the environment first when running manage.py
from config import config
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
# Set jquery version
from flask_bootstrap import WebCDN
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/')
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
# Tell browser not to cache any HTML responses, as most pages have
# sensitive information in them. (But CSS should be cached as normal.)
@app.after_request
def apply_caching(response):
if response.headers.get('Content-Type', '').startswith('text/html'):
response.headers['Cache-control'] = 'no-store'
response.headers['Pragma'] = 'no-cache'
return response
return app
def register_app_cdn(app):
# Date and Time selector
app.extensions['bootstrap']['cdns']['bootstrapdtp'] = WebCDN(
'https://cdnjs.cloudflare.com/ajax/libs/bootstrap-datetimepicker/4.17.47/'
)
# DataTable for displaying information in a grid
app.extensions['bootstrap']['cdns']['dataTable'] = WebCDN(
'https://cdn.datatables.net/1.10.16/')
# Buttons for saving/printing
app.extensions['bootstrap']['cdns']['dataTableBtns'] = WebCDN(
'https://cdn.datatables.net/buttons/1.5.1/')
app.extensions['bootstrap']['cdns']['saveJs'] = WebCDN(
'https://cdnjs.cloudflare.com/ajax/libs/')
app.extensions['bootstrap']['cdns']['multiselect'] = WebCDN(
'https://cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.12.4/')
app.extensions['bootstrap']['cdns']['toastr'] = WebCDN(
'https://cdnjs.cloudflare.com/ajax/libs/toastr.js/')
elif "/var/www/" in os.path.abspath(__file__) or os.environ.get(
'FLASK_ENV') == "production":
app.config.from_object('configuration.ProductionConfig')
else:
app.config.from_object('configuration.DevelopmentConfig')
ext = Sitemap(app=app)
#app.config['SESSION_TYPE'] = 'filesystem'
#app.config['SHELVE_FILENAME'] = 'shelve.db'
#app.config['SHELVE_LOCKFILE'] = 'shelve.db.lock'
#app.config['SESSION_TYPE'] = 'null'
#app.config['SESSION_PERMANENT'] = 'False'
Bootstrap(app)
#app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
#app.config['MAX_CONTENT_LENGTH'] = 32 * 4096 #12/19/2018
app.extensions['bootstrap']['cdns']['slate'] = WebCDN(
"https://cdnjs.cloudflare.com/ajax/libs/bootswatch/3.3.7/slate/")
app.extensions['bootstrap']['cdns']['cyborg'] = WebCDN(
"https://stackpath.bootstrapcdn.com/bootswatch/3.3.7/cyborg/")
nav.init_app(app)
flask_shelve.init_app(app)
_samples = []
# Views and other stuff
def allowed_file(filename):
"""
Make sure filetype has allowed extension.
* docx: most reliable
* odt: through textract (spaces between words disappear, as do
# Initialize the app
app = Flask(__name__)
app.config.from_object(Config)
Bootstrap(app)
login = LoginManager(app)
protocol = ('https', 'http')[app.config.get('DEBUG') == 'True']
# Initialize the db connection
conn_string = app.config.get('DB_URI')
movr = MovR(conn_string)
region = app.config.get('REGION')
cities = app.config.get('CITY_MAP')[region]
# Update Bootstrap from v3.3.7 to v4.5
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN(
'//getbootstrap.com/docs/4.5/dist/')
# Define user_loader function for LoginManager
@login.user_loader
def load_user(user_id):
return movr.get_user(user_id=user_id)
# ROUTES
# Index
@app.route('/', methods=['GET'])
def index():
session['region'] = region
def create_app(config_name):
"""
Creates an instance of the Backend App
Args:
config_name: is the configuration for the type of Backend the
user wants to run
Returns:
Backend, which starts up the app
"""
app = Flask(__name__)
# WARNING It is a security issue to use this middleware in a non-proxy
# setup that enforces using https as it will blindly trust the incoming
# headers which could be forged by a malicious client. See also the
# following: http://flask.pocoo.org/docs/1.0/deploying/wsgi-standalone/
app.wsgi_app = ProxyFix(app.wsgi_app)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
config[config_name].init_app(app)
login_manager.init_app(app)
bootstrap.init_app(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//ajax.googleapis.com/ajax/libs/jquery/3.2.1/')
mail.init_app(app)
db.init_app(app)
cache.init_app(app)
celery.conf.update(app.config)
# Clear cache at startup, Redis defaults to clear the whole DB if that
# happens. NOTE: I am doing this to create a consistent startup
# state, however, any replicas if they spun back up would clear the
# cache after initializing, so we may want to do this elsewhere.
with app.app_context():
try:
cache.clear()
except redis.ConnectionError as e:
print(e)
sys.exit(-1)
# Backend Warning/Error Logger
if not app.config['TESTING']:
error_file_handler = RotatingFileHandler(
filename=app.config['ERROR_LOGGING_LOCATION'],
maxBytes=app.config['ERROR_LOGGING_MAX_BYTES'],
backupCount=['ERROR_LOGGING_BACKUP_COUNT'])
formatter = logging.Formatter(app.config['LOGGING_FORMAT'])
error_file_handler.setFormatter(formatter)
app.logger.setLevel(app.config['ERROR_LOGGING_LEVEL'])
app.logger.addHandler(error_file_handler)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .api_0_1 import api_0_1 as api_0_1_blueprint
app.register_blueprint(api_0_1_blueprint, url_prefix='/api/v0.1')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
return app
from flask import Flask
from pathfinder.pfsweb.config import Config
from flask_bootstrap import Bootstrap, WebCDN
import os
# Create web app
template_dir = os.path.abspath('./pfsweb/templates')
print(template_dir)
app = Flask(__name__, template_folder=template_dir)
Bootstrap(app)
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN(
'//stackpath.bootstrapcdn.com/bootstrap/4.4.1/')
app.extensions['bootstrap']['cdns']['fontawesome'] = WebCDN(
'//stackpath.bootstrapcdn.com/font-awesome/4.4.0/')
# Configure from our configuration object
app.config.from_object(Config)
# Load routes
def main():
"""Run from the 'pfs_web' command"""
app.run()
from flask import Flask, g
from flask_bootstrap import Bootstrap, WebCDN
import sqlite3
D3_VERSION = "4.7.1"
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config')
app.config.from_pyfile('config.py')
Bootstrap(app)
app.extensions['bootstrap']['cdns']['d3'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/d3/{}/'.format(D3_VERSION))
from . import database
from . import views
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
# Set the app version in the config (we use it in templates)
app.config["APP_VERSION"] = __version__
# Initialize all extensions
db.init_app(app)
migrate.init_app(app, db)
login.init_app(app)
mail.init_app(app)
bootstrap.init_app(app)
# Register CDNs
app.extensions["bootstrap"]["cdns"]["bootstrap"] = WebCDN(
"/static/resources/bootstrap/")
app.extensions["bootstrap"]["cdns"]["jquery"] = WebCDN(
"/static/resources/jquery/")
app.extensions["bootstrap"]["cdns"]["datatables"] = WebCDN(
"/static/resources/datatables/")
app.extensions["bootstrap"]["cdns"]["d3"] = WebCDN("/static/resources/d3/")
# Initialize the instance directory and necessary subdirectories
os.makedirs(app.instance_path, exist_ok=True)
os.makedirs(os.path.join(app.instance_path, app.config["TEMP_DIR"]),
exist_ok=True)
os.makedirs(
os.path.join(app.instance_path, app.config["DATASET_DIR"]),
exist_ok=True,
)
# Register all the blueprints
from app.errors import bp as errors_bp
app.register_blueprint(errors_bp)
from app.auth import bp as auth_bp
app.register_blueprint(auth_bp, url_prefix="/auth")
from app.main import bp as main_bp
app.register_blueprint(main_bp)
from app.admin import bp as admin_bp
app.register_blueprint(admin_bp)
# Register the auto_logout function
from app.auth.routes import auto_logout
app.before_request(auto_logout)
if not app.debug:
if app.config["MAIL_SERVER"]:
auth = None
if app.config["MAIL_USERNAME"] or app.config["MAIL_PASSWORD"]:
auth = (
app.config["MAIL_USERNAME"],
app.config["MAIL_PASSWORD"],
)
secure = None
if app.config["MAIL_USE_TLS"]:
secure = ()
mail_handler = SMTPHandler(
mailhost=(app.config["MAIL_SERVER"], app.config["MAIL_PORT"]),
fromaddr="no-reply@" + app.config["MAIL_SERVER"],
toaddrs=app.config["ADMINS"],
subject="AnnotateChange Failure",
credentials=auth,
secure=secure,
)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
if not os.path.exists("logs"):
os.mkdir("logs")
file_handler = RotatingFileHandler("logs/annotatechange.log",
maxBytes=10240,
backupCount=10)
file_handler.setFormatter(
logging.Formatter(
"%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]"
))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info("AnnotateChange startup")
return app
from flask import Flask, jsonify, render_template, request
from flask_bootstrap import Bootstrap, WebCDN
from fetch.fetch import fetch
from flask.ext.sqlalchemy import SQLAlchemy
from sqlalchemy.dialects.postgresql import ARRAY
from flask import request
from fetch.query import addQuery
import psycopg2
DATABASE_URL = "postgres:*************"
app = Flask(__name__)
Bootstrap(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/')
#app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
app.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_URL
db = SQLAlchemy(app)
class AddStruct(db.Model):
__tablename__ = 'addstruct'
date = db.Column(db.Integer, primary_key=True)
year = db.Column(db.Integer)
month = db.Column(db.Integer)
day = db.Column(db.Integer)
link_v4 = db.Column(db.String(80), unique=True)
file_v4 = db.Column(db.String(80), unique=True)
def create_app(test_config=None):
"""
Params::
test_config: (mapping) Used to configure the app.
Returns::
App: Created Flask App
"""
# Create and configure the app
app = Flask(__name__)
# Enable white-space trimming (USELESS WITH MINIFY)
# app.jinja_env.trim_blocks = True
# app.jinja_env.lstrip_blocks = True
if test_config is None:
# Load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py')
else:
# Laod the test config if passed in
app.config.from_mapping(test_config)
# Admin
admin.init_app(app)
# Obscure
obscure.init_app(app)
# For CSRF Protection
csrf = CSRFProtect(app)
# Minify HTML, JS, CSS
mini = minify(app, caching_limit=0)
# For Header Security
talisman = Talisman(
app,
content_security_policy=csp,
content_security_policy_nonce_in=['script-src'],
)
# Bootstrap Wrapper
bootstrap = Bootstrap(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.1/')
# Initialize Database from database.py where models are created
db.init_app(app)
# Migration
migrate = Migrate(app, db, compare_type=True)
# Initialize flask-nav
nav.init_app(app)
register_renderer(app, 'custom', CustomRenderer)
# Set-up login_manager
auth.login_manager.init_app(app)
auth.login_manager.login_view = 'auth/login'
# Ensure the instance folder exists
try:
os.makedirs(app.instance_path)
print("Creating the instance path")
except OSError:
print("Instance path is already created. Using the existing directory")
# Register Blueprints
app.register_blueprint(auth.bp)
app.register_blueprint(posts.bp)
app.register_blueprint(user.bp)
# TODO: Turn this to a infinite scroll using API calls with JSON returns
@app.route('/', methods=['GET', 'POST'])
def index():
if not current_user.is_authenticated and current_user.is_anonymous:
return render_template('welcome.html')
post_list = posts.Post.query.order_by(posts.Post.created.desc()).all()
return render_template('base.html', posts=post_list)
@app.route('/follow_feed', methods=['GET', 'POST'])
@login_required
def follow_feed():
followed_posts = current_user.followed_posts()
return render_template('base.html', posts=followed_posts)
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404
app.add_url_rule('/index', '/')
return app
#!/usr/bin/env python3
from flask import Flask
from flask import render_template
from flask import request
from flask import redirect
from flask_bootstrap import Bootstrap
from flask_bootstrap import WebCDN
from wtforms import Form, TextField, validators
from random import randint
import csv
import re
app = Flask(__name__)
bootstrap = Bootstrap(app)
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN('//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.1.1/')
class ReusableForm(Form):
name = TextField('Name:', validators=[validators.required()])
@app.route('/', methods=['GET', 'POST'])
def index():
form = ReusableForm(request.form)
monsters = []
index=0
rands= [randint(0,443) for i in range(0,5)]
with open('mameg.csv', newline='') as csvfile:
spamreader = csv.reader(csvfile, delimiter=';', quotechar='|')
next(spamreader, None)
def create_app():
"""
Create instance of application
:return: Instance of application
"""
app = Flask(__name__)
app.config.from_object(
environ.get('WORDS_CONFIG', 'config.DevelopmentConfig'))
db.init_app(app)
tasks.init_app(app)
csrf.init_app(app)
bootstrap.init_app(app)
app.extensions['bootstrap']['cdns'].update({
'simplemde-css':
WebCDN('//cdn.jsdelivr.net/simplemde/latest/'),
'simplemde-js':
WebCDN('//cdn.jsdelivr.net/simplemde/latest/'),
'infinite-scroll':
WebCDN('//unpkg.com/infinite-scroll@3/dist/'),
})
app_bcrypt.init_app(app)
moment.init_app(app)
admin.init_app(app)
app.register_blueprint(user.bp)
app.register_blueprint(edit.bp)
app.register_blueprint(post.bp)
app.add_url_rule('/',
'index',
post.global_posts,
methods=('GET', ),
defaults={'page': 1})
app.add_url_rule('/<int:page>',
'index',
post.global_posts,
methods=('GET', ))
app.add_url_rule('/user/{}'.format(app.config['BRAND']),
'user_brand',
lambda: redirect(url_for('index'), 301),
methods=('GET', ))
app.add_url_rule('/feed',
'index_feed',
post.global_feed,
methods=('GET', ))
app.add_url_rule('/user/{}/feed'.format(app.config['BRAND']),
'user_brand_feed',
lambda: redirect(url_for('index_feed'), 301),
methods=('GET', ))
app.add_url_rule('/sitemap.xml',
'index_sitemap',
post.global_sitemap,
methods=('GET', ))
app.register_error_handler(Exception, error.page_500)
app.register_error_handler(500, error.page_500)
app.register_error_handler(CSRFError, error.page_400)
app.register_error_handler(400, error.page_400)
app.register_error_handler(404, error.page_404)
@app.before_request
def app_before_request():
user.load_user()
@app.context_processor
def app_context_processor():
return {'UserStatus': UserStatus}
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True
return app
from flask_bootstrap import WebCDN
basedir = os.path.abspath(os.path.dirname(__file__))
neo4j_user = os.environ.get('NEO4J_USER') or 'neo4j'
neo4j_pass = os.environ.get('NEO4J_PASS') or 'neo4j'
authenticate("localhost:7474", neo4j_user, neo4j_pass)
graph = Graph()
cypher = graph.cypher
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hard to guess string'
manager = Manager(app)
bootstrap = Bootstrap(app)
moment = Moment(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.1/')
class NameForm(Form):
name1 = StringField('First page (e.g. Hidden Markov model)?',
validators=[Required()])
name2 = StringField('Second page (e.g. Support vector machine)?',
validators=[])
submit = SubmitField('Submit')
@app.route('/autocomplete', methods=['GET'])
def autocomplete():
search = request.args.get('query')
search = re.sub(' +', '_', search)
match = cypher.execute(
from flask import Flask, url_for
from flask_bootstrap import Bootstrap, WebCDN
from flask_login import LoginManager
from flask_migrate import Migrate
from flask_socketio import SocketIO
from flask_sqlalchemy import SQLAlchemy
from config import Config
app = Flask(__name__)
app.config.from_object(Config)
bootstrap = Bootstrap(app)
app.extensions["bootstrap"]["cdns"]["jquery"] = WebCDN(
"https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/")
db = SQLAlchemy(app)
migrate = Migrate(app, db)
login = LoginManager(app)
login.login_view = "login"
socketio = SocketIO(app)
@app.template_filter()
def url_for_card_name(card_name):
crd = "".join(x for x in card_name if x.isalnum())
return url_for("static", filename="card_images/" + crd + ".jpg")
from app import routes, models
if __name__ == "__main__":
socketio.run(app)
def init_app(app):
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdn.bootcss.com/jquery/1.11.3/')
app.extensions['bootstrap']['cdns']['bootstrap'] = WebCDN(
'//cdn.bootcss.com/bootstrap/3.3.5/')
app.config['MONGO_AUTO_START_REQUEST'] = False
def create_webcdn(rep_name, version):
return WebCDN('//{cdn_prefix}/{rep_name}/{version}/'.format(
cdn_prefix=CDN_PREFIX, rep_name=rep_name, version=version))
