def create_app(config_mode="dev"):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
if config_mode == "dev":
app.config.from_object(app_config.get("dev"))
elif config_mode == "prod":
app.config.from_object(app_config.get("prod"))
else:
raise Exception("Please Provide dev/prod config")
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
with app.app_context():
from applications.home.views import home
app.register_blueprint(home)
from applications.dash.default import create_dashboard
create_dashboard(app)
from applications.dash.stocktoday import create_stock_app
create_stock_app(app)
return app
async def get(self):
code = self.get_argument('code')
token_payload = {
'client_id': app_config.get('AUTH_ID'),
'client_secret': app_config.get('CLIENT_SECRET'),
'code': code,
'grant_type': 'authorization_code',
'redirect_uri': app_config.get("REDIRECT_URL")
}
_url = "https://{domain}/oauth/token".format(
domain=app_config.get("DOMIAN"))
print(dumps(token_payload))
response = await fetch(_url,
method='POST',
headers={'content-type': 'application/json'},
payload=dumps(token_payload))
if response.code == 200:
body = loads(response.body.decode('utf-8'))
access_token = body['access_token']
user = AuthUser(app_config.get('DOMIAN'), access_token, body)
user_info = await user.get_or_create()
tok = encode(dict(id=user_info.uid, token=user_info.token),
self.settings["jwt_secret"],
algorithm='HS256')
print(tok)
self.set_secure_cookie('_T_GA', tok)
self.redirect('/')
else:
self.redirect('/')
def create_app(env_config=None):
"""Instantiate and return flask app"""
app = Flask(__name__)
# configure app object
app.config.from_object(app_config.get(env_config\
or os.getenv('FLASK_ENV')))
# handle unknown url errors
@app.errorhandler(404)
def url_unknown(e):
return jsonify(
create_message(MSG['url_unknown'], error=True)
), 404
# handle Internal Server Errors
@app.errorhandler(500)
def internal_server_error(e):
return jsonify(
create_message(MSG['internal_server_error'], error=True)
), 500
# handle unauthorized method errors
@app.errorhandler(405)
def method_not_allowed(e):
return jsonify(
create_message(MSG['unsupported_action'], error=True)
), 405
# register movies app
app.register_blueprint(movies)
return app
def _update_text(self):
from markdown2 import Markdown
from html import escape
from bs4 import BeautifulSoup
import re
if self.source is None:
return
if self.source_type == self.SOURCE_TYPE_MARKDOWN:
class Converter(Markdown):
def postprocess(self, text):
return re.compile(r'^<h1>CUT:?\s*(.*)?</h1>', flags=re.M)\
.sub((lambda m: r'<cut title="%s"/>' % escape(m.group(1))), text)
self._text = Converter(extras=['fenced-code-blocks']).convert(
self.source)
elif self.source_type == self.SOURCE_TYPE_PLAINTEXT:
self._text = escape(self.source)
else:
self._text = self.source
cut = BeautifulSoup(self._text,
app_config.get('blog.html_parser')).find('cut')
self.preview = cut and ''.join(
reversed([str(e) for e in cut.previous_siblings]))
self.read_more_label = cut and cut['title'] or None
pass
def create_app(flask_env: FlaskEnv):
"""Create an app for the server to run."""
# create app and Flask-RESTful Api instance
app = Flask(__name__)
# set up config based on flask_env
config = app_config.get(flask_env)
app.config.from_object(config)
# for development server testing without having to rebuild react
if flask_env == FlaskEnv.DEVELOPMENT:
from flask_cors import CORS
CORS(app, resources={r"/api/*": {"origins": "http://*****:*****@app.route("/")
def serve_react():
"""Serve the built react app."""
return send_file("index.html")
@app.route("/robots.txt")
def serve_robots():
return send_file("static/robots.txt")
@app.route("/manifest.json")
def serve_manifest():
return send_file("static/manifest.json")
@app.route("/asset-manifest.txt")
def serve_asset_manifest():
return send_file("static/asset-manifest.txt")
@app.route("/favicon/<icon_file>")
def serve_favicon(icon_file):
return send_file(f"static/favicon/{icon_file}")
# make sure react router urls route back to react, and not to the server
@app.route("/", defaults={"input_path": ""})
@app.route("/<path:input_path>")
def homepage(input_path):
"""Serve the built react app."""
return send_file("index.html")
return app
def create_app(debug=False, config_name='production'):
app = Flask(__name__, instance_relative_config=True)
# Loading config
app.config.from_object(app_config.get(config_name))
app.config.from_pyfile('config.py')
if os.environ.get('FLASK_CONFIG_FILE', False):
app.config.from_envvar('FLASK_CONFIG_FILE')
print(app.config)
return app
def note_feed():
from pyatom import AtomFeed
site_url = '://'.join(request.urlparts[:2])
author = app_config.get('feed.author')
db_session = Session()
notes = db_session.query(Note).order_by(Note.created_at.desc()).limit(10).all()
feed = AtomFeed(title=app_config.get('feed.title'),
subtitle=app_config.get('feed.subtitle'),
feed_url=site_url + app.get_url('note-feed'),
url=site_url + app.get_url('note-list'),
author=author)
for note in notes:
feed.add(title=note.title,
content=strip_cut(note.text),
content_type="html",
author=author,
url=site_url + app.get_url('note-details', note_id=note.id),
updated=note.created_at)
response.add_header('Content-Type', 'application/atom+xml')
return feed.to_string()
def create_app(env):
app = Flask(__name__)
app.config.from_object(app_config.get(env))
from harvestapi.app import api_bp
app.register_blueprint(api_bp, url_prefix='/harvest')
from harvestapi.model import db
db.init_app(app)
return app
def note_feed():
from pyatom import AtomFeed
site_url = '://'.join(request.urlparts[:2])
author = app_config.get('feed.author')
db_session = Session()
notes = db_session.query(Note).order_by(
Note.created_at.desc()).limit(10).all()
feed = AtomFeed(title=app_config.get('feed.title'),
subtitle=app_config.get('feed.subtitle'),
feed_url=site_url + app.get_url('note-feed'),
url=site_url + app.get_url('note-list'),
author=author)
for note in [n for n in notes if not n.is_draft]:
feed.add(title=note.title,
content=strip_cut(note.text),
content_type="html",
author=author,
url=site_url + app.get_url('note-details', note_id=note.id),
updated=note.created_at)
response.add_header('Content-Type', 'application/atom+xml')
return feed.to_string()
def login():
username = post_get('username')
password = post_get('password').encode('utf-8')
if (username and password) is not None:
hashed = app_config.get('app.auth.%s' % username).encode('utf-8')
if bcrypt.hashpw(password, hashed) == hashed:
s = get_session()
s['authenticated'] = True
s['username'] = username
s.save()
bottle.redirect('/')
else:
return template('login.html')
def login():
username = post_get('username')
password = post_get('password').encode('utf-8')
if (username and password) is not None:
hashed = app_config.get('app.auth.%s' % username).encode('utf-8')
if bcrypt.hashpw(password, hashed) == hashed:
s = get_session()
s['authenticated'] = True
s['username'] = username
s.save()
bottle.redirect('/')
else:
return template('login.html')
def _init_test_db():
import alembic.config
import sqlalchemy
from config import app_config
# cleanup db
engine = sqlalchemy.create_engine(app_config.get("db", "url"), echo=False)
results = engine.execute("SHOW TABLES")
for result in results:
table = result[0]
engine.execute(f"DROP TABLE IF EXISTS {table}")
# migrate to head
argv = [
"upgrade",
"head",
]
alembic.config.main(argv=argv)
def _update_text(self):
from markdown2 import Markdown
from html import escape
from bs4 import BeautifulSoup
import re
if self.source is None:
return
if self.source_type == self.SOURCE_TYPE_MARKDOWN:
class Converter(Markdown):
def postprocess(self, text):
return re.compile(r'^<h1>CUT:?\s*(.*)?</h1>', flags=re.M)\
.sub((lambda m: r'<cut title="%s"/>' % escape(m.group(1))), text)
self._text = Converter(extras=['fenced-code-blocks']).convert(self.source)
elif self.source_type == self.SOURCE_TYPE_PLAINTEXT:
self._text = escape(self.source)
else:
self._text = self.source
cut = BeautifulSoup(self._text, app_config.get('blog.html_parser')).find('cut')
self.preview = cut and ''.join(reversed([str(e) for e in cut.previous_siblings]))
self.read_more_label = cut and cut['title'] or None
pass
def create_app(config_name):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(app_config.get(config_name))
app.config.from_pyfile('config.py')
Bootstrap(app)
db.init_app(app)
login_manager.init_app(app)
login_manager.login_message = "You must be logged in to access this page."
login_manager.login_view = "auth.login"
migrate = Migrate(app, db)
from app import models
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .home import home as home_blueprint
app.register_blueprint(home_blueprint)
@app.errorhandler(403)
def forbidden(error):
return render_template('errors/403.html', title='Forbidden'), 403
@app.errorhandler(404)
def page_not_found(error):
return render_template('errors/404.html', title='Page Not Found'), 404
@app.errorhandler(500)
def internal_server_error(error):
return render_template('errors/500.html', title='Server Error'), 500
return app
#!/usr/bin/env python
import webapp2
from config import app_config
from handlers.Error import error_handlers
from routes import route_list
app = webapp2.WSGIApplication(
routes=route_list,
config=app_config,
debug=app_config.get("debug", False),
)
app.error_handlers.update(error_handlers)
def session():
url = app_config.get("db", "url")
engine = sqlalchemy.create_engine(url, echo=False)
Session = sqlalchemy.orm.sessionmaker(bind=engine)
return Session()
import os
import json
import jinja2
import webapp2
import datetime as dt
from models import Admin
from lib import encrypt
from config import app_config as cfg
SUBMISSION_TIMEOUT = cfg.get('submission_timeout', 30)
template_dir = os.path.join(os.path.dirname(__file__), '../templates')
jinja_env = jinja2.Environment(loader = jinja2.FileSystemLoader(template_dir),
autoescape = True)
class BaseHandler(webapp2.RequestHandler):
def write(self, *a, **kw):
self.response.write(*a, **kw)
def render_str(self, template, **params):
t = jinja_env.get_template(template)
return t.render(params, admin=self.admin)
def render(self, template, **kw):
if not template.endswith('.html'):
template = template + '.html'
self.response.write(self.render_str(template, **kw))
import json
from base import BaseHandler
from models import Admin
from lib import qr, ziplib
from config import app_config as cfg
from models import Location, Comfort
from google.appengine.api import memcache
from google.appengine.ext import db
MC_LOCATIONS_KEY = cfg.get('MC_LOCATIONS_KEY', '')
HOSTNAME = cfg.get('hostname', 'localhost')
def get_locations():
locations = memcache.get(MC_LOCATIONS_KEY)
if not locations:
locations = list(Location.all())
memcache.set(MC_LOCATIONS_KEY, locations)
return locations
def login_required(f):
def wrapper(self, *args, **kwargs):
if not self.admin:
self.redirect('/login')
else:
f(self, *args, **kwargs)
return wrapper
# coding=utf-8
import webapp2
import logging
import fix_path
from routes import route_list
from config import app_config
app = webapp2.WSGIApplication(route_list,
config = app_config,
debug = app_config.get('debug', True))
author = app_config.get('feed.author')
db_session = Session()
notes = db_session.query(Note).order_by(
Note.created_at.desc()).limit(10).all()
feed = AtomFeed(title=app_config.get('feed.title'),
subtitle=app_config.get('feed.subtitle'),
feed_url=site_url + app.get_url('note-feed'),
url=site_url + app.get_url('note-list'),
author=author)
for note in [n for n in notes if not n.is_draft]:
feed.add(title=note.title,
content=strip_cut(note.text),
content_type="html",
author=author,
url=site_url + app.get_url('note-details', note_id=note.id),
updated=note.created_at)
response.add_header('Content-Type', 'application/atom+xml')
return feed.to_string()
debug = app_config.get('app.debug', False)
if __name__ == '__main__':
run(middleware,
host='localhost',
port=app_config.get('app.port', 5040),
server=app_config.get('app.server', 'wsgiref'),
debug=debug,
reloader=debug)
else:
application = middleware
def __init__(self):
host = app_config.get("KAFKA_SOCCER_HOST")
# port = Config.KAFKA_SOCCER_PORT
self.set_host(host)
from sqlalchemy import create_engine
from config import app_config
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy import Column, Integer, String, Text, DateTime, Boolean
from sqlalchemy.orm import sessionmaker
from datetime import datetime
from pytz import timezone
tzlocal = timezone(app_config.get('app.timezone', 'UTC'))
Base = declarative_base()
engine = create_engine('sqlite:///%s' %
app_config.get('app.db.path', ':memory:'),
echo=True,
encoding='utf-8')
Session = sessionmaker(bind=engine)
class Note(Base):
__tablename__ = 'notes'
SOURCE_TYPE_MARKDOWN = 1
SOURCE_TYPE_HTML = 2
SOURCE_TYPE_PLAINTEXT = 3
id = Column(Integer, primary_key=True)
source = Column(Text)
_source_type = Column('source_type', Integer)
_text = Column('text', Text)
from args import parser, get_config_module
import hashlib
import hmac
import sys
import requests
import urllib
parser.add_argument("path", metavar="P", type=str, help="Path to query metadata of")
vals = parser.parse_args()
config = get_config_module(vals.config)
path = vals.path
try:
from config import app_config
key = app_config["PUBLISHER_SECRET_KEY"]
root = app_config.get("APPLICATION_ROOT", "")
except ImportError, KeyError:
print "Unable to retrieve secret key for metadata request"
sys.exit(1)
try:
from config import host_config
if "host" in host_config:
host = host_config["host"]
else:
host = "127.0.0.1"
if "port" in host_config:
port = host_config["port"]
else:
port = 8000
import vertx
from config import app_config
vertx.deploy_verticle('WebSocketServer.py',app_config.get('socket.config'),1)
vertx.deploy_verticle('HttpServer.py',app_config.get('http.config'),1)
vertx.deploy_verticle('HttpClient.py',app_config.get('http.client.config'),1)
#!/usr/bin/env python
#
import webapp2
import logging
import fix_path
from routes import route_list
from config import app_config
log = logging.getLogger(__name__)
app = webapp2.WSGIApplication(route_list,
config = app_config,
debug = app_config.get('debug', False))
def production():
env.hosts = [app_config.get('deploy.production.host')]
env.key_filename = app_config.get('deploy.production.key_file')
conf['code_dir'] = app_config.get('deploy.production.target_dir')
def production():
env.hosts = [app_config.get('deploy.production.host')]
env.key_filename = app_config.get('deploy.production.key_file')
conf['code_dir'] = app_config.get('deploy.production.target_dir')
from datetime import datetime, timedelta
from string import capitalize
from config import app_config as cfg
from lib import errors, valid
from base import BaseHandler, BaseComfortHandler
from models import Comfort, Location, Admin
from google.appengine.api import memcache
MC_LOCATIONS_KEY = cfg.get('MC_LOCATIONS_KEY', '')
MC_GRAPH_DATA_KEY = cfg.get('MC_GRAPH_DATA_KEY', '')
MAX_RECORDS = cfg.get('data_api_max_records', 100)
GRAPH_REFRESH = cfg.get('graph_refresh', 5)
GREATER_THAN = 'g'
LESS_THAN = 'l'
FROM = 'from'
TO = 'to'
DELIMITER = '-'
class LocationsAPI(BaseHandler):
def get(self):
"""The API to get the list of locations from the database. The following
parameters can be specified:
building - (optional) the list of locations for the building
floor - (optional) the list of locations for the building and floor
Returns a list of locations in JSON format. An empty list will be returned
if there are no results for the specified parameters."""
locations = memcache.get(MC_LOCATIONS_KEY)
if not locations:
author = app_config.get('feed.author')
db_session = Session()
notes = db_session.query(Note).order_by(Note.created_at.desc()).limit(10).all()
feed = AtomFeed(title=app_config.get('feed.title'),
subtitle=app_config.get('feed.subtitle'),
feed_url=site_url + app.get_url('note-feed'),
url=site_url + app.get_url('note-list'),
author=author)
for note in notes:
feed.add(title=note.title,
content=strip_cut(note.text),
content_type="html",
author=author,
url=site_url + app.get_url('note-details', note_id=note.id),
updated=note.created_at)
response.add_header('Content-Type', 'application/atom+xml')
return feed.to_string()
debug = app_config.get('app.debug', False)
if __name__ == '__main__':
run(middleware,
host='localhost',
port=app_config.get('app.port', 5040),
server=app_config.get('app.server', 'wsgiref'),
debug=debug,
reloader=debug
)
else:
application = middleware
import os
from app import create_app
from flask.ext.script import Manager
from flask.ext.script import Shell
from flask.ext.script import Server
from config import app_config
config_object=app_config.get(os.environ.get('FLASK_CONIFG','default'))
app=create_app(config_object)
manager=Manager(app)
def make_shell():
return dict(app=app)
manager.add_command('shell',Shell(make_context=make_shell))
manager.add_command('runserver',Server(
use_reloader=True,
host='localhost',
port=5000
))
if __name__=='__main__':
manager.run()
def __load_app_log_config(self):
self.log_config = app_config.get("logging")
self.CONF_LOG_LEVEL = self.log_config.get("log_level", None) or 'INFO'
self.LOGGING_MAX_BYTES = 10 * 1024 * 1024
from datetime import datetime, timedelta
from string import capitalize
from config import app_config as cfg
from lib import errors, valid
from base import BaseHandler, BaseComfortHandler
from models import Comfort, Location, Admin
from google.appengine.api import memcache
MC_LOCATIONS_KEY = cfg.get('MC_LOCATIONS_KEY', '')
MC_GRAPH_DATA_KEY = cfg.get('MC_GRAPH_DATA_KEY', '')
MAX_RECORDS = cfg.get('data_api_max_records', 100)
GRAPH_REFRESH = cfg.get('graph_refresh', 5)
GREATER_THAN = 'g'
LESS_THAN = 'l'
FROM = 'from'
TO = 'to'
DELIMITER = '-'
class LocationsAPI(BaseHandler):
def put(self):
"""Add a location to the database"""
building = self.request.get('building')
floor = self.request.get('floor')
location = Location.create() # todo AM
db.put(location)
memcache.delete(MC_LOCATIONS_KEY)
def get(self):
from config import app_config
from routes import route_list
from services.db_helper import DBHelper
import webapp2
db_helper = DBHelper()
app = webapp2.WSGIApplication(route_list, config=app_config, debug=app_config.get("debug", False))
import json
from base import BaseHandler
from models import Admin
from lib import qr, ziplib
from config import app_config as cfg
from models import Location, Comfort
from google.appengine.api import memcache
from google.appengine.ext import db
MC_LOCATIONS_KEY = cfg.get('MC_LOCATIONS_KEY', '')
HOSTNAME = cfg.get('hostname', 'localhost')
def get_locations():
locations = memcache.get(MC_LOCATIONS_KEY)
if not locations:
locations = list(Location.all())
memcache.set(MC_LOCATIONS_KEY, locations)
return locations
def login_required(f):
def wrapper(self, *args, **kwargs):
if not self.admin:
self.redirect('/login')
else:
f(self, *args, **kwargs)
return wrapper
class AdminHandler(BaseHandler):
def get_admin(self):
def init_kafka(self):
res = self.set_host(app_config.get("KAFKA_SOCCER_HOST"))
if res is not None:
logger.info("初始化kafka成功")
else:
logger.info("初始化kafka失败")
from sqlalchemy import create_engine
from config import app_config
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy import Column, Integer, String, Text, DateTime
from sqlalchemy.orm import sessionmaker
from datetime import datetime
from pytz import timezone
tzlocal = timezone(app_config.get('app.timezone', 'UTC'))
Base = declarative_base()
engine = create_engine('sqlite:///%s' % app_config.get('app.db.path', ':memory:'), echo=True, encoding='utf-8')
Session = sessionmaker(bind=engine)
class Note(Base):
__tablename__ = 'notes'
SOURCE_TYPE_MARKDOWN = 1
SOURCE_TYPE_HTML = 2
SOURCE_TYPE_PLAINTEXT = 3
id = Column(Integer, primary_key=True)
source = Column(Text)
_source_type = Column('source_type', Integer)
_text = Column('text', Text)
preview = Column(Text)
read_more_label = Column(String(255))
created_at = Column(DateTime)
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
# Overwrite the alembic.ini sqlalchemy.url
x_db_url = context.get_x_argument(as_dictionary=True).get('x_db_url')
if x_db_url:
# > alembic -x x_db_url=DB_URL upgrade head
config.set_main_option('sqlalchemy.url', x_db_url)
else:
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from config import app_config
config.set_main_option('sqlalchemy.url', app_config.get('db', 'url'))
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
url = config.get_main_option("sqlalchemy.url")
#!/usr/bin/env python
#
import webapp2
import logging
#adjust library path before any other module gets imported...
import fix_path
from routes import route_list
from config import app_config
log = logging.getLogger(__name__)
app = webapp2.WSGIApplication(route_list,
config = app_config,
debug = app_config.get('debug', False))
from pymongo import MongoClient
from datetime import datetime, timedelta
import os
import sys
from config import app_config
from dotenv import load_dotenv
load_dotenv()
app_configuration = app_config.get(os.getenv("FLASK_ENV"))
def connect_mongo(tenant):
client = MongoClient(app_configuration.MONGO_URI)
db = client[f'{app_configuration.DB_NAME}_{tenant.lower()}']
return db
