#coding:utf-8
from flask import Flask, Blueprint
from flask_bootstrap import Bootstrap
from flask_mongoengine import MongoEngine
from flask_nav import Nav
from flask_nav.elements import View, Navbar
from FW.config import config
Databases = MongoEngine()
bootstrap = Bootstrap()
nav = Nav()
Top = Navbar('FuckingWords',
View('Home','main_views.index'),
View('Help','main_views.Help'),
View('Units','Units_views.index'),
View('Words','Words_views.index'),
View('Create','Create_pdf_views.pdf_list')
)
def create_app():
App = Flask(__name__)
App.config.from_object(config['production'])
Databases.init_app(App)
bootstrap.init_app(App)
nav.init_app(App)
nav.register_element('top', Top)
from flask import Flask
from flask_mongoengine import MongoEngine
from flask_jwt_extended import JWTManager
from flask_mail import Mail
from todo.utils.response import response_with
import todo.utils.response_code as response_code
from celery import Celery
import logging
# Init MongoDB object
mongo = MongoEngine()
# Init Flask-Mail object
mail = Mail()
# Init Celery object
celery = Celery(__name__)
def init_celery(app, celery):
"""
Update celery config and celery object with application context
:param app: Flask application object
:param celery: Celery object
"""
celery.conf.update(broker_url=app.config['CELERY_BROKER_URL'],
result_backend=app.config['CELERY_RESULT_BACKEND'])
class ContextTask(celery.Task):
def __call__(self, *args, **kwargs):
os.umask(0)
os.makedirs(FILE_FOLDER, mode=0o777)
if not os.path.exists(FILE_FOLDER_CONVERTED):
os.umask(0)
os.makedirs(FILE_FOLDER_CONVERTED, mode=0o777)
listar.config['SECRET_KEY'] = 'S3cretH4sh'
listar.config['MONGODB_SETTINGS'] = {
'db':
os.environ["MONGO_DB"],
'host':
"mongodb+srv://" + os.environ["MONGO_USER"] + ":" +
os.environ["MONGO_PASSWORD"] + "@" + os.environ["MONGO_HOST"] + "/" +
os.environ["MONGO_DB"] + "?retryWrites=true&w=majority"
}
db = MongoEngine(listar)
ma = Marshmallow(listar)
def allowed_file(filename, isOriginal):
if isOriginal == 1:
return '.' in filename and \
filename.rsplit('.', 1)[1].upper() in ALLOWED_EXTENSIONS
else:
return '.' in filename and \
filename.rsplit('.', 1)[1].upper() in ALLOWED_CONVERTED_EXTENSIONS
class UserAdmin(UserMixin, me.Document):
meta = {'collection': 'admins', 'index_background': True}
id = me.StringField(
def get_db_connection(app):
app.config['MONGODB_HOST'] = DB_URI
db = MongoEngine()
db.init_app(app)
return db
import logging
from flask import Flask
from flask_appbuilder import AppBuilder
from flask_appbuilder.security.mongoengine.manager import SecurityManager
from flask_mongoengine import MongoEngine
logging.basicConfig(format="%(asctime)s:%(levelname)s:%(name)s:%(message)s")
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object("config")
dbmongo = MongoEngine(app)
appbuilder = AppBuilder(app, security_manager_class=SecurityManager)
from . import models, views # noqa
APP = Flask(__name__)
APP.secret_key = session_key("key.hex")
APP.jinja_env.add_extension('jinja2.ext.loopcontrols')
INTROMARKDOWN = intro(
"README.md",
"https://raw.githubusercontent.com/qeeqbox/analyzer/master/README.md")
APP.config['MONGODB_SETTINGS'] = json_settings[
environ["analyzer_env"]]["web_mongo"]
APP.config['SESSION_COOKIE_SAMESITE'] = "Lax"
QUEUE = QBQueue("analyzer",
json_settings[environ["analyzer_env"]]["redis_settings"])
ANALYZER_TIMEOUT = json_settings[environ["analyzer_env"]]["analyzer_timeout"]
FUNCTION_TIMEOUT = json_settings[environ["analyzer_env"]]["function_timeout"]
MALWARE_FOLDER = json_settings[environ["analyzer_env"]]["malware_folder"]
MONGO_DB = MongoEngine()
MONGO_DB.init_app(APP)
BCRYPT = Bcrypt(APP)
LOGIN_MANAGER = LoginManager()
LOGIN_MANAGER.setup_app(APP)
CSRF = CSRFProtect()
CSRF.init_app(APP)
Markdown(APP)
class Namespace:
'''
this namespace for switches
'''
def __init__(self, kwargs):
self.__dict__.update(kwargs)
"""
CRUD and filter tests
"""
import json
import unittest
from unittest.mock import MagicMock
from flask_mongoengine import MongoEngine
from app import APP
from authentification import JwtTokenAuthentication
from documents import Comment, User
DB = MongoEngine()
APP.config.from_pyfile('configs/testing.conf')
DB.init_app(APP)
class UnauthorizedTestCase(unittest.TestCase):
"""
Authorization method returns unauthorized 401
"""
def setUp(self):
self.authorized = JwtTokenAuthentication.authorized
JwtTokenAuthentication.authorized = MagicMock(return_value=False)
def tearDown(self):
JwtTokenAuthentication.authorized = self.authorized
class AuthorizedTestCase(unittest.TestCase):
"""
Authorization method returns authorized 200
def create_app():
""" Flask application factory """
# Setup Flask and load app.config
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Setup Flask-MongoEngine
db = MongoEngine(app)
# Define the User document.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Document, UserMixin):
active = db.BooleanField(default=True)
# User authentication information
username = db.StringField(default='')
password = db.StringField()
# User information
first_name = db.StringField(default='')
last_name = db.StringField(default='')
# Relationships
roles = db.ListField(db.StringField(), default=[])
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# The Home page is accessible to anyone
@app.route('/')
def home_page():
# String-based templates
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>Home page</h2>
<p><a href={{ url_for('user.register') }}>Register</a></p>
<p><a href={{ url_for('user.login') }}>Sign in</a></p>
<p><a href={{ url_for('home_page') }}>Home page</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>Member page</a> (login required)</p>
<p><a href={{ url_for('user.logout') }}>Sign out</a></p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users via the @login_required decorator
@app.route('/members')
@login_required # User must be authenticated
def member_page():
# String-based templates
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>Members page</h2>
<p><a href={{ url_for('user.register') }}>Register</a></p>
<p><a href={{ url_for('user.login') }}>Sign in</a></p>
<p><a href={{ url_for('home_page') }}>Home page</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>Member page</a> (login required)</p>
<p><a href={{ url_for('user.logout') }}>Sign out</a></p>
{% endblock %}
""")
return app
from flask_sqlalchemy import SQLAlchemy
from flask_wtf.csrf import CSRFProtect
from flask_mongoengine import MongoEngine
from flask_pymongo import PyMongo
db = SQLAlchemy()
csrf = CSRFProtect()
mongodb_du = MongoEngine()
# 字典列表
api_config = {
'size': {
'0': '35.5',
'1': '36',
'2': '36.5',
'3': '37',
'4': '37.5',
'5': '38',
'6': '38.5',
'7': '39',
'8': '39.5',
'9': '40',
'10': '40.5',
'11': '41',
'12': '41.5',
'13': '42',
'14': '42.5',
'15': '43',
def get_db(app):
db = getattr(g, '_database', None)
if db is None:
db = g._database = MongoEngine(app)
return db
"""
FILE: app/__init.py__
This file contains the application factory (Flask instance created here)
and allows 'site' to be treated like a package.
"""
import os
from flask import Flask
from config import Config
from flask_cors import CORS #comment this on deployment
from flask_mongoengine import MongoEngine
from flask_jwt_extended import JWTManager
db = MongoEngine() # db initialization occurs before the app starts
app = Flask(__name__)
app.config.from_object(Config)
app.config['MONGODB_SETTINGS'] = {
"db": "simplicity-cloud",
"host": "localhost",
"port": 27017
}
db.init_app(app)
# hw1 = Hardware(name="Set1", capacity=512)
jwt = JWTManager(app)
def test_mongoengine_db_adapter(app):
# Make sure Flask-MongoEngine and MongoEngine are installed
try:
from flask_mongoengine import MongoEngine
from mongoengine import connect
except ImportError:
return
# Import ConnectionError or MongoEngineConnectionError, depending on version
try:
from mongoengine.connection import MongoEngineConnectionError # 0.11.0+
except ImportError:
from mongoengine.connection import ConnectionError as MongoEngineConnectionError # 0.10.9 and down
# Make sure that a MongoDB server is up and running on localhost:27017
try:
db = MongoEngine(app)
except MongoEngineConnectionError:
return
class User(db.Document):
username = db.StringField(default='')
roles = db.ListField(db.StringField(), default=[])
db_manager = DBManager(app, db, UserClass=User)
username = '******'
# Test create_all_tables
db_manager.drop_all_tables()
db_manager.create_all_tables()
# Test add_object
user1 = db_manager.add_user(username='******')
user2 = db_manager.add_user(username='******')
db_manager.commit()
# Test tokenizing MongoDB IDs
token_manager = app.user_manager.token_manager
token = token_manager.generate_token(user1.id)
assert (token_manager.verify_token(token, 3600))
# Test get_object
user = db_manager.get_user_by_id('1234567890ab1234567890ab')
assert user == None
user = db_manager.get_user_by_id(user1.id)
assert user == user1
# Test find methods
user = db_manager.find_user_by_username('Xyz')
assert user == None
user = db_manager.find_user_by_username(username)
assert user == user1
# Test find_objects, directly through adapter
users = db_manager.db_adapter.find_objects(User)
# Test save_object
user.username = '******'
db_manager.save_object(user)
db_manager.commit()
user = db_manager.get_user_by_id(user.id)
assert user == user1
assert user.username == 'NewUsername'
# Test user_role methods
db_manager.add_user_role(user1, 'Admin')
db_manager.add_user_role(user1, 'Agent')
user_roles = db_manager.get_user_roles(user1)
assert user_roles == ['Admin', 'Agent']
# Test delete_object
user1_id = user1.id
db_manager.delete_object(user1)
db_manager.commit()
user = db_manager.get_user_by_id(user1_id)
assert user == None
user = db_manager.get_user_by_id(user2.id)
assert user == user2
# Test drop_all_tables
db_manager.drop_all_tables()
user = db_manager.get_user_by_id(user2.id)
assert user == None
class OneLove(object):
class Result(object):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
api = None
app = None
blueprint = None
collect = Collect()
db = MongoEngine()
jwt = JWT()
mail = Mail()
security = Security()
socketio = None
toolbar = None
user_datastore = None
def __init__(self, app=None):
if app is not None:
if app.config['DEBUG']:
self.cors = CORS()
self.init_app(app)
def init_app(self, app):
global current_app
current_app = self
self.app = app
if app.config['DEBUG']:
self.cors.init_app(
self.app,
resources={r'/api/*': {
'origins': '*'
}},
)
from api import api_v0, api
self.api = api
self.blueprint = Blueprint(
'onelove',
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/static/onelove',
)
self.app.register_blueprint(self.blueprint)
self.app.register_blueprint(api_v0, url_prefix='/api/v0')
self.app.register_blueprint(apidoc.apidoc)
self.mail.init_app(self.app)
self.db.init_app(self.app)
self.user_datastore = MongoEngineUserDatastore(
self.db,
User,
Role,
)
self.security.init_app(
self.app,
self.user_datastore,
)
self.jwt.init_app(self.app)
self.collect.init_app(self.app)
if self.app.config.get('DEBUG_TB_PANELS', False):
from flask_debugtoolbar import DebugToolbarExtension
from flask_debug_api import DebugAPIExtension
self.toolbar = DebugToolbarExtension(self.app)
self.toolbar = DebugAPIExtension(self.app)
self.socketio = SocketIO(self.app, logger=True)
self.app.onelove = self
@jwt.authentication_handler
def authenticate(username, password):
try:
user = User.objects.get(email=username)
except User.DoesNotExist:
return None
result = OneLove.Result(
id=str(user.id),
email=user.email,
first_name=user.first_name,
last_name=user.last_name,
)
if verify_password(password, user.password):
return result
@jwt.identity_handler
def identity(payload):
try:
user = User.objects.get(id=payload['identity'])
except User.DoesNotExist:
user = None
return user
def setUp(self):
from flask import Flask
from flask_appbuilder import AppBuilder
from flask_appbuilder.models.mongoengine.interface import MongoEngineInterface
from flask_appbuilder import ModelView
from flask_appbuilder.security.mongoengine.manager import SecurityManager
self.app = Flask(__name__)
self.app.jinja_env.undefined = jinja2.StrictUndefined
self.basedir = os.path.abspath(os.path.dirname(__file__))
self.app.config['MONGODB_SETTINGS'] = {'DB': 'test'}
self.app.config['CSRF_ENABLED'] = False
self.app.config['SECRET_KEY'] = 'thisismyscretkey'
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = MongoEngine(self.app)
self.appbuilder = AppBuilder(self.app, security_manager_class=SecurityManager)
class Model2View(ModelView):
datamodel = MongoEngineInterface(Model2)
list_columns = ['field_integer', 'field_float', 'field_string', 'field_method', 'group.field_string']
edit_form_query_rel_fields = {'group':[['field_string', FilterEqual, 'G2']]}
add_form_query_rel_fields = {'group':[['field_string', FilterEqual, 'G1']]}
add_exclude_columns = ['excluded_string']
class Model22View(ModelView):
datamodel = MongoEngineInterface(Model2)
list_columns = ['field_integer', 'field_float', 'field_string', 'field_method', 'group.field_string']
add_exclude_columns = ['excluded_string']
edit_exclude_columns = ['excluded_string']
show_exclude_columns = ['excluded_string']
class Model1View(ModelView):
datamodel = MongoEngineInterface(Model1)
related_views = [Model2View]
list_columns = ['field_string','field_file']
class Model1CompactView(CompactCRUDMixin, ModelView):
datamodel = MongoEngineInterface(Model1)
class Model1Filtered1View(ModelView):
datamodel = MongoEngineInterface(Model1)
base_filters = [['field_string', FilterStartsWith, 'a']]
class Model1MasterView(MasterDetailView):
datamodel = MongoEngineInterface(Model1)
related_views = [Model2View]
class Model1Filtered2View(ModelView):
datamodel = MongoEngineInterface(Model1)
base_filters = [['field_integer', FilterEqual, 0]]
class Model2GroupByChartView(GroupByChartView):
datamodel = MongoEngineInterface(Model2)
chart_title = 'Test Model1 Chart'
definitions = [
{
'group':'field_string',
'series':[(aggregate_sum,'field_integer',
aggregate_avg, 'field_integer',
aggregate_count,'field_integer')
]
}
]
class Model2DirectByChartView(DirectByChartView):
datamodel = MongoEngineInterface(Model2)
chart_title = 'Test Model1 Chart'
definitions = [
{
'group':'field_string',
'series':['field_integer','field_float']
}
]
class Model2DirectChartView(DirectChartView):
datamodel = MongoEngineInterface(Model2)
chart_title = 'Test Model1 Chart'
direct_columns = {'stat1': ('group', 'field_integer')}
class Model1MasterView(MasterDetailView):
datamodel = MongoEngineInterface(Model1)
related_views = [Model2View]
class Model1MasterChartView(MasterDetailView):
datamodel = MongoEngineInterface(Model1)
related_views = [Model2DirectByChartView]
self.appbuilder.add_view(Model1View, "Model1", category='Model1')
self.appbuilder.add_view(Model1CompactView, "Model1Compact", category='Model1')
self.appbuilder.add_view(Model1MasterView, "Model1Master", category='Model1')
self.appbuilder.add_view(Model1MasterChartView, "Model1MasterChart", category='Model1')
self.appbuilder.add_view(Model1Filtered1View, "Model1Filtered1", category='Model1')
self.appbuilder.add_view(Model1Filtered2View, "Model1Filtered2", category='Model1')
self.appbuilder.add_view(Model2View, "Model2")
self.appbuilder.add_view(Model22View, "Model22")
self.appbuilder.add_view(Model2View, "Model2 Add", href='/model2view/add')
self.appbuilder.add_view(Model2GroupByChartView, "Model2 Group By Chart")
self.appbuilder.add_view(Model2DirectByChartView, "Model2 Direct By Chart")
self.appbuilder.add_view(Model2DirectChartView, "Model2 Direct Chart")
role_admin = self.appbuilder.sm.find_role('Admin')
try:
self.appbuilder.sm.add_user('admin', 'admin', 'user', '*****@*****.**', role_admin, 'general')
except:
pass
from flask_jwt_extended.jwt_manager import JWTManager
from flask_restful import Api
from flask_pymongo import pymongo
from flask_mongoengine import MongoEngine
from api.routers import create_route
config = {
'JSON_SORT_KEYS': False,
'MONGODB_SETTINGS': {
'host':
'mongodb+srv://borrowDB:[email protected]/myFirstDatabase?retryWrites=true&w=majority'
},
'JWT_SECRET_KEY': '&F)J@NcRfUjXn2r5u7x!A%D*G-KaPdSg',
'JWT_ACCESS_TOKEN_EXPIRES': 300,
'JWT_REFRESH_TOKEN_EXPIRES': 604800
}
app = Flask(__name__)
app.config.update(config)
api = Api(app)
db = MongoEngine(app=app)
create_route(api=api)
jwt = JWTManager(app=app)
CORS(app, resources={r"/*": {"origin": "*"}})
if __name__ == '__main__':
app.run(debug=True, use_reloader=True)
from datetime import datetime
from flask_mongoengine import MongoEngine
from mongoengine import DateTimeField, Document, StringField
image_db = MongoEngine()
class PicBed(Document):
img_id = StringField(max_length=16, required=True)
img_name = StringField(max_length=32, required=True)
orig_img_name = StringField(required=True)
created_time = DateTimeField(default=datetime.utcnow())
meta = {
"collection": "images",
"indexes": ["img_id", "orig_img_name", ("img_id", "img_name")]
}
def __repr__(self):
return "<%s(img_id=%s, img_name=%s)>" % (self.__class__.__name__,
self.img_id, self.img_name)
#!/usr/bin/python
# coding=utf-8
from flask import Flask
from flask_restful import Resource, Api
from flask_mongoengine import MongoEngine
import config
web_site = Flask(__name__)
api = Api(web_site)
db = MongoEngine(web_site)
subapps = config.INSTALL_APPS
for app in subapps:
api.add_resource(TApi, '/<string:id>')
def create_app(config=None):
app = Flask(__name__)
# read .envs and configuration class
app = read_env(app, config)
app.secret_key = app.config.get('SECRET_KEY')
# define logging patterns
import logging # %(pathname)
if app.config.get("TESTING"):
log_format = ("[%(asctime)s] %(funcName)s:%(lineno)d "
"%(levelname)s - %(message)s")
log_level = logging.DEBUG
else:
log_format = ("[%(asctime)s] {%(filename)s#%(funcName)s:%(lineno)d} "
"%(levelname)s - %(message)s")
log_level = logging.INFO
formatter = logging.Formatter(log_format)
handler = logging.StreamHandler()
handler.setLevel(log_level)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
app.logger.setLevel(log_level)
# remove default Flask debug handler
del app.logger.handlers[0]
# setup apps
from flask_debugtoolbar import DebugToolbarExtension
from flask_mongoengine import MongoEngine
from flask_bcrypt import Bcrypt
from flask_rq2 import RQ
from flask_restful import Api
from flask_login import LoginManager
DebugToolbarExtension(app)
MongoEngine(app)
Bcrypt(app)
RQ(app)
api = Api(app)
login_manager = LoginManager(app)
# register view blueprints
from project.home.views import app_blueprint
from project.admin.views import admin_blueprint
from project.user.views import user_blueprint
app.register_blueprint(app_blueprint)
app.register_blueprint(admin_blueprint)
app.register_blueprint(user_blueprint)
# register api endpoints
from .api import Resources, API_VERSION
for resource, url in Resources:
_endpoint = ".".join(API_VERSION.format(url).split("/")[1:-1])
api.add_resource(resource, API_VERSION.format(url), endpoint=_endpoint)
# import custom login manager functions
from project.home.login_manager import load_user_from_request, load_user
login_manager.login_view = "user.login"
login_manager.user_loader(load_user)
login_manager.request_loader(load_user_from_request)
# jinja extensions
app.jinja_env.add_extension('jinja2.ext.do')
# default flashed messages category
login_manager.login_message_category = 'info'
login_manager.needs_refresh_message_category = 'info'
return app
from flask import Flask
from flask_pymongo import PyMongo
from flask_mongoengine import MongoEngine
mongo = PyMongo()
me = MongoEngine()
def create_app():
app = Flask(__name__)
'''
app.config['SQLALCHEMY_DATABASE_URI'] = \
'postgresql+psycopg2://likit@localhost/healthdw_dev'
'''
app.config['MONGO_DBNAME'] = 'health_services'
app.config['MONGODB_DB'] = 'health_services'
me.init_app(app)
mongo.init_app(app)
from api import healthservice_blueprint
app.register_blueprint(healthservice_blueprint, url_prefix='/api')
return app
from flask import Flask
from flask import render_template
from flask_mongoengine import MongoEngine
from flask_mongoengine import MongoEngineSessionInterface
app = Flask(__name__)
app.config.from_object("knife.config.EnvConfig")
engine = MongoEngine(app)
app.session_interface = MongoEngineSessionInterface(engine)
@app.route("/")
def index():
return "test"
def create_app(is_sentry_on=False, **kwargs):
app = Flask(__name__)
app.config.update(kwargs or {})
db = MongoEngine()
CORS(app)
if 'TESTING' in kwargs and kwargs['TESTING']:
app.testing = True
db.init_app(
app, {
'MONGODB_SETTINGS': {
'db':
'testing',
'host':
'mongodb://*****:*****@ds111876.mlab.com:11876/testing'
}
})
# db.connection
else:
app.config['MONGODB_SETTINGS'] = {
'db':
'cheapbookdev',
'host':
'mongodb://*****:*****@ds053305.mlab.com:53305/cheapbookdev'
}
db.init_app(app)
import models
configs = models.Config.objects.get(config_id='initials')
app.config.from_object(configs)
app.config['DEBUG'] = False
mail = flask_mail.Mail()
mail.init_app(app=app)
if is_sentry_on:
sentry = Sentry(
dsn=
'https://*****:*****@sentry.io/177217'
)
sentry.init_app(app)
flask_mobility.Mobility().init_app(app=app)
from utils.exception_handler import error_dict, Handler
for e in error_dict:
app.register_error_handler(e, Handler(e).generate_response)
from utils.exceptions import general_exceptions
# @app.errorhandler(404)
# @app.errorhandler(401)
@app.errorhandler(500)
@json_response
def page_not_found_500(error):
print(error)
return general_exceptions.BASIC_ERROR_500
@app.errorhandler(404)
@json_response
def page_not_found_404(error):
print(error)
return general_exceptions.BASIC_ERROR_500
@app.before_request
def before_request():
request_data = save_request(request)
global_storage.request_data = request_data
@app.after_request
def after_request(resp):
resp_data = save_response(resp)
request_data = global_storage.request_data
traffic = models.Traffic(request=request_data, response=resp_data)
traffic.save()
return resp
import URLs
routes = URLs.get_urls()
for model in dir(models):
temp_class = getattr(models, model)
if inspect.isclass(temp_class) and issubclass(
temp_class, models.base.BaseDocument):
print(temp_class.__name__)
app.url_map.converters[
temp_class.__name__] = temp_class.get_converter()
for route in routes:
imported_class = route['cls']
route_object = imported_class()
app.add_url_rule(route['route'],
view_func=route_object.dispatcher,
endpoint=route['endpoint'],
methods=['GET', 'POST', 'PUT', 'DELETE'])
return app
def mongoengine_setup(request, app, tmpdir, realdburl):
pytest.importorskip("flask_mongoengine")
from flask_mongoengine import MongoEngine
from mongoengine.fields import (
BooleanField,
DateTimeField,
IntField,
ListField,
ReferenceField,
StringField,
)
db_name = "flask_security_test_%s" % str(time.time()).replace(".", "_")
app.config["MONGODB_SETTINGS"] = {
"db": db_name,
"host": "mongomock://localhost",
"port": 27017,
"alias": db_name,
}
db = MongoEngine(app)
class Role(db.Document, RoleMixin):
name = StringField(required=True, unique=True, max_length=80)
description = StringField(max_length=255)
permissions = StringField(max_length=255)
meta = {"db_alias": db_name}
class User(db.Document, UserMixin):
email = StringField(unique=True, max_length=255)
fs_uniquifier = StringField(unique=True, max_length=64, required=True)
username = StringField(unique=True,
required=False,
sparse=True,
max_length=255)
password = StringField(required=False, max_length=255)
security_number = IntField(unique=True, required=False, sparse=True)
last_login_at = DateTimeField()
current_login_at = DateTimeField()
tf_primary_method = StringField(max_length=255)
tf_totp_secret = StringField(max_length=255)
tf_phone_number = StringField(max_length=255)
us_totp_secrets = StringField()
us_phone_number = StringField(max_length=255)
last_login_ip = StringField(max_length=100)
current_login_ip = StringField(max_length=100)
login_count = IntField()
active = BooleanField(default=True)
confirmed_at = DateTimeField()
roles = ListField(ReferenceField(Role), default=[])
meta = {"db_alias": db_name}
def tear_down():
with app.app_context():
User.drop_collection()
Role.drop_collection()
db.connection.drop_database(db_name)
request.addfinalizer(tear_down)
return MongoEngineUserDatastore(db, User, Role)
import functools
from . import config_env_list, version
_db = None
if os.environ.get('FANTASY_ACTIVE_DB', 'no') == 'yes':
from flask_sqlalchemy import SQLAlchemy
_db = SQLAlchemy()
pass
_doc_db = None
if os.environ.get('FANTASY_ACTIVE_DOC_DB', 'no') == 'yes':
from flask_mongoengine import MongoEngine
_doc_db = MongoEngine()
pass
def connect_celery(app, celery):
app.celery = celery
celery.conf.update(app.config)
class ContextTask(celery.Task):
def __call__(self, *args, **kwargs):
with app.app_context():
return self.run(*args, **kwargs)
celery.Task = ContextTask
pass
"""
Exports a function to create an instance of the Image Search app.
"""
import os
from connexion import FlaskApp
from flask import Flask, render_template
from flask_mongoengine import MongoEngine
from swagger_ui_bundle import swagger_ui_3_path
mongoengine = MongoEngine()
def create_app(testing=False):
"""
Creates an instance of the Image Search app.
"""
# create connexion app
connexion_options = {'swagger_path': swagger_ui_3_path}
connexion_app = FlaskApp(__name__,
specification_dir='./swagger',
options=connexion_options)
connexion_app.add_api('swagger.yml')
# get a reference to underlying flask app
app = connexion_app.app
# do this because we want to allow instance configs
app.config.root_path = app.instance_path
app.config["SQLALCHEMY_DATABASE_URI"] = chaos_db
app.config["SQLALCHEMY_BINDS"] = {"log_db": log_db}
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = sqlalchemy_track_modifications
app.config["SQLALCHEMY_POOL_SIZE"] = sqlalchemy_pool_size
app.config.update({"MONGODB_SETTINGS": {"host": mongo_uri}})
sentry = Sentry(app, dsn=sentry_dsn)
alert_sentry_client = Client(bussiness_alert_sentry_dsn)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
ma = Marshmallow(app)
api = Api(app)
mongo_db = MongoEngine(app)
redis_conn = redis.StrictRedis(
connection_pool=redis.ConnectionPool.from_url(
redis_url, charset="utf-8", decode_responses=True
)
)
@api.representation("application/json")
def output_json(data, code, headers):
msg_code = Msg.SUCCESS
msg = ""
if isinstance(data, int) and data in Msg.msg:
msg = Msg.msg[data]
msg_code = data
# -*- coding:utf-8 -*-
from flask import Flask, render_template
from flask_bootstrap import Bootstrap
from config import config
from flask_moment import Moment
from flask_mongoengine import MongoEngine
import datetime
bootstrap = Bootstrap()
moment = Moment()
mongo_db = MongoEngine()
# 自定义jinjia2的过滤器
def transform_timestamp(timestamp):
d = datetime.datetime.fromtimestamp(timestamp)
result = d.strftime("%Y-%m-%d")
return result
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
mongo_db.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from flask import Flask from flask_mongoengine import MongoEngine from config import Config app = Flask(__name__) app.config.from_object(Config) db = MongoEngine() db.init_app(app) from application import routes
SECRET_KEY = 'some secret'
MONGODB_SETTINGS = {
'db': 'neatflex',
'host': 'mongodb://localhost:27017/neatflex'
}
# Flask-User settings
USER_APP_NAME = "NeatFlex"
USER_ENABLE_EMAIL = False
USER_ENABLE_USERNAME = True
USER_REQUIRE_RETYPE_PASSWORD = False
application.config.from_object(__name__ + '.ConfigClass')
db = MongoEngine(application)
auth = HTTPBasicAuth()
class Movie(db.Document):
year = db.StringField()
imdbid = db.StringField()
title = db.StringField()
genre = db.ListField(db.StringField())
image = db.StringField()
class User(db.Document, UserMixin):
# User authentication information
username = db.StringField(default='')
password_hash = db.StringField()
from flask import Flask
from flask_cors import CORS
from flask_mongoengine import MongoEngine
from app.views.auth import router_auth
from app.views.main import router_main
from app.cron import cron
from uploader.views import router_uploader
app = Flask(__name__, instance_relative_config=True)
# config vars
app.config["BASE_PATH"] = "/susunjadwal/api"
app.config["SSO_UI_URL"] = "https://sso.ui.ac.id/cas2/"
app.config["SECRET_KEY"] = "password"
app.config["ACTIVE_PERIOD"] = "2018-2"
app.config["SSO_UI_FORCE_HTTPS"] = False
app.config["MAX_CONTENT_LENGTH"] = 2 * 1024 * 1024
# uploader
app.config['UPLOAD_FOLDER'] = "__files__"
app.config.from_pyfile("config.cfg")
app.register_blueprint(router_auth, url_prefix=app.config["BASE_PATH"])
app.register_blueprint(router_main, url_prefix=app.config["BASE_PATH"])
app.register_blueprint(router_uploader, url_prefix=app.config["BASE_PATH"])
app.register_blueprint(cron)
CORS(app)
MongoEngine(app)
from flask import Flask, Config
from flask_restx import Api
from flask_mongoengine import MongoEngine
from flask_security import Security, MongoEngineUserDatastore, \
auth_token_required
from flask_mail import Mail
from flask_cors import CORS
db = MongoEngine() # NOQA: E402
mail = Mail() # NOQA: E402
security = Security() # NOQA: E402
from muzapi.models import User, Role # NOQA: E402
user_datastore = MongoEngineUserDatastore(db, User, Role) # NOQA: E402
from muzapi.bp_site import muzlog_site # NOQA: E402
from muzapi.bp_api import muzlog_api # NOQA: E402
from muzapi.bp_cms import muzlog_cms # NOQA: E402
configuration = Config('/')
configuration.from_object('config.config')
def create_app(overrides={}):
app = Flask(__name__,
template_folder='../muzsite/templates',
static_folder='../muzsite/static')
configuration.update(overrides)
app.config.update(configuration)
