def create_app(script_info=None):
# instantiate the app
app = Flask(__name__)
# enable CORS
CORS(app)
# set config
app_settings = os.getenv('APP_SETTINGS')
app.config.from_object(app_settings)
mongo = PyMongo(app, tz_aware=True)
app.__setattr__('mongo', mongo)
# set up extensions
mongo.init_app(app)
# register blueprints
from project.api.service_b_routes import service_b_blueprint
app.register_blueprint(service_b_blueprint)
# shell context for flask cli
app.shell_context_processor({'app': app})
return app
class Database:
def __init__(self):
self.mongo = PyMongo()
def init_app(self, app):
self.mongo.init_app(app)
def delete(self, collection_name, query):
self.mongo.db[collection_name].delete_one(query)
def update(self, collection_name, query, new_values):
self.mongo.db[collection_name].update_one(query, new_values)
def add(self, collection_name, data):
return self.mongo.db[collection_name].insert_one(data)
def find_one(self, collection_name, query):
return self.mongo.db[collection_name].find_one(query)
def find(self, collection_name, query):
return self.mongo.db[collection_name].find(query)
def clear_db(self):
db = self.mongo.db
for collection in db.list_collection_names():
db[collection].delete_many({})
def app():
db = MongoEngine()
crypt = Bcrypt()
mongo = PyMongo()
mail = Mail()
login_manager = LoginManager()
login_manager.login_view = None
login_manager.login_message_category = 'info'
app = create_app({
"SECRET_KEY": 'testsecret',
"SECURITY_PASSWORD_SALT": 'testsalt',
"SECURITY_CSRF_COOKIE": {
"key": "XSRF-TOKEN"
},
"SECURITY_CSRF_IGNORE_UNAUTH_ENDPOINTS": True,
"WTF_CSRF_TIME_LIMIT": None,
"WTF_CSRF_CHECK_DEFAULT": False,
"MONGODB_SETTINGS": {
'host': 'mongodb://localhost/pwsched-test'
},
"MONGO_URI": 'mongodb://localhost/pwsched-test',
"TESTING": True
})
db.init_app(app)
crypt.init_app(app)
login_manager.init_app(app)
mongo.init_app(app)
mail.init_app(app)
Shift.drop_collection()
Congregation.drop_collection()
User.drop_collection()
congregation = Congregation(name="English - Willimantic").save()
shift = Shift(location="UConn",
datetime=datetime.now,
congregation=congregation.to_dbref()).save()
congregation.shifts.append(shift.to_dbref())
congregation.save()
hashed_password = crypt.generate_password_hash('password').decode('utf-8')
User(
name="Brother Service Overseer",
email="*****@*****.**",
password=hashed_password,
congregation=(
Congregation.objects().order_by('-id').first().to_dbref())).save()
yield app
Shift.drop_collection()
Congregation.drop_collection()
User.drop_collection()
def create_app():
app = Flask(__name__)
app.config[
"MONGO_URI"] = 'mongodb+srv://admin:[email protected]/mydb?retryWrites=true&w=majority'
#app.config["MONGO_URI"] = 'mongodb+srv://project_user:[email protected]/BusNetwork?retryWrites=true&w=majority'
app.config["FILE_UPLOADS"] = '/static/file/uploads'
mongo = PyMongo(app)
mongo.init_app(app)
app.register_blueprint(main)
return app
def make_db(app):
# SQL
db = SQLAlchemy()
db.init_app(app)
# Mongo
mg = PyMongo()
mg.init_app(app)
# CORS
CORS(app)
return db, mg, app
def init_app(app):
global mongo
global video_detections
global tfl_videos
mongo = PyMongo(app)
mongo.init_app(app)
# Set database collections which are used by the API
video_detections = mongo.db.videoDetections
tfl_videos = mongo.db.TfLvideos
# Index on fields which get sorted on for faster query performance
tfl_videos.create_index('datetime')
def setup_app(name, config='config'):
app = Flask(__name__)
app.config["MONGO_DBNAME"] = "NIST_test"
db = PyMongo(app, config_prefix='MONGO')
#APP_URL = "http://127.0.0.1:5001"
## Original ##
#app = Flask(name)
#app.config.from_object(config)
app.debug = True
# Flask-MongoEngine instance
db.init_app(app)
# Custom Converters
app.url_map.converters['objectid'] = ObjectIDConverter
return app
def init_app(app):
global mongo
mongo = PyMongo(app)
mongo.init_app(app)
class planItDb():
def __init__(self, secret):
self.sig = JSONWebSignatureSerializer(secret)
self.log = logging.getLogger("planItDb")
def init_db(self, app):
self.mongo = PyMongo()
self.mongo.init_app(app)
def log_access(self, idinfo, request, response):
#ensure we have the user in the user db
curs = self.mongo.db.users.find({'sub':idinfo['sub']}).limit(1)
if curs.count() == 0:
self.log.info("Add user to db: {}".format(idinfo))
# need to make a copy because mongo adds its objectid, whcih
# cannot be seralized into the session.
d = idinfo.copy()
d['created'] = datetime.datetime.utcnow()
d['remote_addr'] = [request.remote_addr]
self.mongo.db.users.insert(d)
else:
dbuser = curs.next()
if request.remote_addr not in dbuser['remote_addr']:
self.mongo.db.users.update(
{'_id': dbuser['_id']},
{'$push': {'remote_addr': request.remote_addr}}
)
self.mongo.db.accesses.insert(
{
'sub': idinfo['sub'],
'headers': dict(request.headers),
'args': {x:request.args[x] for x in request.args.keys()},
'time': datetime.datetime.utcnow(),
'remote': request.remote_addr,
'url': request.url,
'status': response.status_code,
'length': response.content_length
})
def validate_key(self, key, remote_addr):
doc = self.mongo.db.keys.find({'signature': key}).next()
if doc == None:
return False
if 'active' not in doc:
return False
op = {
'$inc': {'use_info.use_count': 1},
'$set': {'use_info.last_used': datetime.datetime.utcnow()}
}
if remote_addr not in doc['use_info']['remotes']:
op['$push'] = {'use_info.remotes': remote_addr}
self.mongo.db.keys.update({'_id': doc['_id']}, op)
return doc['active']
def enable_key(self, idinfo, signature, remote_addr):
return self.mongo.db.keys.update(
{'sub': idinfo['sub'], 'signature': signature},
{'$set': {'active': True}}
)
def disable_key(self, idinfo, signature, remote_addr):
return self.mongo.db.keys.update(
{'sub': idinfo['sub'], 'signature': signature},
{'$set': {'active': False}}
)
def delete_key(self, idinfo, signature, remote_addr):
self.mongo.db.users.update(
{"sub": idinfo['sub']},
{'$push': {'deleted_keys':
{'when': datetime.datetime.utcnow(),
'remote_addr': remote_addr,
'signature': signature}}
}
)
return self.mongo.db.keys.remove(
{'sub': idinfo['sub'], 'signature': signature})
def get_or_create_webkey(self, idinfo, remote_addr):
"look for a webkey, reutrn if found, else create one and return it"
curs = self.mongo.db.keys.find(
{'sub': idinfo['sub'], 'web': True, 'active':True},
{'_id': False})
if curs.count() > 0:
return curs.next()
return self.create_key(idinfo, remote_addr, web=True)
def create_key(self, idinfo, remote_addr, web=False):
"create a new key for the user with idinfo (jwt)"
keydoc = {
'sub': idinfo['sub'],
'created': datetime.datetime.utcnow(),
'create_address': remote_addr,
'use_info': {'use_count': 0,
'remotes': [remote_addr]},
'active': True,
'web': web,
'signature': [0*64] # dummy data
}
self.mongo.db.keys.insert(keydoc)
# do the insert to get the _id, then compute the signature on the id
# store the doc id,
docid = keydoc['_id']
del keydoc['_id']
keydoc['signature'] = self.sig.dumps(str(docid)).decode('utf-8')
self.log.info("signature is: {}".format(keydoc['signature']))
self.mongo.db.keys.update(
{"_id": docid},
{'$set': {'signature': keydoc['signature']}}
)
self.mongo.db.users.update(
{"sub": idinfo['sub']},
{'$push': {'created_keys':
{'when': datetime.datetime.utcnow(),
'remote_addr': remote_addr,
'signature': keydoc['signature']}}}
)
return keydoc
def list_keys(self, idinfo):
keys = list(self.mongo.db.keys.find(
{'sub': idinfo['sub']},
{'_id': False}))
self.log.info("got keys: {}".format(keys))
return keys
def configure_mongo(app: Flask, py_mongo: PyMongo = MONGO_DB):
app.config["MONGO_URI"] = os.environ.get(
"MONGODB_URI", default='mongodb://localhost:27017/myDatabase')
py_mongo.init_app(app)
perform_migrations(app.config["MONGO_URI"])
import jwt
import time
from pymongo import MongoClient
from flask_pymongo import PyMongo
import gridfs
from db_config import *
from common import *
# from StringIO import StringIO
from io import StringIO
pymongoDB = Blueprint('pymongoDB', __name__)
app2 = Flask(__name__)
app2.config['MONGO_URI'] = "mongodb://*****:*****@pymongoDB.route("/pymongoDB/uploadFileMongo", methods=['GET', 'POST'])
def uploadFileMongo():
def configure_mongo(app: Flask, py_mongo: PyMongo = MONGO_DB):
app.config["MONGO_URI"] = os.environ.get("MONGODB_URI", default='mongodb://localhost:27017/mongo')
py_mongo.init_app(app)
login_manger.login_view = 'online.login'
log = logger()
oauth = OAuth()
# app config---------------------------------------------------------------------
app.config.from_object(db_config['database'])
app.config.from_object(config['email'])
app.config.from_object(config['paging'])
app.config.from_object(config['cache'])
app.config.from_object(config['session'])
app.config.from_object(db_config['csrf'])
app.config.from_object(db_config['key'])
app.config.from_object(config['upload'])
# init---------------------------------------------------------------------------
mdb_user.init_app(app, config_prefix='MONGO_USER')
mdb_cont.init_app(app, config_prefix='MONGO_CONT')
mdb_sys.init_app(app, config_prefix='MONGO_SYS')
cache.init_app(app)
sess.init_app(app)
csrf.init_app(app)
bootstrap.init_app(app)
login_manger.init_app(app)
moment.init_app(app)
mail.init_app(app)
log.init_app(app)
oauth.init_app(app)
# oauth --------------------------------------------------------------------------
#QQ
QQ_APP_ID = os.getenv('QQ_APP_ID', db_config['my_oauth'].QQ_APP_ID)
# -*-coding:utf-8-*- from flask import Flask from flask_login import LoginManager from flask_pymongo import PyMongo from apps.db_config import MongoDB, Secret __author__ = "Allen Woo" # 创建flask实例对象 app = Flask(__name__) # 创建对象 mongo = PyMongo() login_manger = LoginManager() login_manger.session_protection = 'strong' # app加载配置 app.config.from_object(MongoDB) app.config.from_object(Secret) # 初始化mongo我们数据库库配置变量的前缀都是MONGO mongo.init_app(app, config_prefix='MONGO') login_manger.init_app(app) # 注册蓝本 from apps.blueprint import api, view app.register_blueprint(view, url_prefix="") app.register_blueprint(api, url_prefix="/api")
from flask import Flask
from warehouse.routes.backend import Backend
from flask_login import LoginManager
from flask_pymongo import PyMongo
# Initializes Flask
app = Flask(__name__, template_folder="./template")
app.config["MONGO_URI"] = "mongodb://127.0.0.1/SmartHouse"
db = PyMongo(app)
db.init_app(app)
Backend = Backend(db)
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
from user import User
@login_manager.user_loader
def load_user(user_id):
# since the user_id is just the primary key of our user table, use it in the query for the user
return User(int(user_id))
from warehouse.routes.main import main
# Registers the paths for the main component
app.register_blueprint(main)
from warehouse.routes.auth import auth
from flask import Flask from flask_pymongo import PyMongo from pymongo import MongoClient from config import Config app = Flask(__name__) app.config.from_object(Config) mongo = PyMongo(app) mongo.init_app(app) from app import routes
app = Flask(__name__)
database_file = open('db.txt', 'U')
db_host = database_file.readline().strip() #URL and port
dbname = database_file.readline().strip()
user = database_file.readline().strip()
password = database_file.readline().strip()
database_file.close()
app.config['MONGO_DBNAME'] = dbname
app.config['MONGO_URI'] = 'mongodb://' + user + ':' + password + '@' + db_host + '/' + dbname
app.config['MONGO_CONNECT'] = False
mongo = PyMongo()
with app.app_context():
mongo.init_app(app)
import json
#Copy from StackOverflow-----------------------------
from os import path
import os
extra_dirs = ['static','templates']
extra_files = extra_dirs[:]
for extra_dir in extra_dirs:
for dirname, dirs, files in os.walk(extra_dir):
for filename in files:
filename = path.join(dirname, filename)
if path.isfile(filename):
extra_files.append(filename)
application.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql+psycopg2://%(user)s:%(pw)s@%(host)s:%(port)s/%(db)s' % POSTGRES
application.config['WTF_CSRF_ENABLED'] = True
# MONGO URI(DISABLED)
application.config ['MONGO_URI'] = 'mongodb://localhost:27017/redwingdb'
application.config ["ACCEPTABLE_COLUMNS"] = ['type','item','storage_type','item_type','weight',
'uom','stock','value']
# Start application and database instances
db.app = application
db.init_app (application)
mongo = PyMongo (application)
mongo.init_app (application)
logfile_collection = mongo.db.logfiles
db.create_all ()
db.session.commit ()
'''
---------------------------------------------------
IMAGE UPLOAD LOADING FOR PLOTS AND VISUALIZATIONS
---------------------------------------------------
'''
# Load static image from server to html pages (for visualization tool)
# TODO:Add more comments explaining this.
