def initdb(drop):
if drop:
click.confirm('确认要删除原来的数据库吗？', abort=True)
db.drop_all()
click.echo('Dropped tables.')
db.create_all()
click.echo('Initialized database.')
def init(username, password):
click.echo('Initializing the database...')
db.create_all()
admin = Admin.query.first()
if admin is not None:
click.echo('The administrator already exists, updating...')
admin.username = username
admin.set_password(password)
else:
click.echo('Creating the temporary administrator account...')
admin = Admin(username=username,
blog_title='Bluelog',
blog_sub_title="No, I'm the real thing.",
name='Admin',
about='Anything about you.')
admin.set_password(password)
db.session.add(admin)
category = Category.query.first()
if category is None:
click.echo('Creating the default category...')
category = Category(name='Default')
db.session.add(category)
db.session.commit()
click.echo('Done.')
def init(username, password):
print('Initializing the database...')
db.create_all()
admin = Admin.query.first()
if admin is not None:
print('The administrator already exists, updating...')
admin.username = username
admin.set_password(password)
else:
print('Creating the temporary administrator account...')
admin = Admin(username='******',
blog_title="Flaskblog",
blog_sub_title="No,I am the real thing",
name="Miro",
about="I am a fun guy....")
admin.set_password(password)
db.session.add(admin)
category = Category.query.first()
if category is None:
print('Creating the default category...')
category = Category(name='Default')
db.session.add(category)
db.session.commit()
print('Done.')
def before_first_request():
# Create any database tables that don't exist yet.
db.create_all()
# Create the Roles "admin" and "end-user" -- unless they already exist
user_datastore.find_or_create_role(name='admin', description='Administrator')
user_datastore.find_or_create_role(name='end-user', description='End user')
# Create two Users for testing purposes -- unless they already exists.
# In each case, use Flask-Security utility function to encrypt the password.
encrypted_password = utils.encrypt_password(private.STARTING_ADMIN_PASS)
if not user_datastore.get_user(private.STARTING_ADMIN1):
user_datastore.create_user(email=private.STARTING_ADMIN1, password=encrypted_password)
if not user_datastore.get_user(private.STARTING_ADMIN2):
user_datastore.create_user(email=private.STARTING_ADMIN2, password=encrypted_password)
# Commit any database changes; the User and Roles must exist before we can add a Role to the User
db.session.commit()
# Give one User has the "end-user" role, while the other has the "admin" role. (This will have no effect if the
# Users already have these Roles.) Again, commit any database changes.
user_datastore.add_role_to_user(private.STARTING_ADMIN1, 'admin')
confirmed_admin = user_datastore.get_user(private.STARTING_ADMIN1)
confirmed_admin.confirmed_at = datetime.datetime.utcnow()
user_datastore.add_role_to_user(private.STARTING_ADMIN2, 'admin')
confirmed_admin = user_datastore.get_user(private.STARTING_ADMIN2)
confirmed_admin.confirmed_at = datetime.datetime.utcnow()
db.session.commit()
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = '11eeo9_rCa0a@a#roCr/'
ENV = 'prod'
if ENV == 'dev':
app.debug = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/portfolio'
else:
app.debug = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-3-228-114-251.compute-1.amazonaws.com:5432/d9f0l50lh8a8ai'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
extensions.bootstrap.init_app(app)
app.register_blueprint(main)
db.init_app(app)
with app.app_context():
db.create_all()
return app
def register_extensions(db, app):
"""Register Flask extensions."""
db.init_app(app)
with app.app_context():
db.create_all()
return None
def initdb(drop):
if drop:
db.drop_all()
print('Drop tables')
db.create_all()
Role.init_role()
print('Initialized database')
def create_app():
app = Flask(__name__)
if app.config["ENV"] == "development":
app.config.from_object("config.DevelopmentConfig")
else:
app.config.from_object("config.ProductionConfig")
app.register_blueprint(json_return)
app.register_blueprint(main_page)
app.register_blueprint(account_page)
app.register_blueprint(register_login_page)
app.register_blueprint(general_page)
app.register_blueprint(about_page)
app.register_blueprint(experience_page)
app.register_blueprint(education_page)
app.register_blueprint(skills_page)
app.register_blueprint(project_page)
from extensions import db, login_manager, cors, migrate
db.init_app(app)
login_manager.init_app(app)
cors.init_app(app)
migrate.init_app(app, db)
@login_manager.user_loader
def load_user(user_id):
return General.query.get(int(user_id))
with app.app_context():
db.create_all()
return app
def create_app(settings_overrides=None):
app = Flask(__name__)
# Using Cross-origin resource sharing to allow
# the ajax call from another domain since
# SimpleHTTPServer runs on port 8000 and this
# application runs on port 5000
cors = CORS(app)
app.config['CORS_HEADERS'] = 'Content-Type'
configure_settings(app, settings_overrides)
# Initialise database
db.init_app(app)
configure_blueprints(app)
with app.app_context():
db.create_all()
# Initialising the data in the database
# this should not be needed in a real system
# since the data would be fed in as a result or
# real events taking place.
# However for the sake of this task we need data to work with
# so will keeo this here.
if not Shop.query.count():
load_shops('shops.csv')
if not Product.query.count():
load_products('products.csv')
if not Tag.query.count():
load_tags('tags.csv')
if not Tagging.query.count():
load_taggings('taggings.csv')
return app
def register_extensions(app_obj):
app_obj.app_context().push()
app_obj.register_blueprint(home_controller, url_prefix="/")
app_obj.register_blueprint(user_controller, url_prefix="/api/users")
app_obj.register_blueprint(project_controller, url_prefix="/api/projects")
db.init_app(app_obj)
db.create_all()
def create_app():
app = Flask(__name__)
app.config.from_object('config')
# Create modules
app.register_blueprint(indexModule)
app.register_blueprint(themeModule)
app.register_blueprint(groupModule)
app.register_blueprint(relationModule)
app.register_blueprint(constructionModule)
app.register_blueprint(adminModule)
app.register_blueprint(mymapModule)
# Enable the toolbar?
app.config['DEBUG_TB_ENABLED'] = app.debug
# Should intercept redirects?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = True
# Enable the profiler on all requests, default to false
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# Enable the template editor, default to false
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# debug toolbar
# toolbar = DebugToolbarExtension(app)
# Create database
db.init_app(app)
with app.test_request_context():
db.create_all()
return app
def configure_extensions(app):
from extensions import cache, db, mail, Login
# initialize mail
mail = mail.init_app(app)
# initialize cache
cache = cache.init_app(app)
# initialize database
db.init_app(app)
app.logger.info("Database initialized.")
db.app = app
db.metadata.bind = db.get_engine(app)
db.metadata.reflect()
app.logger.info("Database tables reflected.")
from models import User
db.create_all(bind=['users'])
# login
Login.manager.setup_app(app)
@Login.manager.user_loader
def load_user(userid):
return User.query.get(userid)
@Login.manager.token_loader
def load_token(token):
return User.query.filter(User.passkey == token).first()
def setUp(self) -> None:
self.app = create_app('test')
self.app.app_context().push()
db.drop_all()
db.create_all()
self.book1 = {'book_id': 1,
"name": 'The Overstory',
'author': 'Richard Powers',
'year_of_publication': 2018,
'edition': '1st',
'translator': None
}
self.book2 = {'book_id': 2,
'name': 'Test-Driven Development with Python',
'author': 'Percival Harry J.W.',
'year_of_publication': 2014,
'edition': '2nd',
'translator': None
}
self.user1 = {'user_id': 1,
'name': 'John Smith',
'email': '*****@*****.**',
}
self.user2 = {'user_id': 2,
'name': 'Jane Doe',
'email': '*****@*****.**'
}
db.session.add(Users(**self.user1))
db.session.add(Users(**self.user2))
db.session.commit()
def init(username, password):
"""Building project, just for you."""
click.echo('Initializing the database...')
db.create_all()
admin = Admin.query.first()
if admin is not None:
click.echo('The administrator already exists, updating...')
admin.username = username
admin.set_password(password)
else:
click.echo('Creating the temporary administrator account...')
admin = Admin(username=username, name='Admin')
admin.set_password(password)
db.session.add(admin)
# project = Project.query.first()
# if project is None:
# click.echo('Creating the default project...')
# project = Project(name='Default',uid="111",manager_id="1")
# db.session.add(project)
db.session.commit()
click.echo('Done.')
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
register_extensions(app)
add_blueprints(app)
db.create_all()
return app
def configure_extensions(app):
""" Configure app extension. """
# flask SQLAlchemy
db.init_app(app)
db.create_all(app=app)
# CSRF Protection
csrf.init_app(app)
@csrf.error_handler
def csrf_error(reason):
raise CsrfTokenError()
# mail.init_app(app)
# flask OAuthlib
oauth.init_app(app)
# Login Manger
login_manager.init_app(app)
# Interface for anonymous users
class AnonymousUserMixin(_AnonymousUserMixin):
username = '******'
firstName = ''
lastName = ''
email = ''
role = Role.GUEST
is_admin = False
login_manager.login_view = 'auth.post_login'
login_manager.session_protection = "strong"
login_manager.anonymous_user = AnonymousUserMixin
def initdb(drop):
if drop:
click.confirm("This operation will delete the database, continue?",
abort=True)
db.drop_all()
click.echo('Drop tables.')
db.create_all()
click.echo("Initialized database.")
def configure_extensions(app):
"""This function configures all extensions used in app."""
db.init_app(app)
with app.app_context():
db.create_all()
db.session.commit()
def __init__(self):
app = create_app(config_object=ProdConfig)
app_context = app.app_context()
app_context.push()
db.drop_all() # drop all tables
db.create_all() # create a new schema
with open('default.json') as file:
self.default_data = json.load(file)
def configure_extensions(app):
"""This function configures all extensions used in app."""
db.init_app(app)
with app.app_context():
db.create_all()
db.session.commit()
def initdb(drop):
"""Initialize the database."""
if drop:
click.confirm('This operation will delete the database, do you want to continue?', abort=True)
db.drop_all()
click.echo('Drop tables.')
db.create_all()
click.echo('Initialized database.')
def db_corner(app_corner):
db.app = app_corner
with app_corner.app_context():
db.create_all('__all__', app_corner)
yield db
db.session.remove()
db.drop_all()
def configure_extensions(app):
app.config.setdefault('JWT_SECRET_KEY', SECRET_KEY)
app.config['SQLALCHEMY_DATABASE_URI'] = db_path
app.config[
'SQLALCHEMY_TRACK_MODIFICATIONS'] = SQLALCHEMY_TRACK_MODIFICATIONS
db.init_app(app)
jwt.init_app(app)
db.create_all(app=app)
def init_db():
print('create tables...')
db.create_all()
print('tables created.')
if not User.query.first():
user_datastore.create_user(email=app.config['ADMIN_USER'],
password=utils.encrypt_password(
app.config['ADMIN_PASSWORD']))
db.session.commit()
def init(config='settings.py'):
app = Flask(__name__)
app.config.from_pyfile('settings.py')
db.init_app(app)
ma.init_app(app)
with app.app_context():
db.create_all()
return app
def create_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://root:@localhost/knowledge_management?charset=utf8'
#app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///flask-admin.db'
# Create modules
app.register_blueprint(indexModule)
app.register_blueprint(themeModule)
app.register_blueprint(groupModule)
app.register_blueprint(relationModule)
app.register_blueprint(constructionModule)
app.register_blueprint(adminModule)
app.register_blueprint(brustModule)
app.config['DEBUG'] = True
app.config['ADMINS'] = frozenset(['*****@*****.**'])
app.config['SECRET_KEY'] = 'SecretKeyForSessionSigning'
'''
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://%s:@%s/%s?charset=utf8' % (MYSQL_USER, MYSQL_HOST, MYSQL_DB)
app.config['SQLALCHEMY_ECHO'] = False
'''
app.config['DATABASE_CONNECT_OPTIONS'] = {}
app.config['THREADS_PER_PAGE'] = 8
app.config['CSRF_ENABLED'] = True
app.config['CSRF_SESSION_KEY'] = 'somethingimpossibletoguess'
# Enable the toolbar?
app.config['DEBUG_TB_ENABLED'] = app.debug
# Should intercept redirects?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = True
# Enable the profiler on all requests, default to false
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# Enable the template editor, default to false
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# debug toolbar
# toolbar = DebugToolbarExtension(app)
# Create database
db.init_app(app)
with app.test_request_context():
db.create_all()
# init security
security.init_app(app, datastore=user_datastore)
# init admin
admin.init_app(app)
admin.add_view(UserAdmin(User, db.session))
# admin.add_view(sqla.ModelView(User, db.session))
admin.add_view(sqla.ModelView(Role, db.session))
return app
def db_corner(app_corner):
db.app = app_corner
with app_corner.app_context():
db.create_all('__all__', app_corner)
yield db
db.session.remove()
db.drop_all()
def create_app():
app = Flask(__name__)
app.config.from_object('server.app.config')
init_app(app)
config_extensions(app)
with app.app_context():
db.create_all()
return app
def create_app():
app = Flask(__name__)
app.config.from_object('server.app.config')
init_app(app)
config_extensions(app)
with app.app_context():
db.create_all()
return app
def setUp(self):
"""
1. create db if not exists, drop db and create if exists
2. db.create_all()
"""
create_db()
self.app = create_app(TestingConfig)
self.app_context = self.app.app_context()
self.app_context.push()
self.test_client = self.app.test_client()
db.create_all()
def configure_extensions(app):
# setup SQLAlchemy
db.init_app(app)
# db.drop_all(app=app)
db.create_all(app=app)
from dummy_data import create_test_data
# create_test_data(app)
mail.init_app(app)
bcrypt.init_app(app)
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
register_extensions(app)
register_resources(app)
db.init_app(app)
with app.app_context():
db.create_all()
return app
def register_extensions(app):
argon2.init_app(app)
loginmgr.init_app(app)
loginmgr.login_view = 'login'
create_dash_app(app)
# Database initialisation
db.init_app(app)
migrate = Migrate(app, db)
with app.app_context():
db.create_all()
return db
def create_db():
"""Create database and its schema. Add post states 'draft' and 'published'"""
db.create_all()
from models import PostState
PostState.query.delete()
db.session.add(PostState('draft'))
db.session.add(PostState('published'))
db.session.commit()
print('Database schema and, "draft" and "published" blog post states have been created. '
'You can use populate_db command to populate it with the first post and an example draft post. '
'Also the create_user command to create admin users who can write blog posts.')
def setUp(self):
import config
from main import app_factory
from extensions import db
self.app: Empty = app_factory(config.Test, config.project_name)
self.client = self.app.test_client()
# https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-xv-a-better-application-structure/page/2
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
def create_app(env='dev'):
app = Flask(__name__)
app.config.from_object(get_config(env))
db.init_app(app)
mail.init_app(app)
app.register_blueprint(user_blueprint)
app.register_blueprint(book_blueprint)
app.register_blueprint(library_blueprint)
app.register_blueprint(home_page)
db.create_all(app=app)
migrate.init_app(app, db)
return app
def run(self, **kwargs):
db.create_all()
# check if admin exists
a = Role.query.filter_by(name='admin').first()
if a is None:
db.session.add(Role(name='admin'))
db.session.commit()
u = prompt('Admin Email?', default='*****@*****.**')
p = prompt('Admin Password (min 6 characters)?', default='enferno')
CreateUserCommand().run(email=u, password=p, active=1)
AddRoleCommand().run(user_identifier=u, role_name='admin')
else:
print 'Seems like an Admin is already installed'
def run(self, **kwargs):
db.create_all()
# check if admin exists
a = Role.query.filter_by(name='admin').first()
if a is None:
db.session.add(Role(name='admin'))
db.session.commit()
u = prompt('Admin Email?', default='*****@*****.**')
p = prompt('Admin Password (min 6 characters)?', default='enferno')
CreateUserCommand().run(email=u, password=p, active=1)
AddRoleCommand().run(user_identifier=u, role_name='admin')
else:
print 'Seems like an Admin is already installed'
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'the quick brown dog jumps over the lazy fox'
# mysql+pymysql://<username>:<password>@<host>/<dbname>'
# (using sqlite for dev purposes)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['UPLOAD_FOLDER'] = '/storage/dbfile'
# alembic.init_app(app)
db.init_app(app)
import models # noqa: F401
with app.app_context():
db.create_all()
db.session.commit()
# alembic.revision('making changes')
# alembic.upgrade()
from routes.route_utilities import verify_token # noqa: F401
from routes.user import user_blueprint
from routes.dbfile import dbfile_blueprint
from routes.auth import auth_blueprint
from routes.employee import employee_blueprint
# from routes.cost import cost_blueprint
from routes.reservation import reservation_blueprint
from routes.roomtype import roomtype_blueprint
from routes.room import room_blueprint
from routes.sale import sale_blueprint
from routes.reservat import reservat_blueprint
from routes.statgen import statgen_blueprint
app.register_blueprint(auth_blueprint)
app.register_blueprint(user_blueprint)
app.register_blueprint(dbfile_blueprint)
app.register_blueprint(employee_blueprint)
# app.register_blueprint(cost_blueprint)
app.register_blueprint(reservation_blueprint)
app.register_blueprint(roomtype_blueprint)
app.register_blueprint(room_blueprint)
app.register_blueprint(sale_blueprint)
app.register_blueprint(reservat_blueprint)
app.register_blueprint(statgen_blueprint)
currencyThread = threading.Thread(target=putCurrenciesInDB, args=(app,))
# currencyThread.start() # enable for testing and production only
return app
def create_app(config_mode): app = Flask(__name__) app.config.from_object(config[config_mode]) toolbar.init_app(app) foundation.init_app(app) from views import main app.register_blueprint(main) db.init_app(app) db.create_all(app=app) return app
def create_app():
app = Flask(__name__)
app.config.from_object('config')
# Create database
db.init_app(app)
with app.test_request_context():
db.create_all()
"""
# Create admin
admin.init_app(app)
for m in model.__all__:
m = getattr(model, m)
n = m._name()
admin.add_view(SQLModelView(m, db.session, name=n))
"""
return app
def setUp(self):
sqlite_in_memory_uri = 'sqlite://'
config = {'SQLALCHEMY_DATABASE_URI': sqlite_in_memory_uri,
'TESTING': True,
'WTF_CSRF_ENABLED': False}
app = create_app(config)
self.test_user_email = 'tester@test_users.com'
self.test_user_password = '******'
with app.app_context():
db.create_all()
self.test_user = User(self.test_user_email, self.test_user_password, 'Mr. Tester', timezone=-5)
db.session.add(self.test_user)
db.session.add(PostState(name='draft'))
db.session.add(PostState(name='published'))
db.session.commit()
self.app = app.test_client()
self.get_context = app.app_context
def create_app():
app = Flask(__name__)
app.config.from_object('config')
# Create modules
app.register_blueprint(rootModule)
app.register_blueprint(identifyModule)
app.register_blueprint(moodlensModule)
app.register_blueprint(profileModule)
app.register_blueprint(propagateModule)
app.register_blueprint(adminModule)
app.register_blueprint(graphModule)
# Enable the toolbar?
app.config['DEBUG_TB_ENABLED'] = app.debug
# Should intercept redirects?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = True
# Enable the profiler on all requests, default to false
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# Enable the template editor, default to false
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# debug toolbar
# toolbar = DebugToolbarExtension(app)
# Create database
db.init_app(app)
with app.test_request_context():
db.create_all()
# # Create admin
# admin.init_app(app)
# for m in model.__all__:
# m = getattr(model, m)
# n = m._name()
# admin.add_view(SQLModelView(m, db.session, name=n))
return app
def configure_extensions(app):
""" Configure app extension. """
# flask SQLAlchemy
db.init_app(app)
db.create_all(app=app)
# CSRF Protection
csrf.init_app(app)
@csrf.error_handler
@xhr_or_template('errors/forbidden-page.html')
def csrf_error(message):
flash(message, 'danger')
return {'status': 403}
# mail.init_app(app)
# Login Manger
login_manager.init_app(app)
login_manager.login_view = 'frontend.login'
# Setup login manager anonymous class.
class DefaultAnonymousUserMixin(AnonymousUserMixin):
id = None
firstName = None
lastName = None
username = '******'
email = None
dateJoined = None
avatar = 'avatar.jpg' # TODO: find a better avatar img for guest users
@staticmethod
def is_admin():
return False
login_manager.anonymous_user = DefaultAnonymousUserMixin
def create_app(priority_settings=None):
# Initialising a Flask App
app = Flask(__name__, static_url_path='')
heroku = Heroku()
compress = Compress()
# Load configuraiton from settings file
app.config.from_object(settings)
app.config.from_object(priority_settings)
# Initialise database
db.init_app(app)
# Using Heroku as deployment server
heroku.init_app(app)
# Gziping responses from app
compress.init_app(app)
# Using Flask-Login
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'accounts.login'
@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))
# Registering Blueprints in an effor to make app modular
app.register_blueprint(index_blueprint)
app.register_blueprint(todo_blueprint)
app.register_blueprint(user_blueprint)
app.register_blueprint(api_todo_blueprint)
with app.app_context():
db.create_all()
return app
def initdb():
db.drop_all()
db.create_all()
def create_app():
app = Flask(__name__)
# Create modules
app.register_blueprint(rootModule)
app.register_blueprint(moodlensModule)
app.register_blueprint(opinionModule)
app.register_blueprint(propagateModule)
app.register_blueprint(indexModule)
app.register_blueprint(evolutionModule)
app.register_blueprint(identifyModule)
app.register_blueprint(quota_systemModule)
app.register_blueprint(dataoutModule)
# the debug toolbar is only enabled in debug mode
app.config['DEBUG'] = True
app.config['ADMINS'] = frozenset(['*****@*****.**'])
app.config['SECRET_KEY'] = 'SecretKeyForSessionSigning'
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://%s:@%s/%s?charset=utf8' % (MYSQL_USER, MYSQL_HOST, MYSQL_DB)
app.config['SQLALCHEMY_ECHO'] = False
app.config['DATABASE_CONNECT_OPTIONS'] = {}
app.config['THREADS_PER_PAGE'] = 8
app.config['CSRF_ENABLED'] = True
app.config['CSRF_SESSION_KEY'] = 'somethingimpossibletoguess'
# Enable the toolbar?
app.config['DEBUG_TB_ENABLED'] = app.debug
# Should intercept redirects?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = True
# Enable the profiler on all requests, default to false
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# Enable the template editor, default to false
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# debug toolbar
# toolbar = DebugToolbarExtension(app)
app.config['MONGO_HOST'] = MONGODB_HOST
app.config['MONGO_PORT'] = MONGODB_PORT
app.config['MONGODB_SETTINGS'] = {
'db': MASTER_TIMELINE_54API_WEIBO_DB,
'host': MONGODB_HOST,
'port': MONGODB_PORT
}
# Create mysql database
db.init_app(app)
with app.test_request_context():
db.create_all()
# Create mongo_engine
mongo_engine.init_app(app)
admin.init_app(app)
"""
# Create mysql database admin, visit via url: http://HOST:PORT/admin/
for m in model.__all__:
m = getattr(model, m)
n = m._name()
admin.add_view(SQLModelView(m, db.session, name=n))
for m in mongodb_model.__all__:
admin.add_view(MongoDBView(m))
"""
# init mongo
mongo.init_app(app)
return app
def init_db():
'''init database'''
db.create_all()
print 'Init database success.'
def init_db():
db.create_all(app=app)
def run(self):
db.create_all()
def initdb():
app = make_application()
db.app = app
db.drop_all()
db.create_all()
logger.info("Database reseted")
def create_db(app):
from models import User, Client
db.create_all()
return None
def createall():
"Creates database tables"
db.create_all()
'''
Created on Apr 25, 2016
@author: gonzalo
'''
from factory import create_app
from model import User
from extensions import db
if __name__ == '__main__':
app = create_app("local")
db.create_all(app=app)
import flask
import flask.views
from views import *
from extensions import db
app = flask.Flask(__name__)
app.secret_key = "lepetitbonhomeenmousse"
users = {'test': 'test'}
## DATABASES
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db'
db.init_app(app)
db.app = app
db.create_all()
## VIEWS
class MainView(flask.views.MethodView):
def get(self):
return flask.render_template('index.html')
def post(self):
if 'logout' in flask.request.form:
flask.session.pop('username', None)
return flask.redirect(flask.url_for('index'))
required = ['username', 'password']
for r in required:
if r not in flask.request.form:
flask.flash("Error: {0} is required.".format(r))
def before_first_request():
db.create_all()
def create_all(app=None):
db.create_all(app=app)
def createall():
db.create_all()
def init_table():
db.create_all()
def create_db():
with app.test_request_context():
db.create_all()
