def init():
"""initialize database and directories"""
try:
remakedir(settings.DATA_DIR_PATH)
remakedir(settings.DEMO_DIR_PATH)
remakedir(settings.THUMBNAIL_DIR_PATH)
except:
print sys.exc_info()
try:
if os.path.exists(settings.DB_PATH):
os.remove(settings.DB_PATH)
init_db()
if getpwuid(os.getuid())[0] == "root":
os.chown(settings.DB_PATH, apache_uid, apache_gid)
except:
print sys.exc_info()
try:
role_admin = UserRole("admin", "for administrators")
db_session.add(role_admin)
user_admin = User("admin", role=role_admin)
db_session.add(user_admin)
db_session.commit()
db_session.remove()
except:
print sys.exc_info()
def main():
init_db()
rebase()
contact = Contact.create(
"John F Kidd",
"0765242421",
"*****@*****.**",
comments="A test comment @ {}".format(time.strftime("%H:%M:%S")))
execute = handle_error(log_error, log_info)
execute(lambda: create_and_read(contact), get_description)
def startmeup():
wsgi_app = WSGIContainer(app)
application = Application([
(r"/s/(.*)", StaticFileHandler, { "path" : basedir + "/app/static" }),
(r"/socket", core.ClientSocket),
(r"/publish", core.Publisher),
(r".*", FallbackHandler, dict(fallback=wsgi_app)),
])
CONN_STR = app.config['SQLALCHEMY_DATABASE_URI']
print("Connection string is ? " + CONN_STR)
db.init_db( CONN_STR )
application.listen(8888)
IOLoop.instance().start()
def conn() -> sqlite3.Connection:
conn = sqlite3.connect(":memory:")
db.init_db(conn)
return conn
async def startup_event():
"""initialize the db on startup"""
log.info("starting up")
init_db(app)
def setUpClass(cls):
os.environ['APP_SETTINGS'] == 'testing' or os.environ.update(APP_SETTINGS='testing')
cls.config_obj = get_env_config()
cls.meta_db = get_db_metadata()
init_db(seed_data=True, rebuild=True)
async def startup_event():
log.info("Starting Up...")
init_db(app)
def db():
init_db()
from app import app, db
if __name__ == "__main__":
db.init_db("schema.sql")
app.run(debug=False)
from app import db
db.init_db()
for _t in db.Base.metadata.tables:
print("Table: ", _t)
async def startup_event():
print('Starting up...')
init_db(app)
import unittest
import json
import tempfile
import time
import app as sensors_app
from app import db
# データベースの準備
tempDB = tempfile.mkstemp()
tempDBPath = tempDB[1]
dburl = "sqlite:///" + tempDBPath
app = sensors_app.create_app(dburl)
db.init_db(app)
with app.app_context():
db.create_all()
class TestUserControl(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
def test_health(self):
rv = self.app.get("/api/")
self.assertIn(b"Sensors", rv.data)
def test_user_isexist(self):
testuser = {"name": "test_user_isexist", "password": "******"}
def run(self):
from app import db
with app.app_context():
db.init_db()
def setup_func():
"""
Initializes the database before each test run.
"""
init_db()
def create_app(environment="development"):
"""
Setup de la aplicacion
"""
app = Flask(__name__)
app.response_class = CookiesLaxResponse
# Compilacion de archivos scss
Scss(app, static_dir='app/static', asset_dir='app/assets/scss')
cors = CORS(app,
resources={r"/api/*": {
"origins": "*"
}},
support_credentials=True)
app.config['CORS_HEADERS'] = 'Content-Type'
# Configuracion de variables de flask
app.config.from_object(config[ENVIRONMENT])
# Inicializacion de la base de datos
init_db()
load_database()
# Global de jinja para obtener los permisos en navbar
from app.helpers.permission import user_permissions
app.jinja_env.globals.update(user_permissions=user_permissions)
from app.helpers.auth import check_login
app.jinja_env.globals.update(check_login=check_login)
# Global de jinja para el path de los archivos publicos
app.jinja_env.globals.update(
UPLOADS_PUBLIC_DIRECTORY=UPLOADS_PUBLIC_DIRECTORY.replace('./app', ''))
# Reglas de ruteo
from app.resources import user
app.register_blueprint(user.bp)
from app.resources import auth
app.register_blueprint(auth.bp)
from app.resources import configuration
app.register_blueprint(configuration.bp)
from app.resources import center
app.register_blueprint(center.bp)
from app.resources.api import center as center_api
app.register_blueprint(center_api.bp)
from app.resources.api import tipo as tipo_api
app.register_blueprint(tipo_api.bp)
from app.resources.api import configuration as configuration_api
app.register_blueprint(configuration_api.bp)
from app.resources.api import statistics as statistics_api
app.register_blueprint(statistics_api.bp)
from app.resources import turn
app.register_blueprint(turn.bp)
# Config de la sesion
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Config del directorio publico de archivos
app.config["UPLOADS_PUBLIC_DIRECTORY"] = UPLOADS_PUBLIC_DIRECTORY
@app.route('/')
def home():
"""
Página inicial del sistema.
"""
from app.models.configuration import Configuration as Config
config = Config.query.filter(Config.name.like('home%')).all()
homeConfig = {}
from app.helpers.auth import desloguear_usuario_inactivo
from app.models.user import User
from flask import session
if check_login():
desloguear_usuario_inactivo(
User.query.filter(
User.username == session["username"]).first())
for element in config:
homeConfig[element.name] = element.value
return (render_template('home.html', homeConfiguration=homeConfig))
@app.teardown_appcontext
def shutdown_session(exception=None):
"""
Codigo para que se puede bajar la base de datos automaticamente
"""
db_session.remove()
return app
def create_db():
init_db()
async def startup_event():
logger.info("Starting up...")
init_db(application)
from flask import (Flask)
from app.db import init_db, get_dynamodb
from app.api.routes import (api as api_blueprint)
def create_app():
app = Flask(__name__)
app.config.from_object('app.config.Config')
app.register_blueprint(api_blueprint)
return app
app = create_app()
dynamodb = get_dynamodb(
app.config.get('AWS_REGION'),
app.config.get('AWS_KEY'),
app.config.get('AWS_SECRET'),
)
init_db(dynamodb, app)
if __name__ == '__main__':
app.run()
import os
from flask import Flask, make_response, jsonify
from flask_cors import CORS
from app import db
mongo = db.init_db()
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping()
CORS(app)
if test_config is None:
app.config.from_pyfile('config.py', silent=True)
else:
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
@app.errorhandler(400)
def not_found(error):
from app import create_app
from app.db import init_db, seed
app = create_app({})
init_db(app)
seed()
from flask import Flask
import config
app = Flask('phobook')
app.config.from_object('config')
# Handling OPTION Method request for cross site
from flask_cors import CORS, cross_origin
cors = CORS(app, resources={r"/*":{"origins":"*"}})
# Identicon generator
from pydenticon import Generator
pydent = Generator(8, 8)
from app.db import init_db, db_session
init_db()
from app.login import *
@app.teardown_appcontext
def shutdown_session(exception):
db_session.remove()
from app.controller import routes
routes(app)
from flask_socketio import SocketIO
socketio = SocketIO(app)
from app.socket import register_socket
def create_app(self):
self.app = Flask(__name__, template_folder='../app/templates')
self.app.config['TESTING'] = True
self.app.config['USERNAME'] = '******'
self.app.config['PASSWORD'] = '******'
self.app.testing = True
self.app.config.from_mapping(
SECRET_KEY='dev',
DATABASE=os.path.join(self.app.instance_path, 'test_app.sqlite'),
)
# ensure the instance folder exists
try:
os.makedirs(self.app.instance_path)
except OSError:
pass
with self.app.app_context():
db.init_app(self.app)
db.init_db()
self.db = db.get_db()
from app.routers import recipes, meals, ingredients, auth
self.app.register_blueprint(auth.bp)
self.app.register_blueprint(ingredients.bp)
self.app.register_blueprint(recipes.bp)
self.app.register_blueprint(meals.bp)
@self.app.route('/')
def index():
""" Displays the index page accessible at '/'
"""
return redirect(url_for('recipes.index'))
# adding ingredients
# liquid ingredient
ing1 = {'id': 1, 'name': "ing_unittest1_liquid", 'name_key': "ing_unittest1_liquid",
'portion_size': 4, 'portion_size_unit': "cup", 'portion_converted': h.convert("cup", 4),
'protein': 5.5, 'fat': 7.1, 'carbs': 20.5, 'calories': 98, 'price': 0 * 100,
'price_size': 0.01, 'price_size_unit': "gal", 'tag': "dairy", 'notes': "no notes"}
# spice ingredient (macros are 0, price is based on units)
ing2 = {'id': 2, 'name': "ing_unittest2_spice", 'name_key': "ing_unittest2_spice",
'portion_size': 2, 'portion_size_unit': "unit", 'portion_converted': h.convert("unit", 2),
'protein': 0, 'fat': 0, 'carbs': 0, 'calories': 0, 'price': 2.99 * 100,
'price_size': 2, 'price_size_unit': "unit", 'tag': "spices", 'notes': "no notes"}
# solid ingredient
ing3 = {'id': 3, 'name': "ing_unittest3_solid", 'name_key': "ing_unittest3_solid",
'portion_size': 355, 'portion_size_unit': "g", 'portion_converted': h.convert("g", 355),
'protein': 21.2, 'fat': 14, 'carbs': 133, 'calories': 257, 'price': 3.79 * 100,
'price_size': .5, 'price_size_unit': "kg", 'tag': "proteins", 'notes': "no notes"}
# flour (cup measures are to be converted to grams, not volume)
ing4 = {'id': 4, 'name': "ing_unittest4_cup", 'name_key': "ing_unittest4_cup",
'portion_size': 4, 'portion_size_unit': "cup", 'portion_converted': h.convert("cup", 4),
'protein': 5.2, 'fat': 23, 'carbs': 23, 'calories': 240, 'price': 3.04 * 100,
'price_size': 5, 'price_size_unit': "lb", 'tag': "carbs", 'notes': "no notes"}
# onion (portion is unit but price is in lbs)
ing5 = {'id': 5, 'name': "ing_unittest5_onion", 'name_key': "ing_unittest5_onion",
'portion_size': 2, 'portion_size_unit': "unit", 'portion_converted': h.convert("unit", 2),
'protein': 2, 'fat': 2, 'carbs': 2, 'calories': 17, 'price': 2.99 * 100,
'price_size': 5, 'price_size_unit': "lb", 'tag': "vegetables", 'notes': "no notes"}
for ing in [ing1, ing2, ing3, ing4, ing5]:
self.db.execute('INSERT INTO ingredient VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
tuple(ing.values()))
# adding recipes
recipe1 = [
{'id': 1, 'author_id': "unittest", 'title': "recipe_unittest1", 'body': "Empty body", 'servings': 3,
'tag': "beans"},
[(ing2, 1, 't'), (ing3, 14, 'oz'), (ing5, 1, 'unit')]]
recipe2 = [
{'id': 2, 'author_id': "unittest", 'title': "recipe_unittest2", 'body': "Empty body", 'servings': 4,
'tag': "dessert"},
[(ing2, 1, 'T'), (ing1, 6, 'oz'), (ing4, 280, 'g')]]
for r, ings in [recipe1, recipe2]:
self.db.execute('INSERT INTO recipe VALUES (?, ?, ?, ?, ?, ?)', tuple(r.values()))
for ing in ings:
self.db.execute('INSERT INTO recipeIngredientRelationship (recipeID, ingredientID, quantity, units) '
'VALUES (?, ?, ?, ?)', (r['id'], ing[0]['id'], ing[1], ing[2]))
# adding meals
meal1 = [{'id': 1, 'author_id': "unittest", 'title': "meal_unittest1", 'tag': "easy", 'notes': "None."},
[recipe1], 4]
meal2 = [{'id': 2, 'author_id': "unittest", 'title': "meal_unittest2", 'tag': "brunch", 'notes': "None."},
[recipe1, recipe2], 3]
for m, recipes, servings in [meal1, meal2]:
self.db.execute('INSERT INTO meal VALUES (?, ?, ?, ?, ?)', tuple(m.values()))
for r in recipes:
self.db.execute('INSERT INTO mealRecipeRelationship (mealID, recipeID, servings) '
'VALUES (?, ?, ?)', (m['id'], r[0]['id'], servings))
self.db.commit()
return self.app
async def startup_event():
"""
startup event definition
"""
log.info("Starting up...")
init_db(app)
controller['rv'] = line[7:11]
larr.append(line)
payload = dict( controllerId = controller['id'], controllerName = controller['name'], fridge = controller['fv'], fridgeSet = cs['fridgeSet'], beer = controller['bv'], beerSet = cs['beerSet'], room = controller['rv'], status = larr[-1])
if cs['mode'] == 'p':
payload.update( dict(profile = cs['profile']))
return dict( channel = "data", payload = payload )
def scan(self):
for controller in self.controllers:
lcd = self.getData(controller, "lcd")
cs = self.getData(controller, "getControlSettings")
msg = self.createDataMessage(controller, lcd, cs)
self.postMessage("data", msg)
# init db connection - this may create it if not there ?!?
db.init_db( SQLALCHEMY_DATABASE_URI )
# create the maelstrom -> brewpi bridge
bridge = BrewPiBridge( db.DBSession().query(db.IOController).all() )
while True:
bridge.scan()
time.sleep(5)
def setUp(self):
if not self.client:
self.skipTest("Client not initialized")
else:
self.client.implicitly_wait(3)
init_db(rebuild=True, seed_data=True)
def reset():
init_db()
return 'ok'
def setUp(self):
os.environ['APP_SETTINGS'] == 'testing' or os.environ.update(APP_SETTINGS='testing')
self.config_obj = get_env_config()
self.db = db_session()
init_db()
self.meta_db = get_db_metadata()
def main() -> None:
logger.info("Creating initial data")
asyncio.run(init_db())
logger.info("Initial data created")
async def startup_event() -> None:
"""Initialize ORM for summarizer web app."""
logger.info('Starting up...')
init_db(app)
#!/usr/bin/env python3
from app import db
if __name__ == '__main__':
print('Initializing the database...')
admin_username, admin_password = db.init_db()
print('Initialization done')
print('Initial admin username: {}, password: {}'.format(
admin_username, admin_password))
#==============================================================================
# File: run.py
# Auth: Andrew Calvano / Jim Ching
# Desc: Start the Flask Application
#==============================================================================
from app import app # __init__.py globals
from app.db import init_db # db.py globals
from sys import argv
if len(argv) >= 2:
# initialize the admin account
if argv[1] == 'init':
init_db()
else:
print 'Usage: \'python run.py\' or \'python run.py init\' only.'
else:
# start the flask application
app.run('127.0.0.1', debug = True)
def setUp(self):
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///test.db"
# For most tests we don't care about the CSRF token.
flask_wtf.csrf.validate_csrf = lambda token: True
db.drop_all()
init_db()
