def create_app(**kwargs):
app = Flask(__name__, **kwargs)
app.config.from_pyfile("config.cfg")
# Configure by environment variables
if os.getenv("EED_DB_NAME", None) or os.getenv("EED_DB_HOST", None):
db_name = os.getenv("EED_DB_NAME", "df9egclbrc07pm")
db_host = os.getenv("EED_DB_HOST",
"ec2-54-160-202-3.compute-1.amazonaws.com")
db_user = os.getenv("EED_DB_USER", "ompjvgphfcccsl")
db_pass = os.getenv(
"EED_DB_PASS",
"12aac0929be8a501efc293dda0bb31d3c3263d0a267704ac8a5a852eab637564")
app.config[
"SQLALCHEMY_DATABASE_URI"] = f"postgresql://{db_user}:{db_pass}@{db_host}/{db_name}"
db.init_app(app)
app.register_blueprint(stats_api_bp)
setup_admin(app, db)
@app.route("/ping")
def ping_pong():
return jsonify("pong")
@app.route("/")
def index():
return app.send_static_file("index.html")
return app
def create_app():
#初始化项目实例
app = Flask(__name__,
template_folder=BASE_TEMPLATE_FOLDER,
static_folder=os.path.join(BASE_DIR, 'frontend', 'static'))
app.secret_key = app.config['SECRET_KEY']
#导入配置项
app.config.from_object(config)
# 注册路由
register(app)
# 注册数据库
db.init_app(app) #第二课增加内容
#注册登录组件
login_manager.init_app(app) #第三课增加内容
# 将变量注册到jinja全局变量
app.add_template_global(app.config['PROJECTNAME'], 'PROJECTNAME')
# 钩子 在请求执行之前
@app.before_request
def before_request():
print(current_user.username)
#print('hi')
return app
def create_app():
# 初始化项目实例
app = Flask(__name__,
template_folder=BASE_TEMPLATE_FOLDER,
static_folder=os.path.join(BASE_DIR, 'frontend', 'static'))
app.secret_key = app.config['SECRET_KEY']
# 导入配置项
app.config.from_object(config)
# 注册路由
register(app)
# 注册数据库
db.init_app(app) # 第二课增加内容
# 注册登录组件
login_manager.init_app(app) # 第三课增加内容
# 将变量注册到jinja全局变量
app.add_template_global(app.config['PROJECTNAME'], 'PROJECTNAME')
app.add_template_global(app.config['STATIC_URL'], 'STATIC_URL')
# 钩子 在请求执行之前
@app.before_request
def before_request():
pass
@app.route("/") # 默认主页
def index():
# return "Hello python!"
return render_template("/account/login.html")
@app.route("/index")
def index2():
return render_template("/account/login.html")
return app
def init_db():
app = get_app()
db.init_app(app)
db.create_all()
db.session.commit()
init_database(db)
yield db
db.drop_all()
def create_app(config_filename):
app = Flask(__name__)
app.config.from_object(config_filename)
from backend.app import api_bp
app.register_blueprint(api_bp, url_prefix='/v1')
from backend.models import db
db.init_app(app)
return app
def create_app(database_uri=os.environ.get('DATABASE_URL')):
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = database_uri
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY')
app.config['JWT_EXPIRATION_DELTA'] = datetime.timedelta(hours=50000)
app.config['WEBPACK_MANIFEST_PATH'] = '../build/manifest.json'
jwt = JWT(app, authenticate, identity)
app.jwt = jwt
CORS(app)
SSLify(app)
from backend.models import db
db.init_app(app)
from backend.views.api import api
from backend.views.assets import assets
app.register_blueprint(api)
app.register_blueprint(assets)
@app.errorhandler(voluptuous.error.MultipleInvalid)
def handler_voluptuous_error(multiple_invalid):
# TODO: implement this properly
d = {
str(invalid.path[0] if len(invalid.path) > 0 else 'general'):
[invalid.msg]
for invalid in multiple_invalid.errors
}
response = jsonify({'errors': d})
response.status_code = 400
return response
@app.errorhandler(sqlalchemy.orm.exc.NoResultFound)
def handle_sqlalchemy_no_result_found_error(error):
# TODO: Hmm should something be done here?
response = jsonify({'error': 'No results found'})
response.status_code = 404
return response
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. {{cookiecutter.repo_name}}.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
#initialize CORS
CORS(app, resources={r"/*":{"origins":"*"}})
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
#initialize migration
migrate.init_app(app, db)
#initialize socket
# socketio.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(api)
return app
def create_app(dbname=None):
if not dbname:
dbname = "development.db"
app = Flask(__name__)
# Blue prints
app.register_blueprint(session_manager.bp)
app.register_blueprint(index.bp)
app.register_blueprint(authentication.bp)
app.register_blueprint(community.bp)
# SQL stuff
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///{}".format(
dbname) # Test database for now
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
# Initialize database session
db.init_app(app)
# Fixed endpoint for /
app.add_url_rule("/", endpoint="index")
app.add_url_rule("/community", endpoint="community")
# FIXME: change the secret key!
app.secret_key = "".join(
[choice(ascii_letters + digits) for c in range(128)])
return app
def create_app():
app = Flask(
__name__, static_folder=os.path.join(FRONTEND_FOLDER, 'dist'),
template_folder=FRONTEND_FOLDER
)
app.config.from_pyfile('settings.py')
db.init_app(app)
CSRFProtect(app)
Migrate(app, db)
CORS(app)
lm = LoginManager(app)
@lm.user_loader
def load_user(uid):
return User.query.get(uid)
@app.route('/')
def index():
return render_template('index.html')
app.register_blueprint(todos.bp, url_prefix="/")
app.register_blueprint(auth.bp, url_prefix="/auth")
register_error_handlers(app)
return app
from backend.configuration import data as config
"""
Lê as variáveis de ambiente para pegar a configuração das credenciais.
Esta informação é adicionada ao ambiente pelo script start.sh, que lê
os arquivos de secrets do docker.
"""
db_config = dict(
db_username=os.getenv("POSTGRES_USER"),
db_password=os.getenv("POSTGRES_PASSWORD"),
)
# Atualiza url de conexão com as credenciais de acesso
config["SQLALCHEMY_DATABASE_URI"] = config["SQLALCHEMY_DATABASE_URI"].format(
**db_config)
app = Flask(__name__)
app.config.update(config)
"""
Garante que o modelo de dados será criado antes que qualquer requisição seja processada pela api
"""
@app.before_request
def create_schema():
db.create_all()
db.init_app(app)
api.init_app(app)
def create_app():
# 初始化项目实例
app = Flask(__name__, template_folder=TEMPLATE_FOLDER, static_folder=STATIC_FOLDER)
app.secret_key = app.config['SECRET_KEY']
# 导入配置项
app.config.from_object(config)
app.config.from_object(redis_config)
log.init_app(app)
# 注册路由
urls.register(app)
# 注册数据库
db.init_app(app)
# 注册登录组件
login_manager.init_app(app)
# 注册session组件
session.init_app(app)
# 定时任务
scheduler.init_app(app)
scheduler.start()
# csrf 认证
csrf.init_app(app)
# 注册 swagger
swagger.init_app(app)
# css,js
assets_env.init_app(app)
assets_env.register('main_js', main_js)
assets_env.register('main_css', main_css)
# 将变量注册到jinja全局变量
app.add_template_global(app.config['PROJECTNAME'], 'PROJECTNAME')
app.add_template_global(app.config['STATIC_URL'], 'STATIC_URL')
app.add_template_global(app.config['VERSION'], 'VERSION')
app.BASE_DIR = BASE_DIR
app.LOG_DIR = BASE_DIR + '/logs'
# app.add_template_global(app.config['LOGIN_URL'] + '?cburl=' + app.config['BASE_URL'], 'LOGIN_URL')
# app.add_template_global(app.config['LOGOUT_URL'] + '?cburl=' + app.config['BASE_URL'], 'LOGOUT_URL')
# 钩子 在请求执行之前
@app.before_first_request
def before_first_request():
import time
from backend.models.TaskModel import RemotecmdTaskModel, InterfaceTaskModel
from utils.command import remotecommand, doHttpRequest
logfile = app.LOG_DIR + '/' + time.strftime('%Y%m%d', time.localtime(
time.time())) + '/'
if not os.path.exists(logfile):
os.makedirs(logfile)
tasks_remote = [x for x in RemotecmdTaskModel.query.filter(RemotecmdTaskModel.run_status == 1).all()]
tasks_interface = [x for x in InterfaceTaskModel.query.filter(InterfaceTaskModel.run_status == 1).all()]
if len(tasks_remote) > 0:
for task in tasks_remote:
# 将任务起起来
scheduler.add_job(id=task.task_remotecmd_name,
name=task.task_remotecmd_name,
func=remotecommand,
args=(task.task_remotecmd_host,
task.task_remotecmd_port,
task.task_remotecmd_username,
task.task_remotecmd_password,
task.task_remotecmd_cmd_value,
"{0}{1}_{2}.log".format(logfile, task.task_remotecmd_name, task.id),
),
trigger=task.task_remotecmd_trigger_type,
weeks=int(
task.task_remotecmd_trigger_value) if task.task_remotecmd_trigger_arg == 'weeks' else 0,
days=int(
task.task_remotecmd_trigger_value) if task.task_remotecmd_trigger_arg == 'days' else 0,
hours=int(
task.task_remotecmd_trigger_value) if task.task_remotecmd_trigger_arg == 'hours' else 0,
minutes=int(
task.task_remotecmd_trigger_value) if task.task_remotecmd_trigger_arg == 'minutes' else 0,
seconds=int(
task.task_remotecmd_trigger_value) if task.task_remotecmd_trigger_arg == 'seconds' else 0,
)
if len(tasks_interface) > 0:
for task in tasks_interface:
scheduler.add_job(id=task.task_interface_name,
name=task.task_interface_name,
func=doHttpRequest,
args=(task.task_interface_url,
task.task_interface_params,
0 if task.task_interface_method == 'GET' else 1,
0,
"{0}{1}_{2}.log".format(logfile, task.task_interface_name, task.id),
),
trigger=task.task_interface_trigger_type,
weeks=int(
task.task_interface_trigger_value) if task.task_interface_trigger_arg == 'weeks' else 0,
days=int(
task.task_interface_trigger_value) if task.task_interface_trigger_arg == 'days' else 0,
hours=int(
task.task_interface_trigger_value) if task.task_interface_trigger_arg == 'hours' else 0,
minutes=int(
task.task_interface_trigger_value) if task.task_interface_trigger_arg == 'minutes' else 0,
seconds=int(
task.task_interface_trigger_value) if task.task_interface_trigger_arg == 'seconds' else 0,
)
@app.errorhandler(BaseError)
def custom_error_handler(e):
if e.level in [BaseError.LEVEL_WARN, BaseError.LEVEL_ERROR]:
if isinstance(e, OrmError):
app.logger.exception('%s %s' % (e.parent_error, e))
else:
app.logger.exception('错误信息: %s %s' % (e.extras, e))
response = jsonify(e.to_dict())
response.status_code = e.status_code
return response
return app
def create_app(test_config=None):
# Load .env file (create one if it doesn't exist)
load_dotenv(os.path.join('../', '.env'))
# create and configure the app
app = CustomFlask(__name__,
instance_relative_config=True,
static_folder='../../instance/dist/static',
template_folder='../../instance/dist')
if test_config:
app.config.from_pyfile(
os.path.join(os.path.dirname(__file__), test_config))
else:
db_path = os.path.join(os.path.dirname(__file__), 'app.db')
db_uri = 'sqlite:///{}'.format(db_path)
app.config.from_mapping(
SECRET_KEY=os.getenv('SECRET_KEY'),
SQLALCHEMY_DATABASE_URI=db_uri,
SQLALCHEMY_TRACK_MODIFICATIONS=True,
)
app.register_blueprint(api)
db.init_app(app)
def token_required(f):
@wraps(f)
def _verify(*args, **kwargs):
auth_headers = request.headers.get('Authorization', '').split()
invalid_msg = {
'message':
'Invalid token. Registration and / or authentication required',
'authenticated': False
}
expired_msg = {
'message': 'Expired token. Re-authentication required.',
'authenticated': False
}
if len(auth_headers) != 2:
return jsonify(invalid_msg), 401
try:
token = auth_headers[1]
data = jwt.decode(token, app.config['SECRET_KEY'])
user = User.query.filter_by(email=data['sub']).first()
if not user:
raise RuntimeError('User not found')
return f(user, *args, **kwargs)
except jwt.ExpiredSignatureError:
return jsonify(expired_msg), 401
except (jwt.InvalidTokenError, Exception) as e:
print(e)
return jsonify(invalid_msg), 401
return _verify
@app.route('/')
def index():
return render_template('index.html')
@app.route('/app.js')
def send_app_js():
headers = {"Content-Disposition": "attachment; filename=%s" % 'app.js'}
path = os.path.join(app.instance_path, 'dist', 'app.js')
with open(path, 'r') as f:
body = f.read()
return make_response((body, headers))
return app
def create_app(test_config=None):
app = Flask(__name__, instance_relative_config=True)
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
app.add_template_global(os.environ.get("AVATOR_SERVER"), "avator")
if test_config:
app.config.from_object(test_config)
else:
config = ENV.get(os.environ.get("FLASK_ENV"), DevConfig)
app.config.from_object(config)
try:
os.makedirs(app.instance_path)
except OSError:
pass
app.jinja_env.variable_start_string = "[["
app.jinja_env.variable_end_string = "]]"
from backend.models import db
db.init_app(app)
# init_app(app)
redis_store.init_app(app)
# celery.init_app(app)
# 注册auth redis
# auth_store.init_app(app)
from backend.auth import auth_bp
app.register_blueprint(auth_bp)
from backend.admin import admin_bp
app.register_blueprint(admin_bp)
from backend.manage import manage_bp
app.register_blueprint(manage_bp)
from backend.user import user_bp
app.register_blueprint(user_bp)
# 初始化socketapp
# from backend.socketApp import socketapp
# socketapp.init_app(app)
# from backend.admin import admin_bp
# app.register_blueprint(admin_bp)
# from backend.api import api_bp
# app.register_blueprint(api_bp)
from backend.service import service_bp
app.register_blueprint(service_bp)
from backend.chat import chat_bp
app.register_blueprint(chat_bp)
# from backend.manage import manage_bp
# app.register_blueprint(manage_bp)
from backend.models import User
@app.before_request
def check_login():
user = User.query.filter_by(account=session.get("userId")).first()
if user:
g.user = user
else:
g.user = None
@app.route("/sendemail")
def sendeamil():
if g.user is None:
return jsonify({"code": 500})
SS = ""
email = request.args.get("mail")
if not re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}$',email):
return jsonify({"code": 500})
try:
for i in range(6):
SS += getRandomStr()
mail = SendMail(text=SS, sender="lovehome", receiver="Dear cumtomer", subject="Val", address="{}".format(email))
mail.send()
redis_store.set("email_{}".format(g.user.account), SS)
except Exception as e:
print(e)
return jsonify({"code": 500})
return jsonify({"code": 200})
@app.route("/generatePng")
def generatePng():
SS, pngPath = generateval()
print(SS, pngPath)
return jsonify({"pngPath": pngPath, "avator": os.getenv("AVATOR_SERVER")})
@app.route("/")
def index():
# serviceAddr = request.args.get("serviceAddr")
# serviceType = Info.SERVICETYPE.get(request.args.get("serviceType"))
# SS, pngPath = generateval()
# print(SS, pngPath)
serviceType = None
if serviceType:
services = Info.query.filter(db.and_(Info.serviceType==serviceType, Info.access==True)).all()
else:
services = Info.query.filter_by(access=True).all()
return render_template("index.html", services = services)
@app.route("/404")
def pageNotFound():
data = {"code": 404, "info": "page not found"}
return jsonify(data)
return app
