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
