def setUp(self):
super(JSONAppTestCase, self).setUp()
self.app.config['MONGODB_DB'] = 'testing'
self.app.config['TESTING'] = True
self.app.config['TEMP_DB'] = True
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(self.app)
Todo.drop_collection()
self.Todo = Todo
@self.app.route('/')
def index():
return flask.jsonify(result=self.Todo.objects())
@self.app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return flask.jsonify(result=todo)
@self.app.route('/show/<id>/')
def show(id):
return flask.jsonify(result=self.Todo.objects.get_or_404(id=id))
self.db = db
def setUp(self):
super(BasicAppTestCase, self).setUp()
db = MongoEngine()
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
pub_date = db.DateTimeField(default=datetime.datetime.now)
db.init_app(self.app)
Todo.drop_collection()
self.Todo = Todo
@self.app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.objects)
@self.app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'],
text=form['text'])
todo.save()
return 'added'
@self.app.route('/show/<id>/')
def show(id):
todo = self.Todo.objects.get_or_404(id=id)
return '\n'.join([todo.title, todo.text])
self.db = db
def test_connection_kwargs(self):
"""Make sure additional connection kwargs work."""
# Figure out whether to use "MAX_POOL_SIZE" or "MAXPOOLSIZE" based
# on PyMongo version (former was changed to the latter as described
# in https://jira.mongodb.org/browse/PYTHON-854)
# TODO remove once PyMongo < 3.0 support is dropped
if pymongo.version_tuple[0] >= 3:
MAX_POOL_SIZE_KEY = 'MAXPOOLSIZE'
else:
MAX_POOL_SIZE_KEY = 'MAX_POOL_SIZE'
self.app.config['MONGODB_SETTINGS'] = {
'ALIAS': 'tz_aware_true',
'DB': 'flask_mongoengine_testing_tz_aware',
'TZ_AWARE': True,
'READ_PREFERENCE': ReadPreference.SECONDARY,
MAX_POOL_SIZE_KEY: 10,
}
db = MongoEngine()
db.init_app(self.app)
self.assertTrue(db.connection.codec_options.tz_aware)
self.assertEqual(db.connection.max_pool_size, 10)
self.assertEqual(
db.connection.read_preference,
ReadPreference.SECONDARY
)
def setUp(self):
super(JSONAppTestCase, self).setUp()
self.app.config['MONGODB_DB'] = 'test_db'
self.app.config['TESTING'] = True
self.app.json_encoder = DummyEncoder
db = MongoEngine()
db.init_app(self.app)
self.db = db
def get_db(database=None):
database = conf.MONGODB_DB
mongo = MongoEngine()
mongo.connect(
database,
host=conf.MONGODB_HOST,
port=conf.MONGODB_PORT,
username=conf.MONGODB_USER,
password=conf.MONGODB_PASSWD
)
return mongo
def setup():
app = Flask(__name__)
app.config['SECRET_KEY'] = '1'
app.config['CSRF_ENABLED'] = False
app.config['MONGODB_SETTINGS'] = {'DB': 'tests'}
db = MongoEngine()
db.init_app(app)
admin = Admin(app)
return app, db, admin
def setup():
app = Flask(__name__)
app.config["SECRET_KEY"] = "1"
app.config["CSRF_ENABLED"] = False
app.config["MONGODB_SETTINGS"] = {"DB": "tests"}
db = MongoEngine()
db.init_app(app)
admin = Admin(app)
return app, db, admin
def create_app():
db = MongoEngine()
app = Flask(__name__)
app.config.from_object(Config)
# flask_security config
user_datastore = MongoEngineUserDatastore(db, Users, Roles)
security = Security(app, user_datastore)
# do some init
db.init_app(app)
create_user_role(user_datastore, db)
return app
def test_multiple_connections(self):
"""Make sure establishing multiple connections to a standalone
MongoDB and switching between them works.
"""
db = MongoEngine()
self.app.config['MONGODB_SETTINGS'] = [
{
'ALIAS': 'default',
'DB': 'flask_mongoengine_test_db_1',
'HOST': 'localhost',
'PORT': 27017
},
{
'ALIAS': 'alternative',
'DB': 'flask_mongoengine_test_db_2',
'HOST': 'localhost',
'PORT': 27017
},
]
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
meta = {'db_alias': 'alternative'}
db.init_app(self.app)
Todo.drop_collection()
# Test saving a doc via the default connection
with switch_db(Todo, 'default') as Todo:
todo = Todo()
todo.text = "Sample"
todo.title = "Testing"
todo.done = True
s_todo = todo.save()
f_to = Todo.objects().first()
self.assertEqual(s_todo.title, f_to.title)
# Make sure the doc doesn't exist in the alternative db
with switch_db(Todo, 'alternative') as Todo:
doc = Todo.objects().first()
self.assertEqual(doc, None)
# Make sure switching back to the default connection shows the doc
with switch_db(Todo, 'default') as Todo:
doc = Todo.objects().first()
self.assertNotEqual(doc, None)
def setUp(self):
db = MongoEngine()
app = Flask("corrdb")
# app.config.MONGODB_SETTINGS = { 'db': 'corrdb', 'host': '0.0.0.0', 'port': 27017 }
print(app.config.db)
app.config.from_object({'db': 'corrdb', 'host': '0.0.0.0', 'port': 27017 })
app.logger_name = "corrdb.app"
# Flask-MongoEngine instance
db.init_app(app)
# Custom Converters
app.url_map.converters['objectid'] = ObjectIDConverter
app.run(debug='--no-debug', host='0.0.0.0', port=5000, threaded=True)
def setUp(self):
super(PaginationTestCase, self).setUp()
self.db_name = 'test_db'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
self.app.config['CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def create_app(app_name=None, blueprints=None):
"""Create the flask app."""
if app_name is None:
app_name = "cowrie_api"
if blueprints is None:
blueprints = DEFAULT_BLUEPRINTS
app = Flask(app_name)
configure_app(app)
configure_logging(app)
db = MongoEngine()
db.app = app
db.init_app(app)
configure_blueprints(app, blueprints)
return app
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = 'test_db'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
# For Flask-WTF < 0.9
self.app.config['CSRF_ENABLED'] = False
# For Flask-WTF >= 0.9
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def test_live_connection(self):
db = MongoEngine()
self.app.config['TEMP_DB'] = True
self.app.config['MONGODB_SETTINGS'] = {
'host' : 'localhost',
'port' : 27017
}
class Todo(db.Document):
title = db.StringField(max_length=60)
text = db.StringField()
done = db.BooleanField(default=False)
db.init_app(self.app)
Todo.drop_collection()
# Test persist
todo = Todo()
todo.text = "Sample"
todo.title = "Testing"
todo.done = True
s_todo = todo.save()
f_to = Todo.objects().first()
self.assertEqual(s_todo.title, f_to.title)
def test_connection_default(self):
self.app.config['MONGODB_SETTINGS'] = {}
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
self.app.config['TESTING'] = True
db = MongoEngine()
db.init_app(self.app)
class PaginationTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(PaginationTestCase, self).setUp()
self.db_name = 'test_db'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
self.app.config['CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
try:
self.db.connection.drop_database(self.db_name)
except Exception:
self.db.connection.client.drop_database(self.db_name)
def test_queryset_paginator(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
for i in range(42):
Post(title="post: %s" % i).save()
self.assertRaises(NotFound, Pagination, Post.objects, 0, 10)
self.assertRaises(NotFound, Pagination, Post.objects, 6, 10)
paginator = Pagination(Post.objects, 1, 10)
self._test_paginator(paginator)
def test_paginate_plain_list(self):
self.assertRaises(NotFound, Pagination, range(1, 42), 0, 10)
self.assertRaises(NotFound, Pagination, range(1, 42), 6, 10)
paginator = Pagination(range(1, 42), 1, 10)
self._test_paginator(paginator)
def test_list_field_pagination(self):
with self.app.test_request_context('/'):
db = self.db
class Post(db.Document):
title = db.StringField(required=True, max_length=200)
comments = db.ListField(db.StringField())
comment_count = db.IntField()
comments = ["comment: %s" % i for i in range(42)]
post = Post(title="post has comments", comments=comments,
comment_count=len(comments)).save()
# Check without providing a total
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10)
self._test_paginator(paginator)
# Check with providing a total (saves a query)
paginator = ListFieldPagination(Post.objects, post.id, "comments",
1, 10, post.comment_count)
self._test_paginator(paginator)
paginator = post.paginate_field('comments', 1, 10)
self._test_paginator(paginator)
def _test_paginator(self, paginator):
self.assertEqual(5, paginator.pages)
self.assertEqual([1, 2, 3, 4, 5], list(paginator.iter_pages()))
for i in [1, 2, 3, 4, 5]:
if i == 1:
self.assertRaises(NotFound, paginator.prev)
self.assertFalse(paginator.has_prev)
else:
self.assertTrue(paginator.has_prev)
if i == 5:
self.assertRaises(NotFound, paginator.next)
self.assertFalse(paginator.has_next)
else:
self.assertTrue(paginator.has_next)
if i == 3:
self.assertEqual([None, 2, 3, 4, None],
list(paginator.iter_pages(0, 1, 1, 0)))
self.assertEqual(i, paginator.page)
self.assertEqual(i - 1, paginator.prev_num)
self.assertEqual(i + 1, paginator.next_num)
# Paginate to the next page
if i < 5:
paginator = paginator.next()
from flask import Flask
from config import Config
from flask_mongoengine import MongoEngine, MongoEngineSessionInterface
from flask_swagger_ui import get_swaggerui_blueprint
app = Flask(__name__)
SWAGGER_URL = '/swagger'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
SWAGGER_URL,
'/static/api_swagger.yaml',
config={'app_name': "api-swagger"})
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
app.config.from_object(Config)
db = MongoEngine(app)
db.connect(**Config.MONGODB_SETTINGS)
app.session_interface = MongoEngineSessionInterface(db)
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',
serializer = URLSafeSerializer(app.secret_key)
# MongoDB settings
app.config['MONGODB_SETTINGS'] = {
'alias': 'registry',
'db': 'registry',
'host': '0.0.0.0',
'port': 27017,
'username': '******',
'password': '******'
}
# Build db connection with straight mongoengine
# mongo = connect('registry', host='mongodb://*****:*****@0.0.0.0:27017/registry', alias='registry-db')
mongo = MongoEngine(app)
registry = mongo.get_db('registry')
members = registry.member
# Initialize flask-login
login_manager = LoginManager(app)
# Define login and registation forms (for flask-login)
class LoginForm(form.Form):
name = fields.TextField(validators=[validators.DataRequired()])
class RegistrationForm(form.Form):
name = fields.TextField(validators=[validators.DataRequired()])
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)
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_login import LoginManager
from flask_jwt_extended import JWTManager
from flask_mongoengine import MongoEngine
from flask_cors import CORS
from flask_mail import Mail
from app.config import *
app = Flask(__name__)
if app.env == "development":
app.config.from_object(DevelopmentConfig)
else:
app.config.from_object(ProductionConfig)
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
db = MongoEngine(app)
login_manager = LoginManager(app)
login_manager.login_view = 'login'
jwt_manager = JWTManager(app)
mail = Mail(app)
from app import models
from app.API import bot, devices, mqtt, authAPI
"""
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
class WTFormsAppTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = "test_db"
self.app.config["MONGODB_DB"] = self.db_name
self.app.config["TESTING"] = True
# For Flask-WTF < 0.9
self.app.config["CSRF_ENABLED"] = False
# For Flask-WTF >= 0.9
self.app.config["WTF_CSRF_ENABLED"] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
try:
self.db.connection.drop_database(self.db_name)
except Exception:
self.db.connection.client.drop_database(self.db_name)
def test_binaryfield(self):
with self.app.test_request_context("/"):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({"binary": "1"}))
self.assertTrue(form.validate())
form.save()
def test_choices_coerce(self):
with self.app.test_request_context("/"):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.IntField(choices=CHOICES)
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill, 1)
def test_list_choices_coerce(self):
with self.app.test_request_context("/"):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_emailfield(self):
with self.app.test_request_context("/"):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def test_model_form(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
meta = {"allow_inheritance": True}
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
class TextPost(BlogPost):
email = db.EmailField(required=False)
lead_paragraph = db.StringField(max_length=200)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True, max_length=200)
interest = db.DecimalField(required=True)
# Create a text-based post
TextPostForm = model_form(
TextPost, field_args={"lead_paragraph": {"textarea": True}}
)
form = TextPostForm(
MultiDict(
{"title": "Using MongoEngine", "tags": ["mongodb", "mongoengine"]}
)
)
self.assertFalse(form.validate())
form = TextPostForm(
MultiDict(
{
"title": "Using MongoEngine",
"content": "See the tutorial",
"tags": ["mongodb", "mongoengine"],
}
)
)
self.assertTrue(form.validate())
form.save()
self.assertEqual(form.title.type, "StringField")
self.assertEqual(form.content.type, "TextAreaField")
self.assertEqual(form.lead_paragraph.type, "TextAreaField")
self.assertEqual(BlogPost.objects.first().title, "Using MongoEngine")
self.assertEqual(BlogPost.objects.count(), 1)
form = TextPostForm(
MultiDict(
{
"title": "Using Flask-MongoEngine",
"content": "See the tutorial",
"tags": ["flask", "mongodb", "mongoengine"],
}
)
)
self.assertTrue(form.validate())
form.save()
self.assertEqual(BlogPost.objects.count(), 2)
post = BlogPost.objects(title="Using Flask-MongoEngine").get()
form = TextPostForm(
MultiDict(
{
"title": "Using Flask-MongoEngine",
"content": "See the tutorial",
"tags-0": "flask",
"tags-1": "mongodb",
"tags-2": "mongoengine",
"tags-3": "flask-mongoengine",
}
),
instance=post,
)
self.assertTrue(form.validate())
form.save()
post = post.reload()
self.assertEqual(
post.tags, ["flask", "mongodb", "mongoengine", "flask-mongoengine"]
)
# Create a link post
LinkPostForm = model_form(LinkPost)
form = LinkPostForm(
MultiDict(
{
"title": "Using Flask-MongoEngine",
"url": "http://flask-mongoengine.org",
"interest": "0",
}
)
)
form.validate()
self.assertTrue(form.validate())
def test_model_form_only(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=["tags"])
form = BlogPostForm()
self.assertTrue(hasattr(form, "tags"))
self.assertFalse(hasattr(form, "posted"))
BlogPostForm = model_form(BlogPost, exclude=["posted"])
form = BlogPostForm()
self.assertTrue(hasattr(form, "tags"))
self.assertFalse(hasattr(form, "posted"))
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=["german sheppard", "wolfhound"])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(
DogOwner, field_args={"dog": {"queryset": Dog.large_objects}}
)
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(
DogOwner, field_args={"dog": {"allow_blank": True}}
)
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertFalse(form.dog.widget.multiple)
# Validate the options - should contain a dog (selected) and a
# blank option there should be an extra blank option.
choices = list(form.dog)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, "__None")
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dog.pk)
# Validate selecting one item
form = DogOwnerForm(MultiDict({"dog": dog.id}))
self.assertEqual(form.dog.data, dog)
# Validate selecting no item
form = DogOwnerForm(MultiDict({"dog": "__None"}), dog=dog)
self.assertEqual(form.dog.data, None)
def test_modelselectfield_multiple(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(
DogOwner, field_args={"dogs": {"allow_blank": True}}
)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate the options - both dogs should be selected and
# there should be an extra blank option.
choices = list(form.dogs)
self.assertEqual(len(choices), 3)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, "__None")
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dogs[0].pk)
self.assertTrue(choices[2].checked)
self.assertEqual(choices[2].data, dogs[1].pk)
# Validate selecting two items
form = DogOwnerForm(MultiDict({"dogs": [dog.id for dog in dogs]}))
self.assertEqual(form.dogs.data, dogs)
# Validate selecting none actually empties the list
form = DogOwnerForm(MultiDict({"dogs": "__None"}), dogs=dogs)
self.assertEqual(form.dogs.data, None)
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_modelradiofield(self):
with self.app.test_request_context("/"):
db = self.db
choices = (("male", "Male"), ("female", "Female"), ("other", "Other"))
class Poll(db.Document):
answer = db.StringField(choices=choices)
PollForm = model_form(Poll, field_args={"answer": {"radio": True}})
form = PollForm(answer=None)
self.assertTrue(form.validate())
self.assertEqual(form.answer.type, "RadioField")
self.assertEqual(form.answer.choices, choices)
def test_passwordfield(self):
with self.app.test_request_context("/"):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={"password": {"password": True}})
form = UserForm(password="******")
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_unique_with(self):
with self.app.test_request_context("/"):
db = self.db
class Item(db.Document):
owner_id = db.ObjectIdField(required=True)
owner_item_id = db.StringField(required=True, unique_with="owner_id")
Item.drop_collection()
object_id = bson.ObjectId()
Item(owner_id=object_id, owner_item_id="1").save()
try:
Item(owner_id=object_id, owner_item_id="1").save()
self.fail("Should have raised duplicate key error")
except Exception:
pass
self.assertEqual(1, Item.objects.count())
def test_sub_field_args(self):
with self.app.test_request_context("/"):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {
"lst": {
"label": "Custom Label",
"field_args": {
"widget": wtforms.widgets.HiddenInput(),
"label": "Hidden Input",
},
}
}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string(
"{{ custom_form.lst.label }}", custom_form=custom_form
)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string(
"{{ custom_form.lst }}", custom_form=custom_form
)
self.assertTrue("Hidden Input" in sub_label)
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context("/"):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_model_form_help_text(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(
required=True,
help_text="Some imaginative title to set the world on fire",
)
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(
form.title.description,
"Some imaginative title to set the world on fire",
)
def test_shared_field_args(self):
with self.app.test_request_context("/"):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {
"title": {"validators": [wtforms.validators.Regexp("test")]}
}
TitleOnlyForm = model_form(
BlogPost, field_args=shared_field_args, exclude=["content"]
)
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def test_embedded_model_form(self):
with self.app.test_request_context("/"):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
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
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)
from flask import Flask
from flask_mongoengine import MongoEngine
from apis import api
from config import get_config
app = Flask(__name__)
db = MongoEngine()
CONFIG = get_config()
db.connect(db=CONFIG["mongodb"]["db_name"],
username=CONFIG["mongodb"]["username"],
password=CONFIG["mongodb"]["password"],
host=CONFIG["mongodb"]["host"],
port=CONFIG["mongodb"]["port"],
authentication_source=CONFIG["mongodb"]["auth_source"])
api.init_app(app)
app.run(host="0.0.0.0", port=5000, debug=True)
#!/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>')
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()
widget = widgets.ListWidget(prefix_label=False)
option_widget = widgets.CheckboxInput()
# Configuration
basedir= os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__)
app.config['MONGODB_SETTINGS']={
'db': 'freelance',
'host': os.environ.get('MONGO_LOGIN'),
'port': 27017,
'username': '******',
'password': '******'
}
app.config['SECRET_KEY'] = 'very hard to guess string'
db = MongoEngine()
db.init_app(app)
bootstrap = Bootstrap(app)
migrate = Migrate(app,db)
#Database Classes
class User(db.DynamicDocument):
username = db.StringField()
password_hash = db.StringField()
role = db.StringField()
date_joined = db.DateField()
posts = db.ReferenceField('JobPost')
@property
def password(self):
raise AttributeError("Password is not a readable attribute")
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)
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"
class WTFormsAppTestCase(FlaskMongoEngineTestCase):
def setUp(self):
super(WTFormsAppTestCase, self).setUp()
self.db_name = 'test_db'
self.app.config['MONGODB_DB'] = self.db_name
self.app.config['TESTING'] = True
# For Flask-WTF < 0.9
self.app.config['CSRF_ENABLED'] = False
# For Flask-WTF >= 0.9
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = MongoEngine()
self.db.init_app(self.app)
def tearDown(self):
try:
self.db.connection.drop_database(self.db_name)
except Exception:
self.db.connection.client.drop_database(self.db_name)
def test_binaryfield(self):
with self.app.test_request_context('/'):
db = self.db
class Binary(db.Document):
binary = db.BinaryField()
BinaryForm = model_form(Binary)
form = BinaryForm(MultiDict({'binary': '1'}))
self.assertTrue(form.validate())
form.save()
def test_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.IntField(choices=CHOICES)
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill, 1)
def test_list_choices_coerce(self):
with self.app.test_request_context('/'):
db = self.db
CHOICES = ((1, "blue"), (2, "red"))
class MyChoices(db.Document):
pill = db.ListField(db.IntField(choices=CHOICES))
MyChoicesForm = model_form(MyChoices)
form = MyChoicesForm(MultiDict({"pill": "1"}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(MyChoices.objects.first().pill[0], 1)
def test_emailfield(self):
with self.app.test_request_context('/'):
db = self.db
class Email(db.Document):
email = db.EmailField(required=False)
EmailForm = model_form(Email)
form = EmailForm(instance=Email())
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertTrue(form.validate())
# Ensure required works
class Email(db.Document):
email = db.EmailField(required=True)
EmailForm = model_form(Email)
form = EmailForm(MultiDict({"email": ""}))
self.assertFalse("None" in "%s" % form.email)
self.assertFalse(form.validate())
def test_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
meta = {'allow_inheritance': True}
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
class TextPost(BlogPost):
email = db.EmailField(required=False)
lead_paragraph = db.StringField(max_length=200)
content = db.StringField(required=True)
class LinkPost(BlogPost):
url = db.StringField(required=True, max_length=200)
interest = db.DecimalField(required=True)
# Create a text-based post
TextPostForm = model_form(
TextPost,
field_args={'lead_paragraph': {'textarea': True}})
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'tags': ['mongodb', 'mongoengine']}))
self.assertFalse(form.validate())
form = TextPostForm(MultiDict({
'title': 'Using MongoEngine',
'content': 'See the tutorial',
'tags': ['mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEqual(form.title.type, 'StringField')
self.assertEqual(form.content.type, 'TextAreaField')
self.assertEqual(form.lead_paragraph.type, 'TextAreaField')
self.assertEquals(BlogPost.objects.first().title, 'Using MongoEngine')
self.assertEquals(BlogPost.objects.count(), 1)
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags': ['flask', 'mongodb', 'mongoengine']}))
self.assertTrue(form.validate())
form.save()
self.assertEquals(BlogPost.objects.count(), 2)
post = BlogPost.objects(title="Using Flask-MongoEngine").get()
form = TextPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'content': 'See the tutorial',
'tags-0': 'flask',
'tags-1': 'mongodb',
'tags-2': 'mongoengine',
'tags-3': 'flask-mongoengine',
}), instance=post)
self.assertTrue(form.validate())
form.save()
post = post.reload()
self.assertEqual(post.tags, ['flask', 'mongodb', 'mongoengine', 'flask-mongoengine'])
# Create a link post
LinkPostForm = model_form(LinkPost)
form = LinkPostForm(MultiDict({
'title': 'Using Flask-MongoEngine',
'url': 'http://flask-mongoengine.org',
'interest': '0',
}))
form.validate()
self.assertTrue(form.validate())
def test_model_form_only(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, max_length=200)
posted = db.DateTimeField(default=datetime.datetime.now)
tags = db.ListField(db.StringField())
BlogPost.drop_collection()
BlogPostForm = model_form(BlogPost, only=['tags'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
BlogPostForm = model_form(BlogPost, exclude=['posted'])
form = BlogPostForm()
self.assertTrue(hasattr(form, 'tags'))
self.assertFalse(hasattr(form, 'posted'))
def test_model_form_with_custom_query_set(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
breed = db.StringField()
@queryset_manager
def large_objects(cls, queryset):
return queryset(breed__in=['german sheppard', 'wolfhound'])
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
big_dogs = [Dog(breed="german sheppard"), Dog(breed="wolfhound")]
dogs = [Dog(breed="poodle")] + big_dogs
for dog in dogs:
dog.save()
BigDogForm = model_form(DogOwner, field_args={'dog': {'queryset': Dog.large_objects}})
form = BigDogForm(dog=big_dogs[0])
self.assertTrue(form.validate())
self.assertEqual(big_dogs, [d[1] for d in form.dog.iter_choices()])
def test_modelselectfield(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dog = db.ReferenceField(Dog)
DogOwnerForm = model_form(DogOwner, field_args={
'dog': {'allow_blank': True}
})
dog = Dog(name="fido")
dog.save()
form = DogOwnerForm(dog=dog)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dog.widget))
self.assertFalse(form.dog.widget.multiple)
# Validate the options - should contain a dog (selected) and a
# blank option there should be an extra blank option.
choices = list(form.dog)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, '__None')
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dog.pk)
# Validate selecting one item
form = DogOwnerForm(MultiDict({
'dog': dog.id,
}))
self.assertEqual(form.dog.data, dog)
# Validate selecting no item
form = DogOwnerForm(MultiDict({
'dog': u'__None',
}), dog=dog)
self.assertEqual(form.dog.data, None)
def test_modelselectfield_multiple(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner, field_args={
'dogs': {'allow_blank': True}
})
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=dogs)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate the options - both dogs should be selected and
# there should be an extra blank option.
choices = list(form.dogs)
self.assertEqual(len(choices), 3)
self.assertFalse(choices[0].checked)
self.assertEqual(choices[0].data, '__None')
self.assertTrue(choices[1].checked)
self.assertEqual(choices[1].data, dogs[0].pk)
self.assertTrue(choices[2].checked)
self.assertEqual(choices[2].data, dogs[1].pk)
# Validate selecting two items
form = DogOwnerForm(MultiDict({
'dogs': [dog.id for dog in dogs],
}))
self.assertEqual(form.dogs.data, dogs)
# Validate selecting none actually empties the list
form = DogOwnerForm(MultiDict({
'dogs': '__None',
}), dogs=dogs)
self.assertEqual(form.dogs.data, None)
def test_modelselectfield_multiple_initalvalue_None(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
dogs = [Dog(name="fido"), Dog(name="rex")]
for dog in dogs:
dog.save()
form = DogOwnerForm(dogs=None)
self.assertTrue(form.validate())
self.assertEqual(wtforms.widgets.Select, type(form.dogs.widget))
self.assertTrue(form.dogs.widget.multiple)
# Validate if both dogs are selected
choices = list(form.dogs)
self.assertEqual(len(choices), 2)
self.assertFalse(choices[0].checked)
self.assertFalse(choices[1].checked)
def test_modelradiofield(self):
with self.app.test_request_context('/'):
db = self.db
choices = (('male', 'Male'), ('female', 'Female'), ('other', 'Other'))
class Poll(db.Document):
answer = db.StringField(choices=choices)
PollForm = model_form(Poll, field_args={'answer': {'radio': True}})
form = PollForm(answer=None)
self.assertTrue(form.validate())
self.assertEqual(form.answer.type, 'RadioField')
self.assertEqual(form.answer.choices, choices)
def test_passwordfield(self):
with self.app.test_request_context('/'):
db = self.db
class User(db.Document):
password = db.StringField()
UserForm = model_form(User, field_args={'password': {'password': True}})
form = UserForm(password='******')
self.assertEqual(wtforms.widgets.PasswordInput, type(form.password.widget))
def test_unique_with(self):
with self.app.test_request_context('/'):
db = self.db
class Item (db.Document):
owner_id = db.ObjectIdField(required=True)
owner_item_id = db.StringField(required=True, unique_with='owner_id')
Item.drop_collection()
object_id = bson.ObjectId()
Item(object_id, owner_item_id="1").save()
try:
Item(object_id, owner_item_id="1").save()
self.fail("Should have raised duplicate key error")
except Exception:
pass
self.assertEqual(1, Item.objects.count())
def test_sub_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class TestModel(db.Document):
lst = db.ListField(db.StringField())
field_args = {'lst': {'label': 'Custom Label',
'field_args': {'widget': wtforms.widgets.HiddenInput(),
'label': "Hidden Input"}}}
CustomForm = model_form(TestModel, field_args=field_args)
custom_form = CustomForm(obj=TestModel(lst=["Foo"]))
list_label = flask.render_template_string("{{ custom_form.lst.label }}", custom_form=custom_form)
self.assertTrue("Custom Label" in list_label)
self.assertTrue("Hidden Input" not in list_label)
sub_label = flask.render_template_string("{{ custom_form.lst }}", custom_form=custom_form)
self.assertTrue("Hidden Input" in sub_label)
def test_modelselectfield_multiple_selected_elements_must_be_retained(self):
with self.app.test_request_context('/'):
db = self.db
class Dog(db.Document):
name = db.StringField()
def __unicode__(self):
return self.name
class DogOwner(db.Document):
dogs = db.ListField(db.ReferenceField(Dog))
DogOwnerForm = model_form(DogOwner)
fido = Dog(name="fido").save()
Dog(name="rex").save()
dogOwner = DogOwner(dogs=[fido])
form = DogOwnerForm(obj=dogOwner)
html = form.dogs()
m = re.search("<option selected .+?>(.*?)</option>", html)
self.assertTrue(m is not None, "Should have one selected option")
self.assertEqual("fido", m.group(1))
def test_model_form_help_text(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True, help_text="Some imaginative title to set the world on fire")
post = BlogPost(title="hello world").save()
BlogPostForm = model_form(BlogPost)
form = BlogPostForm(instance=post)
self.assertEqual(form.title.description, "Some imaginative title to set the world on fire")
def test_shared_field_args(self):
with self.app.test_request_context('/'):
db = self.db
class BlogPost(db.Document):
title = db.StringField(required=True)
content = db.StringField(required=False)
shared_field_args = {'title': {'validators': [
wtforms.validators.Regexp('test')
]}}
TitleOnlyForm = model_form(BlogPost, field_args=shared_field_args,
exclude=['content'])
BlogPostForm = model_form(BlogPost, field_args=shared_field_args)
# ensure shared field_args don't create duplicate validators
title_only_form = TitleOnlyForm()
self.assertEqual(len(title_only_form.title.validators), 2)
blog_post_form = BlogPostForm()
self.assertEqual(len(blog_post_form.title.validators), 2)
def test_embedded_model_form(self):
with self.app.test_request_context('/'):
db = self.db
class Content(db.EmbeddedDocument):
text = db.StringField()
lang = db.StringField(max_length=3)
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
tags = db.ListField(db.StringField(max_length=30))
content = db.EmbeddedDocumentField("Content")
PostForm = model_form(Post)
form = PostForm()
self.assertTrue("content-text" in "%s" % form.content.text)
from flask_sqlalchemy import SQLAlchemy
from flask_security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, login_required, current_user
from flask_security.utils import encrypt_password
import flask_admin
from flask_admin.contrib import sqla
from flask_mongoengine import MongoEngine
from flask_admin.contrib.mongoengine import ModelView
from flask_admin import helpers as admin_helpers
# Create Flask application
app = Flask(__name__)
app.config.from_pyfile('config.py')
# Creamos modelo relacional
db = SQLAlchemy(app)
#Creamos modelo
dbm = MongoEngine()
dbm.init_app(app)
# Define models
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))
)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
from flask_cors import CORS
from flask_mongoengine import MongoEngine
from flask_httpauth import HTTPBasicAuth
# Flask 实例
blog = Flask(__name__,
instance_relative_config=True,
static_folder = "../../dist/static",
template_folder= "../../dist")
# auth
auth = HTTPBasicAuth()
# 载入配置
blog.config.from_object('config')
blog.config.from_pyfile('config.py')
# 允许跨域
cors = CORS(blog, resource={"/api/*": {"origins": "*"}})
# 数据库初始化
db = MongoEngine()
db.init_app(blog)
# 所有路由由 vue 接管
@blog.route("/", defaults={'path': ''})
@blog.route('/<path:path>')
def catch_all(path):
return render_template("index.html")
from flask_mongoengine import MongoEngine
from bson import json_util, ObjectId
from flask_cors import CORS
import pymongo
from pymongo import MongoClient
HOST_NAME = 'localhost'
app = Flask(__name__)
CORS(app)
app.config['MONGODB_SETTINGS'] = {'host': '127.0.0.1', 'db': 'kumi'}
kumi_mongo_client = MongoClient('localhost', 27017)
kumi_db = kumi_mongo_client.kumi
db = MongoEngine()
db.init_app(app)
try:
db.get_db()
except pymongo.errors.OperationFailure as e:
print(e)
sys.exit(-1)
from models.course import course_api
app.register_blueprint(course_api)
app.secret_key = b'\xcc^\x91\xea\x17-\xd0W\x03\xa7\xf8J0\xac8\xc5' # move to different file later
# Database
def login_required(
"""
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)
from datetime import datetime
import mongoengine as me
from mongoengine import ListField, EmbeddedDocumentField, EmbeddedDocument
from mongoengine import *
from bson.objectid import ObjectId
app = Flask(__name__)
title = "Task-Manager"
heading = "Task-Manager"
app.config['MONGODB_SETTINGS'] = { # connection to databse
'db': 'mydb1',
'host': 'localhost',
'port': 27017
}
db = MongoEngine()
db.init_app(app) # creates the object of database connection
count = 1
user = None
admin = None
class Task(me.EmbeddedDocument): # creating database model
tid = me.IntField(default=0)
name = me.StringField(max_length=200, required=True)
desc = me.StringField(max_length=250, required=True)
comments = me.StringField(max_length=250, required=True)
priority = me.IntField(default=5)
date = me.DateTimeField(default=datetime.utcnow())
status = me.BooleanField(default=False)
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
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
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):
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
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# __author__ = "@netwookie"
# __credits__ = ["Rick Kauffman"]
# __license__ = "Apache2.0"
# __version__ = "1.0.0"
# __maintainer__ = "Rick Kauffman"
# __email__ = "*****@*****.**"
from flask import Flask
from flask_mongoengine import MongoEngine
db = MongoEngine()
def create_app(**config_overrides):
app = Flask(__name__)
app.config.from_pyfile('settings.py')
app.config['MONGODB_SETTINGS'] = {
'db': 'app_db',
'host': 'localhost',
'port': 27017,
'username': '******',
'password': '******',
'authentication_source': 'admin'
}
"""
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
# -*- 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)
import datetime
from flask import Flask
from flask_mongoengine import MongoEngine
db = MongoEngine()
app = Flask(__name__, static_url_path='/assets', static_folder='assets')
app.config['MONGODB_SETTINGS'] = {'DB': 'startup'}
db.init_app(app)
class Keyword(db.Document):
word = db.StringField(unique=True)
website = db.DictField()
weibo = db.DictField()
wechat = db.DictField()
facebook = db.DictField()
twitter = db.DictField()
instagram = db.DictField()
github = db.DictField()
created = db.DateTimeField()
updated = db.DateTimeField(default=datetime.datetime.now)
def save(self, *args, **kwargs):
if not self.created:
self.created = datetime.datetime.now()
self.updated = datetime.datetime.now()
return super(Keyword, self).save(*args, **kwargs)
def __unicode__(self):
return self.word
}
app.config["CELERY_BROKER_URL"] = "redis://{username}:{password}@{host}:{port}/{db}".format(
host=CONFIG.get("redis.host"),
port=CONFIG.get("redis.port"),
db=CONFIG.get("redis.db", 0),
username=CONFIG.get("redis.username", ""),
password=CONFIG.get("redis.password", ""),
)
app.config["CACHE_TYPE"] = "redis"
app.config["CACHE_REDIS_URL"] = app.config["CELERY_BROKER_URL"]
app.config["CACHE_DEFAULT_TIMEOUT"] = CONFIG.get("api.default_cache_times")
DB = MongoEngine(app)
CACHE = Cache(app)
CELERY = Celery(app.name, broker=app.config["CELERY_BROKER_URL"])
CELERY.conf.update(app.config)
@CELERY.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
from . import tasks
sender.add_periodic_task(
CONFIG.get("api.fetch_photos_delta"),
tasks.fetch_photos.s(),
name="Fetch photos",
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 get_db_connection(app):
app.config['MONGODB_HOST'] = DB_URI
db = MongoEngine()
db.init_app(app)
return db
try:
doc = self.get(*q_objs, **query)
return doc, False
except self._document.DoesNotExist:
query.update(defaults)
doc = self._document(**query)
if auto_save:
doc.save(write_options=write_options)
return doc, True
class QuokkaDocument(Document):
"""Abstract document with extra helpers in the queryset class"""
meta = {'abstract': True,
'queryset_class': QuokkaQuerySet}
class QuokkaDynamicDocument(DynamicDocument):
"""Abstract Dynamic document with extra helpers in the queryset class"""
meta = {'abstract': True,
'queryset_class': QuokkaQuerySet}
db = MongoEngine()
db.ListField = ListField
db.Document = QuokkaDocument
db.DynamicDocument = QuokkaDynamicDocument
def get_db(app):
db = getattr(g, '_database', None)
if db is None:
db = g._database = MongoEngine(app)
return db