def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
bcrypt.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
from core.users.routes import users
from core.posts.routes import posts
from core.main.routes import main
from core.finance.routes import finance
from core.errors.handlers import errors
app.register_blueprint(users)
app.register_blueprint(posts)
app.register_blueprint(main)
app.register_blueprint(finance)
app.register_blueprint(errors)
# flask admin setup
from core.models import User, Post, Transaction, MyAdminIndexView, MyModelView, WebsiteReturn
admin.init_app(app, index_view=MyAdminIndexView())
admin.add_view(MyModelView(User, db.session))
admin.add_view(MyModelView(Post, db.session))
admin.add_view(WebsiteReturn(name='Website', endpoint='website'))
# whoosh search function
import flask_whooshalchemy
flask_whooshalchemy.whoosh_index(app, Post)
return app
def create_web_app(**config):
app = create_app(**config)
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
with app.app_context():
from openspending.views import register_views
register_views(app)
from openspending.admin.routes import register_admin
flaskadmin = admin.Admin(app, name='FIND Admin')
#flaskadmin = Admin(app, url='/admin', name='admin2')
register_admin(flaskadmin, db)
from openspending.model import Dataset
from openspending.model.country import Country
whoosearch.whoosh_index(app, Dataset)
whoosearch.whoosh_index(app, Country)
from openspending.views.context import generate_csrf_token
app.jinja_env.globals['csrf_token'] = generate_csrf_token
from openspending.assets.assets import register_assets
register_assets(assets)
return app
def create_web_app(**config):
app = create_app(**config)
app.jinja_env.add_extension("pyjade.ext.jinja.PyJadeExtension")
with app.app_context():
from openspending.views import register_views
register_views(app)
from openspending.admin.routes import register_admin
flaskadmin = admin.Admin(app, name="FIND Admin")
# flaskadmin = Admin(app, url='/admin', name='admin2')
register_admin(flaskadmin, db)
from openspending.model import Dataset
from openspending.model.country import Country
whoosearch.whoosh_index(app, Dataset)
whoosearch.whoosh_index(app, Country)
from openspending.views.context import generate_csrf_token
app.jinja_env.globals["csrf_token"] = generate_csrf_token
from openspending.assets.assets import register_assets
register_assets(assets)
return app
def rebuild_index(model):
import whoosh
import flask_whooshalchemy
"""Rebuild search index of Flask-SQLAlchemy model"""
app.logger.info("Rebuilding {0} index...".format(model.__name__))
primary_field = model.pure_whoosh.primary_key_name
searchables = model.__searchable__
index_writer = flask_whooshalchemy.whoosh_index(app, model)
# Fetch all data
entries = model.query.all()
entry_count = 0
with index_writer.writer() as writer:
for entry in entries:
index_attrs = {}
for field in searchables:
index_attrs[field] = unicode(getattr(entry, field))
index_attrs[primary_field] = unicode(getattr(entry, primary_field))
writer.update_document(**index_attrs)
entry_count += 1
app.logger.info("Rebuilt {0} {1} search index entries.".format(
str(entry_count), model.__name__))
def create_app(config_name):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(app_config[config_name])
app.config.from_pyfile('config.py')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['DEBUG'] = True
app.config['WHOOSH_BASE'] = 'D:\CRUD'
Bootstrap(app)
db.init_app(app)
login_manager.init_app(app)
login_manager.login_message = "You must be logged in to access this page."
login_manager.login_view = "auth.login"
migrate = Migrate(app, db)
from models import Reports
wa.whoosh_index(app, Reports)
from models import Lives
wa.whoosh_index(app, Lives)
from models import Transports
wa.whoosh_index(app, Transports)
from models import Studios
wa.whoosh_index(app, Studios)
from models import Sngorders
wa.whoosh_index(app, Sngorders)
from .its import its as its_blueprint
app.register_blueprint(its_blueprint, url_prefix='/its')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .home import home as home_blueprint
app.register_blueprint(home_blueprint)
@app.errorhandler(403)
def forbidden(error):
return render_template('errors/403.html', title='Forbidden'), 403
@app.errorhandler(404)
def page_not_found(error):
return render_template('errors/404.html', title='Page Not Found'), 404
@app.errorhandler(500)
def internal_server_error(error):
return render_template('errors/500.html', title='Server Error'), 500
return app
def reindex():
""" Grant admin privileges to given user """
from openspending.core import db
from openspending.model import Dataset
from openspending.model.country import Country
index = whoo.whoosh_index(current_app, Dataset)
with index.writer() as writer:
for dataset in Dataset.all():
primary_field = dataset.pure_whoosh.primary_key_name
searchable = dataset.__searchable__
attrs = {}
for key in searchable:
try:
attrs[key] = unicode(getattr(dataset, key))
except AttributeError:
raise AttributeError(
'{0} does not have {1} field {2}'.format(
"Dataset", __searchable__, key))
attrs[primary_field] = unicode(getattr(dataset, primary_field))
writer.update_document(**attrs)
#make sure we ahve all of the geometry tables in there
createCountries(silent=True)
index = whoo.whoosh_index(current_app, Country)
with index.writer() as writer:
for country in Country.all():
primary_field = country.pure_whoosh.primary_key_name
searchable = country.__searchable__
attrs = {}
for key in searchable:
try:
attrs[key] = unicode(getattr(country, key))
except AttributeError:
raise AttributeError(
'{0} does not have {1} field {2}'.format(
"Country", __searchable__, key))
attrs[primary_field] = unicode(getattr(country, primary_field))
writer.update_document(**attrs)
def reindex():
""" Grant admin privileges to given user """
from openspending.core import db
from openspending.model import Dataset
from openspending.model.country import Country
index = whoo.whoosh_index(current_app, Dataset)
with index.writer() as writer:
for dataset in Dataset.all():
primary_field = dataset.pure_whoosh.primary_key_name
searchable = dataset.__searchable__
attrs = {}
for key in searchable:
try:
attrs[key] = unicode(getattr(dataset, key))
except AttributeError:
raise AttributeError('{0} does not have {1} field {2}'
.format("Dataset", __searchable__, key))
attrs[primary_field] = unicode(getattr(dataset, primary_field))
writer.update_document(**attrs)
#make sure we ahve all of the geometry tables in there
createCountries(silent=True)
index = whoo.whoosh_index(current_app, Country)
with index.writer() as writer:
for country in Country.all():
primary_field = country.pure_whoosh.primary_key_name
searchable = country.__searchable__
attrs = {}
for key in searchable:
try:
attrs[key] = unicode(getattr(country, key))
except AttributeError:
raise AttributeError('{0} does not have {1} field {2}'
.format("Country", __searchable__, key))
attrs[primary_field] = unicode(getattr(country, primary_field))
writer.update_document(**attrs)
def configure_extensions(app):
"""
Configures the Flask extensions for an app.
Args:
app: The Flask app object to initialize the extensions with.
"""
db.init_app(app)
lm.init_app(app)
cache.init_app(app, app.config)
markdown.init_app(app)
moment.init_app(app)
security.init_app(app, user_datastore)
whoosh_index(app, Post)
app.jinja_env.add_extension('jinja2.ext.do')
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config['default'])
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# app.config['SQLALCHEMY_ECHO'] = True
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
app.config['SIMPLEMDE_USE_CDN'] = True
app.config['SIMPLEMDE_JS_IIFE'] = True
# ------ APPLICATION FACTORY ----- #
db.init_app(app)
migrate.init_app(app, db)
bootstrap.init_app(app)
toolbar.init_app(app)
login_manager.init_app(app)
simplemde.init_app(app)
moment.init_app(app)
csrf.init_app(app)
Misaka(app,
fenced_code=True,
strikethrough=True,
tables=True,
highlight=True,
autolink=True,
no_intra_emphasis=True,
underline=True,
smartypants=True,
qoute=True)
from app.models import Entries # import local for whoosh index
wa.whoosh_index(app, Entries)
# ------- BLUEPRINTS --------------#
from .blog import blog as blog
app.register_blueprint(blog)
''' Blueprint was required after making the application factory.
As the app instance is created and configured at run time and thus the 'app'
has already created, you cannot access the 'app' after this. I.e. the app in app.route
is inaccessible: blueprints mitigate this.
'''
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
migrate.init_app(app, db)
from app.models import Project
w.whoosh_index(app, Project)
from app.models import User
w.whoosh_index(app, User)
#import and register blueprints here
from app.api import api
app.register_blueprint(api)
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
bcrypt.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
from lostandfound.users.routes import users
from lostandfound.items.routes import items
from lostandfound.errors.handlers import errors
from lostandfound.models import LostItem, FoundItem
wa.whoosh_index(app, LostItem)
wa.whoosh_index(app, FoundItem)
#register blueprints
app.register_blueprint(users)
app.register_blueprint(items)
app.register_blueprint(errors)
return app
def create_app(config_file):
app = Flask(__name__)
app.config.from_pyfile(config_file)
from app.models import db
db.app = app
db.init_app(app)
with app.app_context():
db.create_all()
if config_file == 'config_dev.py':
from app.models import User
admin_user = User("admin", "*****@*****.**", "Th1515NOT53cur3")
admin_user.is_admin = True
admin_user.zipcode = 80915
admin_user.viewable = True
db.session.add(admin_user)
db.session.commit()
app.register_blueprint(home)
app.register_blueprint(auth)
app.register_blueprint(market)
app.register_blueprint(comm)
app.register_blueprint(admin)
app.debug = True
from app.login_manager import lm
lm.init_app(app)
lm.login_view = 'auth.login'
lm.login_message = u"You must be logged in to access that page."
from app.email import mail
mail.init_app(app)
resize.init_app(app)
from app.models import Item
whooshalchemy.whoosh_index(app, Item)
toolbar = DebugToolbarExtension(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
configure_logging()
app.jinja_env.globals.update(slugify=slugify)
app.jinja_env.globals.update(truncate=truncate)
app.jinja_env.globals.update(url=ads.url)
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
configure_uploads(app, (ads, imgs, landings))
mail.init_app(app)
babel.init_app(app)
afla_manager.init_app(app)
from .models import Post
whoosh_index(app, Post)
from .aflafrettir import aflafrettir as afla_blueprint
from .auth import auth as auth_blueprint
from .admin import admin as admin_blueprint
from .rss import feed as feed_blueprint
app.register_blueprint(afla_blueprint)
app.register_blueprint(auth_blueprint, url_prefix='/auth')
app.register_blueprint(admin_blueprint, url_prefix='/admin')
app.register_blueprint(feed_blueprint, url_prefix='/feed')
from helpers.image import start_image_deletion_thread
#pylint: disable-msg=W0612
@app.before_first_request
def before_first_request():
start_image_deletion_thread()
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
configure_logging()
app.jinja_env.globals.update(slugify=slugify)
app.jinja_env.globals.update(truncate=truncate)
app.jinja_env.globals.update(url=ads.url)
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
configure_uploads(app, (ads, imgs, landings))
mail.init_app(app)
babel.init_app(app)
afla_manager.init_app(app)
from .models import Post
whoosh_index(app, Post)
from .aflafrettir import aflafrettir as afla_blueprint
from .auth import auth as auth_blueprint
from .admin import admin as admin_blueprint
from .rss import feed as feed_blueprint
app.register_blueprint(afla_blueprint)
app.register_blueprint(auth_blueprint, url_prefix='/auth')
app.register_blueprint(admin_blueprint, url_prefix='/admin')
app.register_blueprint(feed_blueprint, url_prefix='/feed')
from helpers.image import start_image_deletion_thread
#pylint: disable-msg=W0612
@app.before_first_request
def before_first_request():
start_image_deletion_thread()
return app
class Post(db.Model):
__searchable__ = ['title'], ['content']
post_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text(50))
content = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'))
def __repr__(self): # pragma: no cover
return '<Post %r>' % (self.content)
if enable_search:
whooshalchemy.whoosh_index(app, Post, User)
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)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
login_manager.init_app(app)
configure_uploads(app, photos)
pagedown.init_app(app)
from models import Knjige
whooshalchemy.whoosh_index(app, Knjige)
from main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
return app
def create_app(configname):
app = Flask(__name__)
login_manager.init_app(app)
app.config.from_object(config[configname])
bootstrap.init_app(app)
db.init_app(app)
csrf.init_app(app)
configure_uploads(app, (photos, audio))
# main blueprint
from main import main as main_blueprint
app.register_blueprint(main_blueprint)
# auth blueprint
from auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
#index searches
from .models import Song, Album
if enable_search:
flask_whooshalchemy.whoosh_index(app, Song)
flask_whooshalchemy.whoosh_index(app, Album)
return app
def rebuild_index(model):
primary_field = model.pure_whoosh.primary_key_name
searchables = model.__searchable__
index_writer = flask_whooshalchemy.whoosh_index(APP, model)
entries = model.query.all()
entry_count = 0
with index_writer.writer() as writer:
for entry in entries:
index_attrs = {}
for field in searchables:
index_attrs[field] = unicode(getattr(entry, field))
index_attrs[primary_field] = unicode(
getattr(entry, primary_field))
writer.update_document(**index_attrs)
entry_count += 1
print 'Rebuilt {0} {1} search index entries.'.format(str(entry_count),
model.__name__)
def rebuild_index(model):
"""Rebuild search index of Flask-SQLAlchemy model"""
log("Rebuilding {0} index...".format(model.__name__))
primary_field = model.pure_whoosh.primary_key_name
searchables = model.__searchable__
index_writer = flask_whooshalchemy.whoosh_index(app, model)
# Fetch all data
entries = model.query.all()
entry_count = 0
with index_writer.writer() as writer:
for entry in entries:
index_attrs = {}
for field in searchables:
index_attrs[field] = unicode(getattr(entry, field))
index_attrs[primary_field] = unicode(getattr(entry, primary_field))
writer.update_document(**index_attrs)
entry_count += 1
log("Rebuilt {0} {1} search index entries.".format(str(entry_count), model.__name__))
def create_web_app(**config):
app = create_app(**config)
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
with app.app_context():
from openspending.views import register_views
register_views(app)
from openspending.admin.routes import register_admin
register_admin(app, db)
from openspending.model import Dataset
from openspending.model.country import Country
from openspending.forum.forum.models import Category,Post,Topic,Forum
whoosearch.whoosh_index(app,Dataset)
whoosearch.whoosh_index(app, Country)
whoosearch.whoosh_index(app, Category)
whoosearch.whoosh_index(app, Post)
whoosearch.whoosh_index(app, Topic)
whoosearch.whoosh_index(app, Forum)
from openspending.views.context import generate_csrf_token
app.jinja_env.globals['csrf_token'] = generate_csrf_token
from openspending.assets.assets import register_assets
register_assets(assets)
configure_template_filters(app)
if os.environ.get("FLASK_DEBUGTOOLBAR", False):
toolbar = DebugToolbarExtension(app)
return app
from app import create_app import flask_whooshalchemy as whooshalchemy from app.models import Company, Product, Article, User from flask import request, abort, g from app.config import ProductionConfig from app.main.forms import SearchForm from app.users.forms import SubscribeForm from app.constants import Constants app = create_app() app.app_context().push() @app.before_request def before_request(): g.subscribe_form = SubscribeForm() if ProductionConfig.MAINTENANCE_MODE and not "static" in request.path: abort(Constants.MAINTENANCE_PAGE) elif ProductionConfig.COMING_SOON and not "static" in request.path: abort(Constants.COMING_SOON_PAGE) else: g.search_form = SearchForm() if __name__ == "__main__": whooshalchemy.whoosh_index(app, Company) whooshalchemy.whoosh_index(app, Product) whooshalchemy.whoosh_index(app, Article) whooshalchemy.whoosh_index(app, User) app.run(debug=True)
def configure_extensions(app):
"""Configures the extensions."""
# Flask-WTF CSRF
csrf.init_app(app)
# Flask-Plugins
plugin_manager.init_app(app)
# Flask-SQLAlchemy
db.init_app(app)
# Flask-Migrate
migrate.init_app(app, db)
# Flask-Mail
mail.init_app(app)
# Flask-Cache
cache.init_app(app)
# Flask-Debugtoolbar
debugtoolbar.init_app(app)
# Flask-Themes
themes.init_themes(app, app_identifier="flaskbb")
# Flask-And-Redis
redis_store.init_app(app)
# Flask-WhooshAlchemy
with app.app_context():
whoosh_index(app, Post)
whoosh_index(app, Topic)
whoosh_index(app, Forum)
whoosh_index(app, Category)
whoosh_index(app, User)
# Flask-Login
login_manager.login_view = app.config["LOGIN_VIEW"]
login_manager.refresh_view = app.config["REAUTH_VIEW"]
login_manager.anonymous_user = Guest
@login_manager.user_loader
def load_user(user_id):
"""Loads the user. Required by the `login` extension."""
user_instance = User.query.filter_by(id=user_id).first()
if user_instance:
return user_instance
else:
return None
login_manager.init_app(app)
# Flask-BabelEx
babel.init_app(app=app, default_domain=FlaskBBDomain(app))
@babel.localeselector
def get_locale():
# if a user is logged in, use the locale from the user settings
if current_user.is_authenticated and current_user.language:
return current_user.language
# otherwise we will just fallback to the default language
return flaskbb_config["DEFAULT_LANGUAGE"]
# Flask-Allows
allows.init_app(app)
allows.identity_loader(lambda: current_user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
return Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).order_by(
Post.timestamp.desc())
def __repr__(self): # pragma: no cover
return '<User %r>' % (self.nickname)
class Post(db.Model):
__searchable__ = ['body']
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
language = db.Column(db.String(5))
def __repr__(self): # pragma: no cover
return '<Post %r>' % (self.body)
if enable_search:
flask_whooshalchemy.whoosh_index(app, Post)
def __str__(self):
return str(self.username)
class Movies(db.Model):
__searchable__ = ['name', 'director']
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
imdb_score = db.Column(db.Numeric(2, 2), default=0.0)
popularity99 = db.Column(db.Numeric(2, 2), default=0.0)
director = db.Column(db.String(80), nullable=False)
def __str__(self):
index_service.register_class(Movies)
return str(self.name)
wb.whoosh_index(app, Movies)
class MovieGenre(db.Model):
MovieID = db.Column(db.Integer,
db.ForeignKey('movies.id'),
primary_key=True)
Genre = db.Column(db.String(20), primary_key=True)
def __str__(self):
return str(self.GenreID + str(self.MovieID))
db.create_all()
db.session.commit()
class Codes(db.Model):
__tablename__ = 'Codes'
__searchable__ = ['description', 'tags']
code_id = db.Column('code_id', db.Unicode, primary_key=True)
description = db.Column('description', db.Unicode)
tags = db.Column('tags', db.Unicode)
code = db.Column('code', db.Unicode)
def __init__(self, code_id, description, tags, code):
self.code_id = code_id
self.description = description
self.tags = tags
self.code = code
wa.whoosh_index(app, Codes)
@bp.route('/save', methods=['GET', 'POST'])
def save():
if request.method == 'POST':
if request.form.get('save'):
code = request.form.get('code')
tags = request.form.get('tags')
description = request.form.get('problem')
code_id = random_String()
temp = Codes(code_id, description, tags, code)
db.session.add(temp)
db.session.commit()
def configure_extensions(app):
"""Configures the extensions."""
# Flask-WTF CSRF
csrf.init_app(app)
# Flask-Plugins
plugin_manager.init_app(app)
# Flask-SQLAlchemy
db.init_app(app)
# Flask-Migrate
migrate.init_app(app, db)
# Flask-Mail
mail.init_app(app)
# Flask-Cache
cache.init_app(app)
# Flask-Debugtoolbar
debugtoolbar.init_app(app)
# Flask-Themes
themes.init_themes(app, app_identifier="flaskbb")
# Flask-And-Redis
redis_store.init_app(app)
# Flask-WhooshAlchemy
with app.app_context():
whoosh_index(app, Post)
whoosh_index(app, Topic)
whoosh_index(app, Forum)
whoosh_index(app, Category)
whoosh_index(app, User)
# Flask-Login
login_manager.login_view = app.config["LOGIN_VIEW"]
login_manager.refresh_view = app.config["REAUTH_VIEW"]
login_manager.login_message_category = app.config["LOGIN_MESSAGE_CATEGORY"]
login_manager.needs_refresh_message_category = \
app.config["REFRESH_MESSAGE_CATEGORY"]
login_manager.anonymous_user = Guest
@login_manager.user_loader
def load_user(user_id):
"""Loads the user. Required by the `login` extension."""
user_instance = User.query.filter_by(id=user_id).first()
if user_instance:
return user_instance
else:
return None
login_manager.init_app(app)
# Flask-BabelEx
babel.init_app(app=app, default_domain=FlaskBBDomain(app))
@babel.localeselector
def get_locale():
# if a user is logged in, use the locale from the user settings
if current_user.is_authenticated and current_user.language:
return current_user.language
# otherwise we will just fallback to the default language
return flaskbb_config["DEFAULT_LANGUAGE"]
# Flask-Allows
allows.init_app(app)
allows.identity_loader(lambda: current_user)
self.cost_price = cost_price
self.package_id = package_id
self.edit_log = edit_log
def __repr__(self):
return '<name {0}>'.format(self.order_status)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.String, primary_key = True)
name = db.Column(db.String, unique = True, nullable = False)
email = db.Column(db.String, unique = True, nullable = False)
password = db.Column(db.String, nullable = False)
role = db.Column(db.String, default = 'user')
def __init__(self, id, name = None, email = None, password = None, role = None, price_model = None):
self.id = id
self.name = name
self.email = email
self.password = password
self.role = role
def __repr__(self):
return '<User {0}>'.format(self.name)
if enable_search:
whooshalchemy.whoosh_index(app, Orders)
import flask_whooshalchemy as whooshalchemy from dataviva import app from models import Publication whooshalchemy.whoosh_index(app, Publication)
'id': self.id,
}
class Book(db.Model):
__searchable__ = ['name','description']
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(250))
price = db.Column(db.String(8))
author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
@property
def serialize(self):
return {
'name': self.name,
'description': self.description,
'id': self.id,
'price': self.price,
}
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(15), unique=True)
email = db.Column(db.String(50), unique=True)
password = db.Column(db.String(80))
db.create_all();
wa.whoosh_index(app, Book)
image_url=None, game_id=None, owner_id=None, *args):
super(Community, self).__init__(*args)
self.id = id
self.name = name
self.description = description
self.language = language
self.rules = rules
self.image_url = image_url
self.game_id = game_id
self.owner_id = owner_id
id = db.Column(db.String(128), primary_key = True)
# Attributes
name = db.Column(db.TEXT)
description = db.Column(db.TEXT)
language = db.Column(db.String(128))
rules = db.Column(db.TEXT)
image_url = db.Column(db.TEXT)
# Connection to other models
game_id = db.Column(db.Integer)
owner_id = db.Column(db.String)
# Allow indexing on models
wa.whoosh_index(application, User)
wa.whoosh_index(application, Game)
wa.whoosh_index(application, Team)
wa.whoosh_index(application, Community)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from app import create_app
from flask_script import Manager
from flask_migrate import MigrateCommand
import flask_whooshalchemy as whooshalchemy
from app.models import User, Question, Answer
app = create_app('production')
manager = Manager(app)
manager.add_command('db', MigrateCommand)
whooshalchemy.whoosh_index(app, Question) #初始化whoosh全文搜索索引
whooshalchemy.whoosh_index(app, Answer)
whooshalchemy.whoosh_index(app, User)
if __name__ == '__main__':
manager.run()
short_description = db.Column(db.String(140), index=True)
def __repr__(self):
return 'CodeProject %r \n short description: %r \n timestamp: %r \n github_link: %r \n download_link: %r \n name_no_spaces: %r \n datestring: %r \n' \
% (self.name,self.short_description, self.timestamp, self.github_link, self.download_link, self.name_no_spaces, self.date_string)
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
class Picture(db.Model):
id = db.Column(db.Integer, primary_key=True)
link = db.Column(db.String(150), index=True, unique=True)
foreign_id = db.Column(db.Integer, db.ForeignKey('code_project.id'))
def __repr__(self):
return '<Picture %r>' % (self.link)
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
# Enable search if running python 2
if enable_search:
whooshalchemy.whoosh_index(app, BlogPost)
whooshalchemy.whoosh_index(app, CodeProject)
def configure_extensions(app):
"""Configures the extensions."""
# Flask-Plugins
plugin_manager.init_app(app)
# Flask-SQLAlchemy
db.init_app(app)
# Flask-Migrate
migrate.init_app(app, db)
# Flask-Mail
mail.init_app(app)
# Flask-Cache
cache.init_app(app)
# Flask-Debugtoolbar
debugtoolbar.init_app(app)
# Flask-Themes
themes.init_themes(app, app_identifier="flaskbb")
# Flask-And-Redis
redis_store.init_app(app)
# Flask-WhooshAlchemy
with app.app_context():
whoosh_index(app, Post)
whoosh_index(app, Topic)
whoosh_index(app, Forum)
whoosh_index(app, Category)
whoosh_index(app, User)
# Flask-Login
login_manager.login_view = app.config["LOGIN_VIEW"]
login_manager.refresh_view = app.config["REAUTH_VIEW"]
login_manager.anonymous_user = Guest
@login_manager.user_loader
def load_user(user_id):
"""Loads the user. Required by the `login` extension."""
unread_count = db.session.query(db.func.count(PrivateMessage.id)).\
filter(PrivateMessage.unread,
PrivateMessage.user_id == user_id).subquery()
u = db.session.query(User, unread_count).filter(User.id == user_id).\
first()
if u:
user, user.pm_unread = u
return user
else:
return None
login_manager.init_app(app)
# Flask-BabelEx
babel.init_app(app=app, default_domain=FlaskBBDomain(app))
@babel.localeselector
def get_locale():
# if a user is logged in, use the locale from the user settings
if current_user.is_authenticated() and current_user.language:
return current_user.language
# otherwise we will just fallback to the default language
return flaskbb_config["DEFAULT_LANGUAGE"]
location_id = db.Column(db.Integer, db.ForeignKey('location.id'))
title = db.Column(db.String(30), nullable=False)
price_low = db.Column(db.Integer)
price_high = db.Column(db.Integer)
description = db.Column(db.Text)
create_time = db.Column(db.DateTime)
valid_time = db.Column(db.DateTime)
status = db.Column(db.SmallInteger)
phone = db.Column(db.String(40))
qq = db.Column(db.String(40))
def __repr__(self):
"""docstring for __repr__"""
return '<Buy id:%s user_id:%s title:%s>' % (self.id, self.user_id,
self.title)
class Token(db.Model, Serializer):
"""docstring for Token"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
confirm = db.Column(db.Integer, nullable=False)
create_time = db.Column(db.DateTime, nullable=False)
def __repr__(self):
"""docstring for __repr__"""
return '<Token user_id:%s confirm:%s create_time:%s>' % (self.user_id,
self.confirm, self.create_time)
whooshalchemy.whoosh_index(app, Sell)
whooshalchemy.whoosh_index(app, Buy)
self.C150_4_COMB_PRESENT = C150_4_COMB_PRESENT
self.COSTT4_COMB_PRESENT = COSTT4_COMB_PRESENT
self.WDRAW_ORIG_YR6_RT_PRESENT = WDRAW_ORIG_YR6_RT_PRESENT
self.NPT4_COMB_PRESENT = NPT4_COMB_PRESENT
self.PCTPELL_PRESENT = PCTPELL_PRESENT
self.RET_FT4_COMB_PRESENT = RET_FT4_COMB_PRESENT
self.RET_PT4_COMB_PRESENT = RET_PT4_COMB_PRESENT
self.ADJ_AVGFACSAL_PRESENT = ADJ_AVGFACSAL_PRESENT
self.ADJ_INEXPFTE_PRESENT = ADJ_INEXPFTE_PRESENT
self.PFTFTUG1_EF_PRESENT = PFTFTUG1_EF_PRESENT
self.PFTFAC_PRESENT = PFTFAC_PRESENT
self.fin_COMB_RET_RATE_PRESENT = fin_COMB_RET_RATE_PRESENT
self.rankp_MN_EARN_WNE_P6 = rankp_MN_EARN_WNE_P6
self.rankp_DEBT_MDN = rankp_DEBT_MDN
self.rankp_C150_4_COMB = rankp_C150_4_COMB
self.rankp_COSTT4_COMB = rankp_COSTT4_COMB
self.rankp_WDRAW_ORIG_YR6_RT = rankp_WDRAW_ORIG_YR6_RT
self.rankp_NPT4_COMB = rankp_NPT4_COMB
self.rankp_PCTPELL = rankp_PCTPELL
self.rankp_ADJ_AVGFACSAL = rankp_ADJ_AVGFACSAL
self.rankp_ADJ_INEXPFTE = rankp_ADJ_INEXPFTE
self.rankp_PFTFAC = rankp_PFTFAC
self.rankp_COMB_RET_RATE = rankp_COMB_RET_RATE
self.adm_pct = adm_pct
self.IF_SAT_PRESENT = IF_SAT_PRESENT
self.IF_ACT_PRESENT = IF_ACT_PRESENT
if enable_search:
whooshalchemy.whoosh_index(flask_app, School_details)
whooshalchemy.whoosh_index(flask_app, Wiki_summary)
from . import db
from . import app
from . import ma
import flask_whooshalchemy as wa
class Movie(db.Model):
__searchable__ = ['title', 'description']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
rating = db.Column(db.Integer)
description = db.Column(db.String(255))
wa.whoosh_index(app, Movie)
class Show(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200))
description = db.Column(db.String(1000))
class Season(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200))
total_episodes = db.Column(db.Integer)
show_id = db.Column(db.Integer, db.ForeignKey('show.id'))
show = db.relationship('Show', backref='seasons')
__searchable__ = ['name']
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
def __repr__(self):
return '<Book %r>' % self.name
flask_whooshalchemy.whoosh_index(app, Author)
flask_whooshalchemy.whoosh_index(app, Book)
AuthorFormBase = model_form(Author, base_class=Form, db_session=db.session)
BookFormBase = model_form(Book, base_class=Form, db_session=db.session)
class MultiCheckboxField(SelectMultipleField):
widget = widgets.ListWidget(prefix_label=False)
option_widget = widgets.CheckboxInput()
class AuthorForm(AuthorFormBase):
books = MultiCheckboxField(coerce=int)
class BookForm(BookFormBase):
class Operations(db.Model):
__tablename__ = 'operations'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer)
operation = db.Column(db.String(200))
timestamp = db.Column(db.TIMESTAMP)
class Rates(db.Model):
__tablename__ = 'rates'
__searchable__ = ['date', 'client', 'rate', 'origin', 'destination', 'type', 'terms', 'manager', 'comments']
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
date = db.Column(db.DateTime, default=datetime.datetime.now())
client = db.Column(db.String(100))
rate = db.Column(db.String(100))
origin = db.Column(db.String(100))
destination = db.Column(db.String(100))
capacity = db.Column(db.String(100))
type = db.Column(db.String(100))
terms = db.Column(db.String(500))
manager = db.Column(db.String(100))
comments = db.Column(db.String(500))
created_by = db.Column(db.Integer)
is_new = db.Column(db.Boolean)
taken_by = db.Column(db.Integer)
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
whooshalchemy.whoosh_index(app, Rates)
if not self.is_following(user):
self.followed.append(user)
return self
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
return self
def is_following(self, user):
return self.followed.filter(followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
return Post.query.join(followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).order_by(Post.timestamp.desc())
class Post(db.Model):
__searchable__ = ['body']
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(120))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post %r>' % self.body
whooshalchemy.whoosh_index(app, Post)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60))
description = db.Column(db.String(560))
sort = db.Column(db.Integer)
is_custom = db.Column(db.Integer)
parent_id = db.Column(db.Integer, db.ForeignKey('category.id'))
type = db.Column(db.Integer)
parrent = db.relationship('Category', remote_side=[id], backref='children')
# def __init__(self, name):
# self.name = name
def __init__(self, **kwargs):
super(Category, self).__init__(**kwargs)
def __repr__(self):
return self.name
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
cellphone = db.Column(db.String(30))
email = db.Column(db.String(120))
report = db.Column(db.String(1024))
if enable_search:
flask_whooshalchemy.whoosh_index(app, Post)
# Relationships
characters = db.relationship("Character", secondary=characters_books,
back_populates="books")
povCharacters = db.relationship("Character", secondary=characters_povbooks,
back_populates="povBooks")
def __init__(self, id="", name="", isbn="",
numberOfPages=0, publisher="", country="",
mediaType="", released=""):
self.id = id
self.name = name
self.isbn = isbn
self.numberOfPages = numberOfPages
self.publisher = publisher
self.country = country
self.mediaType = mediaType
self.released = released
def __repr__(self):
return "<Book %r>" % self.name
"""
Index the models for searching
with Whoosh
"""
flask_whooshalchemy.whoosh_index(app, Character)
flask_whooshalchemy.whoosh_index(app, House)
flask_whooshalchemy.whoosh_index(app, Book)
username = db.Column(db.String(164))
password_hash = db.Column(db.String(164))
book = db.relationship('Book', backref="user", lazy="dynamic")
@login_manager.user_loader
def load_user(user_id):
"""flask-login要求实现的用户加载回调函数
依据用户的unicode字符串的id加载用户"""
return User.query.get(int(user_id))
@property
def password(self):
"""将密码方法设为User类的属性"""
raise AttributeError('无法读取密码原始值!')
@password.setter
def password(self, password):
"""设置密码散列值"""
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
"""验证密码散列值"""
return check_password_hash(self.password_hash, password)
def __repr__(self):
return "%r :The instance of class User" % self.username
if enable_search:
whooshalchemy.whoosh_index(app, Book)
__tablename__ = 'Post'
__searchable__ = ['id','name']
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(30))
age= db.Column(db.VARCHAR(10))
gender=db.Column(db.VARCHAR(1))
school=db.Column(db.VARCHAR(10))
height=db.Column(db.Float(5,2))
health=db.Column(db.String(20))
blood=db.Column(db.VARCHAR(10))
db.create_all()
def __repr__(self):
return '{0}(title={1})'.format(self.__class__.__name__, self.name)
wa.whoosh_index(app,Post)
@app.route('/search',methods=['GET'])
def search(Post):
with app.test_request_context():
from flask import request# Do Expensive work
posts =Post.query.whoosh_search(request.args.get('query')). all()
return render_template('records.html',posts=posts)
class Donate(db.Model):
id=db.Column(db.Integer,primary_key=True,autoincrement=True)
name1=db.Column(db.String(100))
address=db.Column(db.String(100))
# ---------------------------------------------------------------------------------------------------
class Interview_question(db.Model):
id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
jobkey = jobkey = db.Column(db.String, db.ForeignKey('position.jobkey'), primary_key=True)
employer_name = db.Column(db.String, db.ForeignKey('position.employername'))
interview_round = db.Column(db.Integer)
question = db.Column(db.String)
solution = db.Column(db.String)
feedback = db.Column(db.String)
user = db.relationship(User, uselist=False, backref="application_status")
position = db.relationship(Position, uselist=False, backref="application_status")
def __init__(self, id, jobkey, employer_name, interview_round, queston, solution, feedback):
self.id = id
self.jobkey = jobkey
self.employer_name = employer_name
self.interview_round = interview_round
self.question = queston
self.solution = solution
self.feedback = feedback
def __repr__(self):
return '<Interview_question | accountid: %s, jobkey : %s, round: %d, question: %s>' \
% (self.id, self.jobkey, self.interview_round, self.question)
# ---------------------------------------------------------------------------------------------------
# create index for table: Position
whooshalchemy.whoosh_index(app, Position)
#判断python版本是否大于3.0, 大于3.0的版本还不能用Whoosh
if sys.version_info >= (3, 0):
enable_search = False
else:
enable_search = True
import flask_whooshalchemy as whooshalchemy
class Warehouseinfo(db.Model):
#__searchable__字段中包含数据库中所有能被搜索并被建立索引的字段
#即, "title"字段可以被全文搜索引擎搜索到
__tablename__ = 'warehouseinfo'
__searchable__ = ['title']
id = db.Column(db.String(100), primary_key=True)
title = db.Column(db.String(50))
author = db.Column(db.String(30))
tags = db.Column(db.String(100))
desc = db.Column(db.String(700))
imgurl = db.Column(db.String(250))
kmzurl = db.Column(db.String(250))
imgfile = db.Column(db.String(30))
kmzfile = db.Column(db.String(30))
other = db.Column(db.String(100))
if enable_search:
#whoosh_index()为Warehouseinfo模型初始化了全文搜索索引
#即, 为"title"初始化了全文搜索索引
whooshalchemy.whoosh_index(app, Warehouseinfo)
site = db.Column(db.String(200))
def __init__(self, title, picture, species, comment, by, uploaded, email,
country, site):
self.title = title
self.picture = picture
self.species = species
self.comment = comment
self.by = by
self.uploaded = uploaded
self.email = email
self.country = country
self.site = site
wa.whoosh_index(app, Sightings)
class Comments(db.Model):
_id = db.Column("id", db.Integer, primary_key=True)
post_id = db.Column(db.Integer)
comment = db.Column(db.String(300))
by = db.Column(db.String(100))
def __init__(self, post_id, comment, by):
self.post_id = post_id
self.comment = comment
self.by = by
@app.route("/")
def a(): from manage import app whooshalchemy.whoosh_index(app, Post)
subject = db.Column(db.VARCHAR(128), nullable=True)
place = db.Column(db.VARCHAR(128), nullable=True)
timing = db.Column(db.Date, nullable=False)
description = db.Column(db.VARCHAR(2048), nullable=True)
thumbnail = db.Column(db.BLOB, nullable=False)
photo = db.Column(db.BLOB, nullable=False)
# Relationship to follow with sqlalchemy
viewed_by = relationship("Popularity", backref="image")
def __repr__(self):
return '<Image %r %r>' % (self.photo_id, self.owner_name)
# Register indexes on images
whooshalchemy.whoosh_index(app, Image)
class Popularity(db.Model):
"""
ORM for the `popularity` table. This table stores a combination of photo_id/viewed_by for each
user that has viewed an image.
"""
__tablename__ = 'popularities'
# Columns
photo_id = db.Column(db.Integer,
ForeignKey('images.photo_id'),
primary_key=True,
nullable=False)
from app import app
from app.models import Post as Model
from flask_whooshalchemy import whoosh_index
"""
from app.models import <table to index> as Model. change <table to index> to the table you want indexed
atatime - the number of records to pull from the database at once
limitmb - "max" megabytes to use
procs - cores to use in parallel
"""
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
atatime = 512 # how many rows to load at a time
with app.app_context():
index = whoosh_index(app, Model) # Create a Whoosh index object
searchable = Model.__searchable__ # Import the fields we want indexed
print 'counting rows...'
total = int(Model.query.order_by(None).count()) # Count the number of rows
done = 0 # initialize the done variable
print 'total rows: {}'.format(total)
writer = index.writer(limitmb=10000, procs=16, multisegment=True) # Create the writer object
for p in Model.query.yield_per(atatime): # to batch results in sub-collections and yield them out partially (Save memory)
record = dict([(s, p.__dict__[s]) for s in searchable]) # create a dictionary of of the fields we are indexing with whoosh form the table
record.update({'id': unicode(p.id)}) # id is mandatory, or whoosh won't work
writer.add_document(**record) # write record to index database
done += 1 # update done variable
if done % atatime == 0:
print 'c {}/{} ({}%)'.format(done, total, round((float(done)/total)*100, 2)), # calculate percentage complete
print '{}/{} ({}%)'.format(done, total, round((float(done)/total)*100, 2)) # print completion
nullable=False)
#demo_email = db.Column(db.String(100), db.ForeignKey('demo.email', ondelete='CASCADE'), nullable=False)
def __init__(self, body, meeting_id, like_count):
self.body = body
self.timestamp = datetime.utcnow()
self.meeting_id = meeting_id
self.like_count = like_count # Or should it be just meeting.id instead of g.course.id?
def __repr__(self):
return '<Muddy %r>' % self.body
class EmailList(db.Model):
__tablename__ = 'email'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), index=True, nullable=False, unique=True)
def __init__(self, email):
self.email = email
def __repr__(self):
return '<Email %r>' % self.email
if enable_search:
whooshalchemy.whoosh_index(app, Course)
whooshalchemy.whoosh_index(app, Meeting)
whooshalchemy.whoosh_index(app, Muddy)
Post.timestamp.desc()) # order by date created
def __repr__(self):
return '<User {nickname}>'.format(nickname=self.nickname)
"""
defines a method for printing this object
"""
class Post(db.Model):
__searchable__ = ['body'] # used by whoosh
id = db.Column(db.Integer, primary_key=True) # Creates a primary key, integer column named ID
body = db.Column(db.String(140)) # Creates a column named body with type string, 140 char length
timestamp = db.Column(db.DateTime) # Creates a column named timestamp with type datetime
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
"""
Creates a ForeignKey linked to the id column in the user table (provided by the User class)
"""
def __repr__(self):
return '<Post {body}>'.format(body=self.body)
"""
defines a method for printing this object
"""
if enable_search: # checks to see if the enable search flag has been enabled
whooshalchemy.whoosh_index(app, Post) # indexes the database on the fields we need
# Bookmark model and related db columns
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
lesson_id = db.Column(db.Integer, db.ForeignKey('lesson.id'))
topic_id = db.Column(db.Integer, db.ForeignKey('topic.id'))
created_at = db.Column('created_at',
db.TIMESTAMP,
server_default=db.func.now())
# What gets printed in flask shell or yarn shell when
# querying Lessons
def __repr__(self):
return '<Bookmark {}>'.format(self.id, self.lesson_id, self.user_id,
self.topic_id, self.created_at)
@login.user_loader
def load_user(id):
return User.query.get(int(id))
wa.whoosh_index(app, User)
wa.whoosh_index(app, Role)
wa.whoosh_index(app, Topic)
wa.whoosh_index(app, Lesson)
wa.whoosh_index(app, Comment)
Rates = db.Column(db.Float(8), index=True, unique=False)
DownloadTimes = db.Column(db.Integer, index=True, unique=False)
ImplementedDate = db.Column(db.String(64), index=True, unique=False)
developer_tool_mapping = db.relationship('Developer_tool_map',
backref='tool',
lazy='dynamic')
keyword_tool_mapping = db.relationship('Keyword_tool_map',
backref='tool',
lazy='dynamic')
def __repr__(self):
return '<Tool %r>' % (self.NameString)
if enable_search:
whooshalchemy.whoosh_index(app, Tool)
class Developer(db.Model):
id = db.Column(db.Integer, primary_key=True)
NameString = db.Column(db.String(32), index=True, unique=False)
developer_tool_mapping = db.relationship('Developer_tool_map',
backref='developer',
lazy='dynamic')
def __repr__(self):
return '<Developer %r>' % (self.NameString)
class Keyword(db.Model):
id = db.Column(db.Integer, primary_key=True)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
return Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).order_by(
Post.timestamp.desc())
def __repr__(self): # pragma: no cover
return '<User %r>' % (self.nickname)
class Post(db.Model):
__searchable__ = ['body']
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
language = db.Column(db.String(5))
def __repr__(self):
return '<Post %r>' % (self.body)
if enable_search:
whooshalchemy.whoosh_index(app, Post)
def register_search_models(app):
whooshalchemy.whoosh_index(app, HrApplication)
