@expose('/')
def index(self):
return redirect(url_for('dashboard.index'))
admin = Admin(name='Apollo', index_view=AdminHome(name='Dashboard'))
babel = Babel()
cache = Cache()
db = SQLAlchemy(session_options={'expire_on_commit': False})
mail = Mail()
menu = Menu()
migrate = Migrate()
oauth = OAuth()
red = FlaskRedis()
security = Security()
gravatar = Gravatar(size=25, default="identicon", use_ssl=True)
sentry = Sentry(client_cls=ApolloRavenClient)
csrf = CSRFProtect()
debug_toolbar = DebugToolbarExtension() if fdt_available else None
uploads = UploadSet('uploads', DEFAULTS)
webpack = Webpack()
docs = FlaskApiSpec()
class Filter(object):
"""Enables filtering a queryset on one parameter. Several filters
can (and should) be combined into a `class`FilterSet, which can be
used to generate a form for receiving the necessary parameters for
filtering.
This base class doesn't do much, and will raise an exception if it's
from flask_compress import Compress
from flask_caching import Cache
from flask_babel import Babel, lazy_gettext as _l
from config import Config
db = SQLAlchemy() # flask-sqlalchemy
migrate = Migrate() # flask-migrate
login = LoginManager() # flask-login
login.login_view = 'auth.login'
login.login_message = _l('Please login to access this page.')
mail = Mail()
moment = Moment()
gravatar = Gravatar(app=None,
size=100,
rating='g',
default='robohash',
force_default=False,
force_lower=False,
use_ssl=True,
base_url=None)
bootstrap = Bootstrap() # flask-bootstrap
cache = Cache() # flask-caching
compress = Compress() # flask-compress
babel = Babel() # flask-babel
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
migrate.init_app(app, db)
from functools import wraps
from werkzeug.security import generate_password_hash, check_password_hash
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import relationship
from flask_login import UserMixin, login_user, LoginManager, login_required, current_user, logout_user
from forms import LoginForm, RegisterForm, CreatePostForm, CommentForm
from flask_gravatar import Gravatar
app = Flask(__name__)
app.config['SECRET_KEY'] = '8BYkEfBA6O6donzWlSihBXox7C0sKR6b'
ckeditor = CKEditor(app)
Bootstrap(app)
gravatar = Gravatar(app,
size=100,
rating='g',
default='retro',
force_default=False,
force_lower=False,
use_ssl=False,
base_url=None)
##CONNECT TO DB
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
class AdminLTE(object):
"""
Attributes:
app (flask.Flask): Application object.
manager (Manager): Manager for accessing AdminLTE features.
"""
def __init__(self, app=None):
self.app = app
self.manager = Manager()
self.flash = Flash()
self.gravatar = Gravatar(default='mp')
if app is not None:
self.init_app(app)
def init_app(self, app):
"""Initializes the extension."""
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions['adminlte_full'] = self
for name, value in DEFAULT_SETTINGS.items():
app.config.setdefault(name, value)
# assets.init_app(app)
self.gravatar.init_app(app)
self.manager.user_getter(self.user_getter)
self.manager.home_page = app.config['ADMINLTE_HOME_PAGE']
self.init_locale(app)
self.register_blueprint(app)
if not app.debug:
app.register_error_handler(HTTPException, self.error_page)
for name in filters.__all__:
app.jinja_env.filters.setdefault(name, getattr(filters, name))
@app.context_processor
def processors():
return dict(
adminlte=self.manager,
adminlte_user=self.manager.user,
ThemeColor=ThemeColor,
ThemeLayout=ThemeLayout,
)
if not hasattr(app.jinja_env, 'install_gettext_callables'):
app.jinja_env.add_extension('jinja2.ext.i18n')
app.jinja_env.install_null_translations(True)
def init_locale(self, app):
"""Initializes the manager to use locales."""
babel = app.extensions.get('babel')
if babel is not None:
self.manager.default_locale = str(babel.default_locale)
self.manager.locale_getter(lambda: babel.locale_selector_func and
babel.locale_selector_func())
else:
self.manager.default_locale = app.config.get(
'ADMINLTE_DEFAULT_LOCALE')
def error_page(self, err):
"""Page for all HTTP errors."""
template = f'adminlte_full/http_error_page.html'
context = {
'status_code': err.code,
'status_message': err.name,
'details': err.get_description(),
}
return render_template(template, **context), err.code
def register_blueprint(self, app):
"""Registers Blueprint."""
app.register_blueprint(
Blueprint('adminlte_full',
__name__,
static_folder='static',
template_folder=pkg_resources.resource_filename(
'adminlte_base', 'templates'),
static_url_path='/adminlte_full'))
def user_getter(self):
"""Returns the current user."""
return current_user, current_app.config['ADMINLTE_USER_MAPPING']
"""
Flask Web
"""
from flask import Flask, render_template
from flask_gravatar import Gravatar
from webtools import Settings, get_activities, get_users
settings = Settings()
app = Flask(__name__)
gravatar = Gravatar(app, size=128, rating='g', default='retro')
@app.route("/")
def index():
return render_template("index.html")
@app.route("/charts/")
def charts_view():
activities = get_activities(settings)
date_range = [] # list of dates for x axis
chart_series = {} # list of users with duration for y axis
for date in activities:
date_range.append(date)
for point in activities[date]:
if point['user'] not in chart_series:
chart_series[point['user']] = []
chart_series[point['user']].append(point['duration'])
return render_template("chart.html",
date_range=date_range,
app = Flask(__name__)
app.config["SECRET_KEY"] = os.getenv("FLASK_SECRET_KEY")
ckeditor = CKEditor(app)
Bootstrap(app)
# CONNECT TO DB
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///blog.sqlite3"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db = SQLAlchemy(app)
# GAVATAR
gravatar = Gravatar(
app,
size=100,
rating="g",
default="retro",
force_default=False,
force_lower=False,
use_ssl=False,
base_url=None,
)
# CONFIGURE TABLES
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(250), unique=True, nullable=False)
password = db.Column(db.String(250), nullable=False)
name = db.Column(db.String(250), nullable=False)
posts = relationship("BlogPost", back_populates="author")
comments = relationship("Comment", back_populates="author")
def test_constructor(self):
Gravatar(self.app)
def index():
"""Render and process the main browser window."""
# Register Gravatar module with the app only if required
if config.SHOW_GRAVATAR_IMAGE:
Gravatar(current_app,
size=100,
rating='g',
default='retro',
force_default=False,
use_ssl=True,
base_url=None)
# Check the browser is a supported version
# NOTE: If the checks here are updated, make sure the supported versions
# at https://www.pgadmin.org/faq/#11 are updated to match!
if config.CHECK_SUPPORTED_BROWSER:
browser_name, browser_known, version = _get_supported_browser()
if browser_name is not None:
msg = render_template(MODULE_NAME + "/browser.html",
version=version,
browser=browser_name,
known=browser_known)
flash(msg, 'warning')
# Get the current version info from the website, and flash a message if
# the user is out of date, and the check is enabled.
if config.UPGRADE_CHECK_ENABLED:
last_check = get_setting('LastUpdateCheck', default='0')
today = time.strftime('%Y%m%d')
if int(last_check) < int(today):
check_browser_upgrade()
store_setting('LastUpdateCheck', today)
auth_only_internal = False
auth_source = []
session['allow_save_password'] = True
if config.SERVER_MODE:
if session['auth_source_manager']['current_source'] == INTERNAL:
auth_only_internal = True
auth_source = session['auth_source_manager']['source_friendly_name']
if not config.MASTER_PASSWORD_REQUIRED and 'pass_enc_key' in session:
session['allow_save_password'] = False
response = Response(
render_template(MODULE_NAME + "/index.html",
username=current_user.username,
auth_source=auth_source,
is_admin=current_user.has_role("Administrator"),
logout_url=get_logout_url(),
requirejs=True,
basejs=True,
mfa_enabled=is_mfa_enabled(),
login_url=login_url,
_=gettext,
auth_only_internal=auth_only_internal))
# Set the language cookie after login, so next time the user will have that
# same option at the login time.
misc_preference = Preferences.module('misc')
user_languages = misc_preference.preference('user_language')
language = 'en'
if user_languages:
language = user_languages.get() or 'en'
domain = dict()
if config.COOKIE_DEFAULT_DOMAIN and\
config.COOKIE_DEFAULT_DOMAIN != 'localhost':
domain['domain'] = config.COOKIE_DEFAULT_DOMAIN
response.set_cookie("PGADMIN_LANGUAGE",
value=language,
path=config.COOKIE_DEFAULT_PATH,
secure=config.SESSION_COOKIE_SECURE,
httponly=config.SESSION_COOKIE_HTTPONLY,
samesite=config.SESSION_COOKIE_SAMESITE,
**domain)
return response
template_mode="bootstrap3",
index_view=HomeView())
# Debug toolbar
debug_toolbar = DebugToolbarExtension()
# CSRF protection
csrf = CSRFProtect()
# SQLAlchemy
db = SQLAlchemy(session_options={"autoflush": False})
# Flask gravatar
gravatar = Gravatar(
size=100,
rating="g",
default="retro",
force_default=False,
use_ssl=True,
base_url=None,
)
# Flask migrate
migrate = Migrate()
# Flask-User
user_manager = CustomUserManager(None, None, None)
# Celery
cel = FlaskCelery("opencve", include=["opencve.tasks"])
app.config["FLATPAGES_ROOT"] = "flatpages" app.config["FLATPAGES_EXTENSION"] = ".md" app.config.from_pyfile(os.environ["FLASK_CONFIG"]) r = redis.Redis.from_url(app.config["REDIS_URL"]) menu.Menu(app=app) github = GitHub(app) csrf = CSRFProtect(app) mail = Mail(app) pages = FlatPages(app) babel = Babel(app) gravatar = Gravatar(app, size=58, rating='g', default='mp', force_default=False, force_lower=False, use_ssl=True, base_url=None) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "users.login" from .sass import sass sass(app) if not app.debug and app.config["MAIL_UTILS_ERROR_SEND_TO"]: from .maillogger import build_handler app.logger.addHandler(build_handler(app))
# coding: utf-8
"""
ext
~~~
Good place for pluggable extensions.
:copyright: (c) 2015 by Roman Zaiev.
:license: BSD, see LICENSE for more details.
"""
from flask_debugtoolbar import DebugToolbarExtension
from flask_gravatar import Gravatar
from flask_login import LoginManager
from flask_sqlalchemy import SQLAlchemy
from flask_assets import Environment
db = SQLAlchemy()
assets = Environment()
login_manager = LoginManager()
gravatar = Gravatar(size=50)
toolbar = DebugToolbarExtension()
# Almost any modern Flask extension has special init_app()
# method for deferred app binding. But there are a couple of
# popular extensions that no nothing about such use case.
# Or, maybe, you have to use some app.config settings
# gravatar = lambda app: Gravatar(app, size=50)
def configure(app):
if app.config.get('GRAVATAR'):
try:
Gravatar(app, **app.config.get('GRAVATAR'))
except TypeError:
raise ImportError('You must install flask_gravatar')
def index():
"""Render and process the main browser window."""
# Register Gravatar module with the app only if required
if config.SHOW_GRAVATAR_IMAGE:
Gravatar(current_app,
size=100,
rating='g',
default='retro',
force_default=False,
use_ssl=True,
base_url=None)
# Check the browser is a support version
# NOTE: If the checks here are updated, make sure the supported versions
# at https://www.pgadmin.org/faq/#11 are updated to match!
if config.CHECK_SUPPORTED_BROWSER:
browser_name, browser_known, version = _get_supported_browser()
if browser_name is not None:
msg = render_template(MODULE_NAME + "/browser.html",
version=version,
browser=browser_name,
known=browser_known)
flash(msg, 'warning')
# Get the current version info from the website, and flash a message if
# the user is out of date, and the check is enabled.
if config.UPGRADE_CHECK_ENABLED:
check_browser_upgrade()
auth_only_internal = False
auth_source = []
if config.SERVER_MODE:
if len(config.AUTHENTICATION_SOURCES) == 1\
and 'internal' in config.AUTHENTICATION_SOURCES:
auth_only_internal = True
auth_source = session['_auth_source_manager_obj'][
'source_friendly_name']
response = Response(
render_template(MODULE_NAME + "/index.html",
username=current_user.username,
auth_source=auth_source,
is_admin=current_user.has_role("Administrator"),
logout_url=_get_logout_url(),
_=gettext,
auth_only_internal=auth_only_internal))
# Set the language cookie after login, so next time the user will have that
# same option at the login time.
misc_preference = Preferences.module('misc')
user_languages = misc_preference.preference('user_language')
language = 'en'
if user_languages:
language = user_languages.get() or 'en'
domain = dict()
if config.COOKIE_DEFAULT_DOMAIN and\
config.COOKIE_DEFAULT_DOMAIN != 'localhost':
domain['domain'] = config.COOKIE_DEFAULT_DOMAIN
response.set_cookie("PGADMIN_LANGUAGE",
value=language,
path=config.COOKIE_DEFAULT_PATH,
**domain)
return response
def index():
"""Render and process the main browser window."""
# Register Gravatar module with the app only if required
if config.SHOW_GRAVATAR_IMAGE:
Gravatar(
current_app,
size=100,
rating='g',
default='retro',
force_default=False,
use_ssl=True,
base_url=None
)
# Check the browser is a support version
# NOTE: If the checks here are updated, make sure the supported versions
# at https://www.pgadmin.org/faq/#11 are updated to match!
if config.CHECK_SUPPORTED_BROWSER:
browser = request.user_agent.browser
version = request.user_agent.version and int(
request.user_agent.version.split('.')[0])
browser_name = None
browser_known = True
if browser == 'chrome' and version < 72:
browser_name = 'Chrome'
elif browser == 'firefox' and version < 65:
browser_name = 'Firefox'
elif browser == 'edge' and version < 44:
browser_name = 'Edge'
elif browser == 'safari' and version < 12:
browser_name = 'Safari'
elif browser == 'msie':
browser_name = 'Internet Explorer'
elif browser != 'chrome' and browser != 'firefox' and \
browser != 'edge' and browser != 'safari':
browser_name = browser
browser_known = False
if browser_name is not None:
msg = render_template(
MODULE_NAME + "/browser.html",
version=version,
browser=browser_name,
known=browser_known
)
flash(msg, 'warning')
# Get the current version info from the website, and flash a message if
# the user is out of date, and the check is enabled.
if config.UPGRADE_CHECK_ENABLED:
data = None
url = '%s?version=%s' % (config.UPGRADE_CHECK_URL, config.APP_VERSION)
current_app.logger.debug('Checking version data at: %s' % url)
try:
# Do not wait for more than 5 seconds.
# It stuck on rendering the browser.html, while working in the
# broken network.
if os.path.exists(config.CA_FILE):
response = urlreq.urlopen(url, data, 5, cafile=config.CA_FILE)
else:
response = urlreq.urlopen(url, data, 5)
current_app.logger.debug(
'Version check HTTP response code: %d' % response.getcode()
)
if response.getcode() == 200:
data = json.loads(response.read().decode('utf-8'))
current_app.logger.debug('Response data: %s' % data)
except Exception:
current_app.logger.exception('Exception when checking for update')
if data is not None:
if data[config.UPGRADE_CHECK_KEY]['version_int'] > \
config.APP_VERSION_INT:
msg = render_template(
MODULE_NAME + "/upgrade.html",
current_version=config.APP_VERSION,
upgrade_version=data[config.UPGRADE_CHECK_KEY]['version'],
product_name=config.APP_NAME,
download_url=data[config.UPGRADE_CHECK_KEY]['download_url']
)
flash(msg, 'warning')
auth_only_internal = False
auth_source = []
if config.SERVER_MODE:
if len(config.AUTHENTICATION_SOURCES) == 1\
and 'internal' in config.AUTHENTICATION_SOURCES:
auth_only_internal = True
auth_source = session['_auth_source_manager_obj'][
'source_friendly_name']
response = Response(render_template(
MODULE_NAME + "/index.html",
username=current_user.username,
auth_source=auth_source,
is_admin=current_user.has_role("Administrator"),
logout_url=_get_logout_url(),
_=gettext,
auth_only_internal=auth_only_internal
))
# Set the language cookie after login, so next time the user will have that
# same option at the login time.
misc_preference = Preferences.module('misc')
user_languages = misc_preference.preference(
'user_language'
)
language = 'en'
if user_languages:
language = user_languages.get() or 'en'
domain = dict()
if config.COOKIE_DEFAULT_DOMAIN and\
config.COOKIE_DEFAULT_DOMAIN != 'localhost':
domain['domain'] = config.COOKIE_DEFAULT_DOMAIN
response.set_cookie("PGADMIN_LANGUAGE", value=language,
path=config.COOKIE_DEFAULT_PATH,
**domain)
return response
def test_init_app(self):
gravatar = Gravatar()
if hasattr(self.app, 'extensions'):
del self.app.extensions
gravatar.init_app(self.app)
from flask import Flask
from flask_mail import Mail
from flask_gravatar import Gravatar
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config.from_object('auth.config')
mail = Mail(app)
gravatar = Gravatar(app, use_ssl=True)
db = SQLAlchemy(app)
def test_parameters(self):
gravatar = Gravatar(self.app, force_lower=True)
assert gravatar('*****@*****.**') == gravatar('*****@*****.**',
force_lower=None)
import os
from redis import Redis
import rq
from flask_gravatar import Gravatar
from flask_babelex import Babel
app = Flask(__name__)
db = MongoEngine()
jsglue = JSGlue()
login = LoginManager()
login.login_view = 'auth.login'
login.login_message = 'Veuillez vous connecter pour accéder à cette page'
gravatar = Gravatar(size=100,
rating='g',
default='identicon',
force_default=False,
force_lower=False,
use_ssl=False,
base_url=None)
redis = Redis()
task_queue = rq.Queue('standard-tasks', connection=redis)
babel = Babel()
# photos = UploadSet('photos', IMAGES)
class HomeView(AdminIndexView):
@expose('/')
def index(self):
courriers_entrant = CourrierEntrant.objects.count()
def add_user_blueprint(app):
""" to the app.
"""
monkey_patch_email()
# https://pythonhosted.org/Flask-Security-Fork/customizing.html
from flask_security.forms import RegisterForm, ConfirmRegisterForm
from wtforms.fields import StringField
from wtforms.validators import Required, Regexp, Length
# https://flask-security-fork.readthedocs.io/en/latest/customizing.html#views
# https://flask-security-fork.readthedocs.io/en/latest/quickstart.html#id1
from flask_security import Security
monkey_patch_sqlstore(app)
def unique_user_name(form, field):
""" Make sure it is a unique user name.
"""
from wtforms import ValidationError
from pygameweb.user.models import User
user = (current_session.query(User).filter(
User.name == field.data).first())
if user is not None:
msg = f'{field.data} is already associated with an account.'
raise ValidationError(msg)
username_msg = 'Username must contain only letters numbers or underscore'
username_validators = [
Required(),
Regexp('^\w+$', message=username_msg),
Length(min=5,
max=25,
message='Username must be betwen 5 & 25 characters'),
unique_user_name,
]
class ExtendedRegisterForm(RegisterForm):
name = StringField('Username', username_validators)
title = StringField('Title (eg. Real name)', [Required()])
class ExtendedConfirmRegisterForm(ConfirmRegisterForm):
name = StringField('Username', username_validators)
title = StringField('Title (eg. Real name)', [Required()])
monkey_patch_email_field(ExtendedRegisterForm)
monkey_patch_email_field(ExtendedConfirmRegisterForm)
security = Security(app,
app.user_datastore,
register_form=ExtendedRegisterForm,
confirm_register_form=ExtendedConfirmRegisterForm)
from pygameweb.cache import limiter
limiter.limit("4/hour")(security.app.blueprints['security'])
# https://pypi.python.org/pypi/Flask-Gravatar
from flask_gravatar import Gravatar
Gravatar(app,
size=100,
rating='g',
default='retro',
force_default=False,
use_ssl=True,
base_url=None)
# http://flask-security-fork.readthedocs.io/en/latest/api.html#signals
from flask_security import user_confirmed, user_registered
@user_confirmed.connect_via(app)
def when_the_user_is_confirmed(app, user):
""" we can add a newbie role.
"""
# we add a newbie role, once the user confirms their email.
default_role = app.user_datastore.find_role("newbie")
app.user_datastore.add_role_to_user(user, default_role)
# TODO: After a couple of hours we can add a 'member' role.
# The idea with this magic spell would be to ward off spam a bit.
member_role = app.user_datastore.find_role("members")
app.user_datastore.add_role_to_user(user, member_role)
current_session.commit()
@user_registered.connect_via(app)
def when_user_is_registered(app, user, confirm_token):
""" we log their ip address so as to try and block spammers.
"""
remote_addr = request.remote_addr or None
user.registered_ip = remote_addr
current_session.add(user)
current_session.commit()
app.register_blueprint(user_blueprint)
import os
from datetime import date, datetime
from flask import Blueprint, g, redirect, render_template, request, url_for
from flask_babel import gettext
from flask_gravatar import Gravatar
from main import app, flash_error, flash_success
from main.decorators import auth_required
from main.forms import AuthForm, ContactForm, ResetPasswordConfirmForm, ResetPasswordForm
from main.models import Application, AuthModel, ContactModel, InitPasswordResetModel, PasswordResetModel
gravatar = Gravatar(app)
front = Blueprint('front', __name__, url_prefix='/<any(pl, en, ru, ""):lang_code>')
@front.url_defaults
def add_language_code(endpoint, values):
values.setdefault('lang_code', g.lang_code)
@front.url_value_preprocessor
def pull_lang_code(endpoint, values):
g.lang_code = values.pop('lang_code')
@app.template_filter('age')
def age(birth_date):
birth_date = datetime.strptime(birth_date, '%Y-%m-%d')
return int((date.today() - birth_date.date()).days / 365.2425)
def index():
"""Render and process the main browser window."""
# Register Gravatar module with the app only if required
if config.SHOW_GRAVATAR_IMAGE:
Gravatar(
current_app,
size=100,
rating='g',
default='retro',
force_default=False,
use_ssl=True,
base_url=None
)
# Get the current version info from the website, and flash a message if
# the user is out of date, and the check is enabled.
if config.UPGRADE_CHECK_ENABLED:
data = None
url = '%s?version=%s' % (config.UPGRADE_CHECK_URL, config.APP_VERSION)
current_app.logger.debug('Checking version data at: %s' % url)
try:
# Do not wait for more than 5 seconds.
# It stuck on rendering the browser.html, while working in the
# broken network.
if os.path.exists(config.CA_FILE):
response = urlreq.urlopen(url, data, 5, cafile=config.CA_FILE)
else:
response = urlreq.urlopen(url, data, 5)
current_app.logger.debug(
'Version check HTTP response code: %d' % response.getcode()
)
if response.getcode() == 200:
data = json.loads(response.read().decode('utf-8'))
current_app.logger.debug('Response data: %s' % data)
except Exception:
current_app.logger.exception('Exception when checking for update')
if data is not None:
if data[config.UPGRADE_CHECK_KEY]['version_int'] > \
config.APP_VERSION_INT:
msg = render_template(
MODULE_NAME + "/upgrade.html",
current_version=config.APP_VERSION,
upgrade_version=data[config.UPGRADE_CHECK_KEY]['version'],
product_name=config.APP_NAME,
download_url=data[config.UPGRADE_CHECK_KEY]['download_url']
)
flash(msg, 'warning')
response = Response(render_template(
MODULE_NAME + "/index.html",
username=current_user.email,
is_admin=current_user.has_role("Administrator"),
_=gettext
))
# Set the language cookie after login, so next time the user will have that
# same option at the login time.
misc_preference = Preferences.module('miscellaneous')
user_languages = misc_preference.preference(
'user_language'
)
language = 'en'
if user_languages:
language = user_languages.get() or 'en'
domain = dict()
if config.COOKIE_DEFAULT_DOMAIN and\
config.COOKIE_DEFAULT_DOMAIN != 'localhost':
domain['domain'] = config.COOKIE_DEFAULT_DOMAIN
response.set_cookie("PGADMIN_LANGUAGE", value=language,
path=config.COOKIE_DEFAULT_PATH,
**domain)
return response
ckeditor = CKEditor(app)
Bootstrap(app)
login_manager = LoginManager()
login_manager.init_app(app)
##CONNECT TO DB
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL',
"sqlite:///blog.db")
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
##CONFIGURE TABLES
gravatar = Gravatar(
app,
size=100,
rating='g',
default='retro',
force_default=False,
force_lower=False,
)
class Users(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(250), unique=True, nullable=False)
password = db.Column(db.String(250), nullable=False)
name = db.Column(db.String(250), nullable=False)
user_blog_posts = db.relationship('BlogPost', backref='the_user')
the_comments = db.relationship('Comments', backref='the_user_comment')
import os
import click
from flask import Flask
from flask.cli import with_appcontext
from flask_sqlalchemy import SQLAlchemy
from flask_gravatar import Gravatar
db = SQLAlchemy()
gravatar = Gravatar()
def create_app(test_config=None):
"""Create and configure an instance of the Flask application."""
app = Flask(__name__, instance_relative_config=True)
# some deploy system set the database url in the environ
db_url = os.environ.get("DATABASE_URL")
if db_url is None:
# default to a sqlite database in the instance folder
db_url = "sqlite:///" + os.path.join(app.instance_path,
"flaskr.sqlite")
# ensure the instance folder exists
os.makedirs(app.instance_path, exist_ok=True)
app.config.from_mapping(
# default secret that should be overridden in environ or config
SECRET_KEY=os.environ.get("SECRET_KEY", "dev"),
SQLALCHEMY_DATABASE_URI=db_url,
SQLALCHEMY_TRACK_MODIFICATIONS=False,
def test_init_app(self):
gravatar = Gravatar()
if hasattr(self.app, 'extensions'):
del self.app.extensions
gravatar.init_app(self.app)
from daimaduan.views.pastes import paste_app
from daimaduan.views.tags import tag_app
from daimaduan.views.bookmarks import bookmark_app
app.register_blueprint(site_app)
app.register_blueprint(user_app, url_prefix='/user')
app.register_blueprint(paste_app, url_prefix='/paste')
app.register_blueprint(tag_app, url_prefix='/tag')
app.register_blueprint(bookmark_app, url_prefix='/bookmark')
app.jinja_env.filters['time_passed'] = time_passed
app.jinja_env.filters['time_used'] = time_used
app.jinja_env.filters['ternary'] = ternary
app.jinja_env.filters['datetimeformat'] = datetimeformat
app.jinja_env.filters['markdown'] = md
if app.config['USE_JINJA_CACHE']:
app.jinja_env.bytecode_cache = MemcachedBytecodeCache(memcache.Client([app.config['MEMCACHED_URL']]))
login_manager.init_app(app)
assets.init_app(app)
cdn.init_app(app)
gravatar = Gravatar(app,
size=100,
rating='g',
default='retro',
force_default=False,
force_lower=False,
use_ssl=True,
base_url='https://cn.gravatar.com/')
