def init(): L.l.debug('WebUI module initialising') # thread_pool.add_callable(webui.thread_run, run_interval_second=60) from crud import admin, user crud.init_crud() app.register_blueprint(admin, url_prefix='/admin') app.register_blueprint(user, url_prefix='/user') global initialised, flask_thread if BIND_IP is not None and BIND_PORT is not None: host = BIND_IP port = BIND_PORT else: # otherwise listen on all interfaces host = '0.0.0.0' port = int(model_helper.get_param(Constant.P_FLASK_WEB_PORT)) app.wsgi_app = ReverseProxied(app.wsgi_app) app.config['STATIC_FOLDER'] = os.path.join(os.path.dirname(__file__), 'static') flask_thread = helpers.FlaskInThread(app, host=host, port=port, debug=True, use_reloader=False) initialised = True flask_thread.start()
def setUp(self): self.ingestion_globals = IngestionGlobals() self.ingestion_globals.data_dir = os.getcwd() + '/' mongo_server_ip, mongo_port = mongo_host_port() magen_mongo = "{ip}:{port}".format(ip=mongo_server_ip, port=mongo_port) magen_db = MainDb.get_instance() magen_db.core_database = MongoCore.get_instance() magen_db.core_database.utils_strategy = MongoUtils.get_instance() magen_db.core_database.asset_strategy = MongoAsset.get_instance() magen_db.core_database.db_ip_port = magen_mongo magen_db.core_database.utils_strategy.check_db(magen_mongo) magen_db.core_database.initialize() app.config['TESTING'] = True app.register_blueprint(main_bp) app.register_blueprint(users_bp) app.register_blueprint(ingestion_file_upload_bp, url_prefix='/magen/ingestion/v2') app.register_blueprint(ingestion_bp, url_prefix='/magen/ingestion/v1') self.test_app = app.test_client() success, _ = AssetDbApi.delete_all() self.assertTrue(success) with db.connect(config.TEST_DB_NAME) as db_instance: db_instance.drop_collection(config.USER_COLLECTION_NAME) config.DEV_DB_NAME = config.TEST_DB_NAME
def register(self): # import the app context, is done locally so that an importerror is not raised from main import app # register all the required functional blueprints pointing to the controllers # TODO: find some way to do this dynamically app.register_blueprint(page_controller, url_prefix="/") app.register_blueprint(rate_controller, url_prefix='/rate') app.register_blueprint(translate_controller, url_prefix='/translate') app.register_blueprint(insight_controller, url_prefix='/insight')
from controllers.helpers import admin_required @app.before_request def load_user(): if current_user.is_authenticated(): g.user = current_user else: g.user = None from admin import admin import security from users import users app.register_blueprint(users) from courses import courses app.register_blueprint(courses) from lti import lti_assignments app.register_blueprint(lti_assignments) from services import services app.register_blueprint(services) from blockpy import blockpy app.register_blueprint(blockpy) @app.route('/', methods=['GET', 'POST']) def index():
@app.before_request def load_user(): if current_user.is_authenticated: g.user = current_user if 'lti_course' in session: g.course = Course.by_id(session['lti_course']) else: g.user = None from controllers.admin import admin import controllers.security from controllers.users import users app.register_blueprint(users) from controllers.courses import courses app.register_blueprint(courses) from controllers.assignments import blueprint_assignments app.register_blueprint(blueprint_assignments) from controllers.assignment_groups import blueprint_assignment_group app.register_blueprint(blueprint_assignment_group) from controllers.homework import blueprint_homework app.register_blueprint(blueprint_homework) ''' from lti import lti_assignments app.register_blueprint(lti_assignments)
@app.before_request def load_user(): if current_user.is_authenticated(): g.user = current_user if 'lti_course' in session: g.course = Course.by_id(session['lti_course']) else: g.user = None from admin import admin import security from users import users app.register_blueprint(users) from courses import courses app.register_blueprint(courses) from assignments import blueprint_assignments app.register_blueprint(blueprint_assignments) from assignment_groups import blueprint_assignment_group app.register_blueprint(blueprint_assignment_group) ''' from lti import lti_assignments app.register_blueprint(lti_assignments) '''
from main import app import sys import logging import traceback from flask import jsonify import logging from view.demo_view import demo_view logger = logging.getLogger(__name__) app.register_blueprint(demo_view, url_prefix='/demo') @app.errorhandler(Exception) def handle_errors(ex): tb = traceback.format_exc() logger.error(tb) resp = { 'status': 1, 'msg': 'Something went wrong, please contact the system administrator.' } return jsonify(resp) if __name__ == '__main__': app.run(host='127.0.0.1', port=5608, debug=False)
""" URL routing & initialization for webapp """ from os.path import join from main import app from flask import send_from_directory, Blueprint, send_file import os print "Starting webapp!" # user sub-app from user.views import user app.register_blueprint(user, url_prefix='/user') # splash from splash.views import splash app.register_blueprint(splash) # editor from editor.views import editor app.register_blueprint(editor, url_prefix='/editor') # modules manage their own static files. This serves them all up. @app.route("/<blueprint_name>/static/<path:fn>") def _return_static(blueprint_name, fn='index.html'): path = join(*app.blueprints[blueprint_name].import_name.split('.')[:-1]) return send_file('%s/static/%s' % (path, fn)) port = os.getenv('VCAP_APP_PORT', '5000')
return render_template('video.html', ids=ids, types=types) @index_page.route('/work') def work(): imgs0 = os.listdir(os.path.join(app.root_path, 'static/img/portfolio/0')) imgs1 = os.listdir(os.path.join(app.root_path, 'static/img/portfolio/1')) imgs2 = os.listdir(os.path.join(app.root_path, 'static/img/portfolio/2')) imgs3 = os.listdir(os.path.join(app.root_path, 'static/img/portfolio/3')) return render_template('work.html', imgs=[imgs0, imgs1, imgs2, imgs3], enumerate=enumerate) @index_page.route('/subscribe/1') def subscribe1(): cur = db.connection.cursor() cur.execute("""select type,description from product_type;""") info = cur.fetchall() try: return render_template('subscribe/subscribe1.html', info=info) except TemplateNotFound: abort(404) @index_page.route('/subscribe/2') def subscribe2(): if not session.get('subscribe_type', None): return redirect('/subscribe/1') try: return render_template('subscribe/subscribe2.html') except TemplateNotFound: abort(404) app.register_blueprint(index_page)
import os from flask import Blueprint, render_template, abort, session, redirect from jinja2 import TemplateNotFound from main import app admin_page = Blueprint('admin_page', __name__, template_folder='templates', ) @admin_page.route('/admin', defaults={'page': 'index'}) @admin_page.route('/admin/<string:page>') def admin(page): try: return render_template('admin_%s.html' % page) except TemplateNotFound: abort(404) app.register_blueprint(admin_page)
#!/usr/bin/python3 # -*- coding: utf-8 -*- from main import app from auth import UserLogin from resources import Resources # 注册登录 login 蓝图 app.register_blueprint(UserLogin, url_prefix='/auth') # 注册 Restful API 蓝图 app.register_blueprint(Resources, url_prefix='/api') # 注册前端主页路由 @app.route('/') @app.route('/index') def index(): return app.send_static_file('index.html') # # 默认的错误页面请求处理 # @app.errorhandler(404) # def page_not_found(e): # return render_template('404.html'), 404 # @app.errorhandler(500) # def internal_server_error(e): # return render_template('500.html'), 500
""" URL routing & initialization for webapp """ from os.path import join from main import app from flask import send_from_directory, Blueprint, send_file import os print "Starting webapp!" # splash from splash.views import splash app.register_blueprint(splash) # modules manage their own static files. This serves them all up. @app.route("/<blueprint_name>/static/<path:fn>") def _return_static(blueprint_name, fn='index.html'): path = join(*app.blueprints[blueprint_name].import_name.split('.')[:-1]) return send_file('%s/static/%s' % (path, fn)) port = os.getenv('VCAP_APP_PORT', '5000') if __name__ == '__main__': app.run(host='0.0.0.0', port=int(port))
# admin from main import app from .routes import admin_bp app.register_blueprint(admin_bp)
@app.before_request def load_user(): if current_user.is_authenticated(): g.user = current_user else: g.user = None from admin import admin import security from users import users app.register_blueprint(users) from courses import courses app.register_blueprint(courses) from lti import lti_assignments app.register_blueprint(lti_assignments) from services import services app.register_blueprint(services) from blockpy import blockpy app.register_blueprint(blockpy) @app.route('/', methods=['GET', 'POST'])
from main import app from manager.json_response import response import jinja2, os my_loader = jinja2.ChoiceLoader( [app.jinja_loader, jinja2.FileSystemLoader(['modules'])]) app.jinja_loader = my_loader from .articles.router import articles app.register_blueprint(articles) @app.route('/') def index(): return "welcome to Meeber py V1.0, response from %s \n" % (os.getpid()) @app.errorhandler(405) def r405(e): return response(code=405, message=str(e)) @app.errorhandler(404) def r404(e): return response(code=404, message=str(e))
logger.info("API login failed for user {}".format(username)) return "{\"error\": \"error\"}", {"content-type": "text/json"} if Config.GOOGLE_OAUTH: google_blueprint = make_google_blueprint( scope=[ "https://www.googleapis.com/auth/userinfo.email", "openid" ], client_id=Config.GOOGLE_OAUTH_CLIENT_ID, client_secret=Config.GOOGLE_OAUTH_CLIENT_SECRET, redirect_url="https://" + Config.SERVER_NAME + "/" ) google_blueprint.backend = SQLAlchemyStorage(AuthLinks, db.session, user=current_user) app.register_blueprint(google_blueprint, url_prefix="/google") @oauth_authorized.connect_via(google_blueprint) def google_oauth_handler(blueprint, token): """ Passes the oauth event to the oauth handler """ return oauth_handler(blueprint, token) @login_page.route("/googleregister") def google_signup(): """ Sets the required session variable to enable signup when logging in """
""" URL routing & initialization for webapp """ from os.path import join from main import app from flask import send_from_directory, Blueprint, send_file print "Starting webapp!" from user.views import user app.register_blueprint(user, url_prefix='/user') from party.views import party app.register_blueprint(party, url_prefix='/party') # splash from splash.views import splash app.register_blueprint(splash) # modules manage their own static files. This serves them all up. @app.route("/<blueprint_name>/static/<path:fn>") def _return_static(blueprint_name, fn='index.html'): path = join(*app.blueprints[blueprint_name].import_name.split('.')[:-1]) return send_file('%s/static/%s' % (path, fn)) if __name__ == '__main__': app.run(debug=True)
""" URL routing & initialization for webapp """ from os.path import join from main import app from flask import send_from_directory, Blueprint, send_file print "Starting webapp!" # splash from splash.views import splash app.register_blueprint(splash) from live.views import live app.register_blueprint(live, url_prefix='/live') # modules manage their own static files. This serves them all up. @app.route("/<blueprint_name>/static/<path:fn>") def _return_static(blueprint_name, fn='index.html'): path = join(*app.blueprints[blueprint_name].import_name.split('.')[:-1]) return send_file('%s/static/%s' % (path, fn)) if __name__ == '__main__': app.run(debug=True)
#!/usr/bin/env python # -*- coding:utf-8 -*- from control.views.loginBlue import login_blue from control.views.hostBlue import hostInfo_blue from control.views.sshBlue import ssh_blue from control.views.fileBlue import file_blue from control.views.agentBlue import agent_blue from control.views.lightBlue import light_blue from control.views import errorPage from main import app app.register_blueprint(login_blue, ull_prefix='/') app.register_blueprint(hostInfo_blue, ull_prefix='/host') app.register_blueprint(ssh_blue, ull_prefix='/ssh') app.register_blueprint(file_blue, ull_prefix='/file') app.register_blueprint(agent_blue, ull_prefix='/agent') app.register_blueprint(light_blue, ull_prefix='/light')
""" URL routing & initialization for webapp """ from os.path import join from main import app from flask import send_from_directory, Blueprint, send_file print "Starting webapp!" # floorplan sub-app from floorplan.views import floorplan app.register_blueprint(floorplan, url_prefix='/floorplan') # user sub-app from user.views import user app.register_blueprint(user, url_prefix='/user') # beacon sub-app from beacon.views import beacon app.register_blueprint(beacon, url_prefix='/beacon') # company sub-app from company.views import company app.register_blueprint(company, url_prefix='/company') # advertisements sub-app from advertisement.views import advertisement app.register_blueprint(advertisement, url_prefix='/advertisement')
app.config['JWT_SECRET_KEY'] = config.app['at_string'] app.config['JWT_ACCESS_TOKEN_EXPIRES'] = config.app['jwt_life_span'] app.config['JWT_HEADER_NAME'] = jwt_service.JWT_HEADER_NAME app.config['JWT_HEADER_TYPE'] = jwt_service.JWT_HEADER_TYPE jwt = JWTManager(app) # Register served static pages @app.route(paint_socket.namespace) def paint_socket_route(): return render_template('paint-socket.html', namespace=paint_socket.namespace) # Register App Blueprints app.register_blueprint(user_bp, url_prefix='/api/user') # Configure general error handler @app.errorhandler(Exception) def handle_error(e): err_code = 500 if isinstance(e, HTTPException): err_code = e.code return make_response(jsonify({'success': False, 'msg': str(e)}), err_code) # Configure 404 handler @app.errorhandler(404) def not_found(error): return make_response('Sorry, not found.', 404)
from models.models import User from flask import session, g @app.before_request def load_user(): if "user_email" in session and session["user_email"]: user = User.query.filter_by(email=session["user_email"]).first() else: user = None g.user = user from frontend import frontend app.register_blueprint(frontend) from users import users app.register_blueprint(users) from instructor import instructor app.register_blueprint(instructor) from ajax import ajax app.register_blueprint(ajax) from assignments import assignments app.register_blueprint(assignments) from flask import redirect, url_for
from flask import Flask, request, render_template, url_for, flash, session, redirect, jsonify, send_file, make_response import sys, datetime, os, threading from forms import LoginForm, RegisterForm, ModifyForm from werkzeug.security import generate_password_hash, check_password_hash import base64, shutil from flask_mail import Mail, Message #import blueprints from user.routes import user #import db configuration, mail configuration from main import db, dept, app, mail from file_utils import create_pdf, save_img app.register_blueprint(user) def send_mail(message_text, to_mail): message = Message(subject="Update on files", sender=mail_settings.get('MAIL_USERNAME'), recipients=[to_mail], body=message_text) mail.send(message) @app.route('/login', methods=['GET', 'POST']) def login(): form = LoginForm() if request.method == 'POST': if form.validate_on_submit(): with db.cursor() as conn:
from model.admin import AdminInfo from squirrel.view.home_page.home import home_index from squirrel.view.test import test_index from squirrel.view.common_form.login import login_index from squirrel.view.home_page.add_note import add_index from squirrel.view.common_form.errors import error_index from squirrel.view.home_page.modification import mod_index from squirrel.view.label_manager.manage_label import bind_index from squirrel.view.home_page.note_detail import detail_index from squirrel.view.my_plan.plans import plan_index from squirrel.view.admin_manager.admin_page import NewAdminInfo, MyAdminIndexView # 蓝图注册 app.register_blueprint(add_index, url_prefix='/') app.register_blueprint(mod_index, url_prefix='/') app.register_blueprint(home_index, url_prefix='/') app.register_blueprint(test_index, url_prefix='/') app.register_blueprint(bind_index, url_prefix='/') app.register_blueprint(error_index, url_prefix='/') app.register_blueprint(login_index, url_prefix='/login/') app.register_blueprint(detail_index, url_prefix='/detail/') app.register_blueprint(plan_index, url_prefix='/') # 后台管理入口, 重写MyAdminIndexView后台首页 admin = Admin(app, name='后台管理', index_view=MyAdminIndexView(), template_mode='bootstrap3') admin.add_view(NewAdminInfo(AdminInfo, db.session, name='用户管理'))
if not view_model.validate_hash(): flash_error(gettext(u'Link resetowania hasła już wygasł, spróbuj ponownie')) return redirect(url_for('front.reset_password')) form = ResetPasswordConfirmForm(request.form) if form.validate_on_submit(): form.populate_obj(view_model) view_model.reset_password() flash_success(gettext(u'Pomyślnie zmieniłeś swoje hasło')) return redirect(url_for('front.login')) return render_template('auth/reset_password_confirm.html', form=form) @front.route('/contact', methods=['GET', 'POST']) def contact(): form = ContactForm(request.form) if form.validate_on_submit(): model = ContactModel() form.populate_obj(model) model.send() flash_success(gettext(u'Twoja wiadomość została wysłana. Skontaktuję się z Tobą w najbliższym czasie.')) return redirect(url_for('front.contact')) return render_template('pages/contact.html', form=form) @front.route('/<string(minlength=3):path>') def page(path): return render_template('pages/%s.html' % path) app.register_blueprint(front)
from main import app from .base import r_base from .account import r_account from .cart import r_cart from .recipe import r_recipe app.register_blueprint(r_base) app.register_blueprint(r_account) app.register_blueprint(r_cart) app.register_blueprint(r_recipe)
def load_user(): if current_user.is_authenticated: g.user = current_user if 'lti_course' in session: g.course = models.Course.by_id(session['lti_course']) else: g.user = None from controllers.admin import admin import controllers.security from controllers.courses import courses app.register_blueprint(courses) from controllers.assignments import blueprint_assignments app.register_blueprint(blueprint_assignments) from controllers.assignment_groups import blueprint_assignment_group app.register_blueprint(blueprint_assignment_group) from controllers.blockpy import blueprint_blockpy app.register_blueprint(blueprint_blockpy) from controllers.maze import blueprint_maze
@app.before_request def load_user(): if current_user.is_authenticated: g.user = current_user if 'lti_course' in session: g.course = Course.by_id(session['lti_course']) else: g.user = None from controllers.admin import admin import controllers.security from controllers.users import users app.register_blueprint(users) from controllers.courses import courses app.register_blueprint(courses) from controllers.assignments import blueprint_assignments app.register_blueprint(blueprint_assignments) from controllers.assignment_groups import blueprint_assignment_group app.register_blueprint(blueprint_assignment_group) from controllers.blockpy import blueprint_blockpy app.register_blueprint(blueprint_blockpy) from controllers.maze import blueprint_maze app.register_blueprint(blueprint_maze)
#!/usr/bin/env python if __name__ == "__main__": from main import app app.run(debug=True, host="0.0.0.0", port=1337) import os from flask import Flask from osuchan.blueprint import osuchan from osuchan.models import db wd = os.getcwd() app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///%s/test.db" % wd app.config["SQLALCHEMY_ECHO"] = True app.config["SECRET_KEY"] = os.urandom(16) db.init_app(app) app.register_blueprint(osuchan)
""" URL routing & initialization for webapp """ from os.path import join from main import app from flask import send_from_directory, Blueprint, send_file print "Starting webapp!" # splash from splash.views import splash app.register_blueprint(splash) # modules manage their own static files. This serves them all up. @app.route("/<blueprint_name>/static/<path:fn>") def _return_static(blueprint_name, fn='index.html'): path = join(*app.blueprints[blueprint_name].import_name.split('.')[:-1]) return send_file('%s/static/%s' % (path, fn)) if __name__ == '__main__': app.run(debug=True)
response.headers.add( 'Access-Control-Allow-Origin', 'https://ia.jifangcheng.com' if app.config.get('ENV') == 'production' else 'http://localhost:3000') response.headers.add('Access-Control-Allow-Headers', 'Content-Type, Authorization') response.headers.add('Access-Control-Allow-Methods', 'DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT') response.headers.add('Access-Control-Allow-Credentials', 'true') return response app.url_map.strict_slashes = False # url apps = ['blog', 'auth', 'fish'] for _app in apps: try: url = import_module('apps.{}.urls'.format(_app)) except Exception: continue app.register_blueprint(url.bp) # error app.register_error_handler(404, lambda e: utils.common.raise_error(status_code=404)) app.register_error_handler(500, lambda e: utils.common.raise_error(status_code=500)) if __name__ == '__main__': app.run(host=config.HOST, port=config.PORT)
from flask.ext.restful import Api from flask.ext.admin import Admin from main import mainapp from main import app,db from blog import blog from blog.admin import PostView, TagsView, CategoriesView, CommentsView from user import users from user.admin import UserView from service import service from service.restful_service import UserAPI, UsersListAPI, PostAPI, TokenAPI app.register_blueprint(mainapp, url_prefix='') app.register_blueprint(blog, url_prefix='') app.register_blueprint(users, url_prefix='') app.register_blueprint(service, url_prefix='/service') admin = Admin(app) admin.add_view(UserView(db.session)) admin.add_view(PostView(db.session, endpoint="postview")) admin.add_view(TagsView(db.session)) admin.add_view(CategoriesView(db.session)) admin.add_view(CommentsView(db.session)) api = Api(app) api.add_resource(UserAPI, '/api/user/<int:id>', endpoint = 'user') api.add_resource(TokenAPI, '/api/token', endpoint = 'token') api.add_resource(UsersListAPI, '/api/users', endpoint = 'userlists') api.add_resource(PostAPI, '/api/post/<int:id>', endpoint = 'post')
@app.before_request def load_user(): if current_user.is_authenticated(): g.user = current_user if 'lti_course' in session: g.course = Course.by_id(session['lti_course']) else: g.user = None from admin import admin import security from users import users app.register_blueprint(users) from courses import courses app.register_blueprint(courses) from assignments import blueprint_assignments app.register_blueprint(blueprint_assignments) from assignment_groups import blueprint_assignment_group app.register_blueprint(blueprint_assignment_group) ''' from lti import lti_assignments app.register_blueprint(lti_assignments) ''' from services import services