################
#### config ####
################
application = Flask(__name__)
application.config.from_object('config.ProductionConfig')
####################
#### extensions ####
####################
login_manager = LoginManager()
login_manager.init_app(application)
bcrypt = Bcrypt(application)
mail = Mail(application)
toolbar = DebugToolbarExtension(application)
db = SQLAlchemy(application)
####################
#### blueprints ####
####################
with application.app_context():
from main.views import main_blueprint
from user.views import user_blueprint
application.register_blueprint(main_blueprint)
application.register_blueprint(user_blueprint)
####################
#### flask-login ####
####################
from noggin.middleware import IPAErrorHandler
from noggin.security.ipa_admin import IPAAdmin
from noggin.themes import Theme
from noggin.utility import import_all
# Forms
csrf = CSRFProtect()
# IPA admin account
ipa_admin = IPAAdmin()
# Theme manager
theme = Theme()
# Flask-Mail
mailer = Mail()
# Catch IPA errors
ipa_error_handler = IPAErrorHandler()
# Security headers
talisman = flask_talisman.Talisman()
def create_app(config=None):
"""See https://flask.palletsprojects.com/en/1.1.x/patterns/appfactories/"""
app = Flask(__name__)
# Load default configuration
app.config.from_object("noggin.defaults")
def base_app(request):
"""Flask application fixture without OAuthClient initialized."""
instance_path = tempfile.mkdtemp()
base_app = Flask('testapp')
base_app.config.update(
TESTING=True,
WTF_CSRF_ENABLED=False,
LOGIN_DISABLED=False,
CACHE_TYPE='simple',
OAUTHCLIENT_REMOTE_APPS=dict(
cern=CERN_REMOTE_APP,
orcid=ORCID_REMOTE_APP,
github=GITHUB_REMOTE_APP,
globus=GLOBUS_REMOTE_APP,
),
GITHUB_APP_CREDENTIALS=dict(
consumer_key='github_key_changeme',
consumer_secret='github_secret_changeme',
),
ORCID_APP_CREDENTIALS=dict(
consumer_key='orcid_key_changeme',
consumer_secret='orcid_secret_changeme',
),
CERN_APP_CREDENTIALS=dict(
consumer_key='cern_key_changeme',
consumer_secret='cern_secret_changeme',
),
GLOBUS_APP_CREDENTIALS=dict(
consumer_key='globus_key_changeme',
consumer_secret='globus_secret_changeme',
),
# use local memory mailbox
EMAIL_BACKEND='flask_email.backends.locmem.Mail',
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite://'),
SERVER_NAME='localhost',
DEBUG=False,
SECRET_KEY='TEST',
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
SQLALCHEMY_TRACK_MODIFICATIONS=False,
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
APP_ALLOWED_HOSTS=['localhost'])
FlaskMenu(base_app)
Babel(base_app)
Mail(base_app)
InvenioDB(base_app)
InvenioAccounts(base_app)
with base_app.app_context():
if str(db.engine.url) != 'sqlite://' and \
not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.create_all()
def teardown():
with base_app.app_context():
db.session.close()
if str(db.engine.url) != 'sqlite://':
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
base_app.test_request_context().push()
return base_app
def __init__(self, repo, db_uri=None, debug=None, config=None, **kwargs):
Flask.__init__(self, __name__,
template_folder='templates',
static_folder='static')
# Add unique identifier for this application isinstance
self.uuid = str(uuid.uuid4())
if 'KNOWLEDGE_REPO_MASTER_UUID' not in os.environ:
os.environ['KNOWLEDGE_REPO_MASTER_UUID'] = self.uuid
# Preload default configuration
self.config.from_object('knowledge_repo.app.config_defaults')
# Load configuration from file or provided object
if config:
if isinstance(config, str):
config = imp.load_source('knowledge_server_config', os.path.abspath(config))
self.config.from_object(config)
# Add configuration passed in as keyword arguments
self.config.update(kwargs)
# Prepare repository, and add it to the app
if hasattr(config, 'prepare_repo'):
repo = config.prepare_repo(repo)
self.repository = repo
assert isinstance(self.repository, knowledge_repo.KnowledgeRepository), "Invalid repository object provided."
# Set debug mode from kwargs or else maintain current setting
if debug is not None:
self.config['DEBUG'] = debug
# Set the secret key for this instance (creating one if one does not exist already)
self.config['SECRET_KEY'] = self.config['SECRET_KEY'] or str(uuid.uuid4())
# Configure database
if db_uri:
self.config['SQLALCHEMY_DATABASE_URI'] = db_uri
logger.debug(u"Using database: {}".format(self.config['SQLALCHEMY_DATABASE_URI']))
# Register database schema with flask app
sqlalchemy_db.init_app(self)
# Set up database migration information
# Registers Migrate plugin in self.extensions['migrate']
Migrate(self, self.db)
# Try to create the database if it does not already exist
# Existence is determined by whether there is an existing alembic migration revision
db_auto_create = self.config.get('DB_AUTO_CREATE', True)
db_auto_upgrade = self.config.get('DB_AUTO_UPGRADE', True)
if db_auto_create and self.db_revision is None:
self.db_init()
elif db_auto_upgrade:
self.db_upgrade()
# Initialise login manager to keep track of user sessions
LoginManager().init_app(self)
self.login_manager.login_view = 'auth.login'
self.login_manager.anonymous_user = AnonymousKnowledgeUser
@self.login_manager.user_loader
def load_user(user_id):
return User(identifier=user_id)
# Attempt login via http headers if header is specified
if self.config.get('AUTH_USER_IDENTIFIER_REQUEST_HEADER'):
@self.login_manager.request_loader
def load_user_from_request(request):
identifier = request.headers.get(current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER'])
if identifier:
if current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER_MAPPING']:
identifier = current_app.config['AUTH_USER_IDENTIFIER_REQUEST_HEADER_MAPPING'](identifier)
user = User(identifier=identifier)
user.can_logout = False
user = prepare_user(user, session_start=False)
return user
# Intialise access policies
self.principal = Principal(self)
# Add AnonymousIdentity fallback so that on_identity_loaded is called for
# anonymous users too.
self.principal.identity_loaders.append(lambda: AnonymousIdentity())
# Synchronise user permissions with data model
@user_loaded_from_request.connect
def on_user_loaded_from_request(sender, user):
self.principal.set_identity(Identity(user.id))
@identity_loaded.connect_via(self)
def on_identity_loaded(sender, identity):
populate_identity_roles(identity, user=current_user)
@self.errorhandler(PermissionDenied)
def handle_insufficient_permissions(error):
return render_template('permission_denied.html'), 403
# Add mail object if configuration is supplied
if self.config.get('MAIL_SERVER'):
self.config['mail'] = Mail(self)
# Register routes to be served
self.register_blueprint(routes.posts.blueprint)
self.register_blueprint(routes.health.blueprint)
self.register_blueprint(routes.index.blueprint)
self.register_blueprint(routes.tags.blueprint)
self.register_blueprint(routes.vote.blueprint)
self.register_blueprint(routes.comment.blueprint)
self.register_blueprint(routes.stats.blueprint)
self.register_blueprint(routes.editor.blueprint)
self.register_blueprint(routes.groups.blueprint)
self.register_blueprint(routes.auth.blueprint)
KnowledgeAuthProvider.register_auth_provider_blueprints(self)
if self.config['DEBUG']:
self.register_blueprint(routes.debug.blueprint)
# Register error handler
@self.errorhandler(500)
def show_traceback(self):
""" If LOCAL MODE: show the stack trace on a server error
otherwise show a nice error template to the users
"""
if current_app.config.get("DEBUG"):
return render_template('traceback.html', info=traceback.format_exc()), 500
else:
return render_template('error.html')
@self.before_first_request
def ensure_excluded_tags_exist():
# For every tag in the excluded tags, create the tag object if it doesn't exist
excluded_tags = current_app.config['EXCLUDED_TAGS']
for tag in excluded_tags:
Tag(name=tag)
db_session.commit()
# Set up indexing timers
set_up_indexing_timers(self)
@self.before_request
def open_repository_session():
if not request.path.startswith('/static'):
current_repo.session_begin()
@self.after_request
def close_repository_session(response):
if not request.path.startswith('/static'):
current_repo.session_end()
return response
@self.context_processor
def webediting_enabled():
# TODO: Link this more to KnowledgeRepository capability and
# configuration rather than a specific name.
return {"webeditor_enabled": 'webposts' in current_repo.uris}
@self.context_processor
def inject_version():
version = knowledge_repo.__version__
version_revision = None
if '_' in knowledge_repo.__version__:
version, version_revision = version.split('_')
return dict(version=version,
version_revision=version_revision,
last_index=time_since_index(human_readable=True),
last_index_check=time_since_index_check(human_readable=True))
@self.template_global()
def modify_query(**new_values):
args = request.args.copy()
for key, value in new_values.items():
args[key] = value
return u'{}?{}'.format(request.path, url_encode(args))
@self.template_global()
def pagination_pages(current_page, page_count, max_pages=5, extremes=True):
page_min = int(max(1, current_page - math.floor(1.0 * max_pages // 2)))
page_max = int(min(page_count, current_page + math.floor(1.0 * max_pages / 2)))
to_acquire = max_pages - (page_max - page_min + 1)
while to_acquire > 0 and page_min > 1:
page_min -= 1
to_acquire -= 1
while to_acquire > 0 and page_max < page_count:
page_max += 1
to_acquire -= 1
pages = list(range(page_min, page_max + 1))
if extremes:
if 1 not in pages:
pages[0] = 1
if page_count not in pages:
pages[-1] = page_count
return pages
@self.template_filter('format_date')
def format_date(date):
"""
This will be a Jinja filter that string formats a datetime object.
If we can't correctly format, we just return the object.
:type date: Datetime
:return: A string of the format of YYYY-MM-DD
:rtype: String
"""
try:
return datetime.strftime(date, '%Y-%m-%d')
except:
return date
def __init__(self, to: str = None):
app.config.from_pyfile('config.cfg')
self.mail = Mail(app)
self.s = URLSafeTimedSerializer(app.config['SECRET_KEY'])
self.sender = '*****@*****.**'
self.to = to
def create_app(config_filename="config.development.Config",
app_name=None,
register_blueprints=True):
# App configuration
app = Flask(app_name or __name__)
app_settings = os.getenv("APP_SETTINGS", config_filename)
print(f" * Loading config: '{app_settings}'")
try:
cfg = import_string(app_settings)()
except ImportError:
print(" *** Cannot import config ***")
cfg = import_string("config.config.BaseConfig")
print(" *** Default config loaded, expect problems ***")
if hasattr(cfg, "post_load"):
print(" *** Doing some magic")
cfg.post_load()
app.config.from_object(cfg)
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
Bootstrap(app)
app.jinja_env.add_extension("jinja2.ext.with_")
app.jinja_env.add_extension("jinja2.ext.do")
app.jinja_env.globals.update(is_admin=is_admin)
if HAS_SENTRY:
sentry_sdk.init(
app.config["SENTRY_DSN"],
integrations=[SentryFlaskIntegration(),
SentryCeleryIntegration()],
release=f"{VERSION} ({GIT_VERSION})",
)
print(" * Sentry Flask/Celery support activated")
print(" * Sentry DSN: %s" % app.config["SENTRY_DSN"])
if app.debug:
app.jinja_env.auto_reload = True
logging.basicConfig(level=logging.DEBUG)
# Logging
if not app.debug:
formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s "
"[in %(pathname)s:%(lineno)d]")
file_handler = RotatingFileHandler("%s/errors_app.log" % os.getcwd(),
"a", 1000000, 1)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
CORS(app, origins=["*"])
if app.debug:
logging.getLogger("flask_cors.extension").level = logging.DEBUG
mail = Mail(app) # noqa: F841
migrate = Migrate(app, db) # noqa: F841 lgtm [py/unused-local-variable]
babel = Babel(app) # noqa: F841
app.babel = babel
template = {
"swagger": "2.0",
"info": {
"title": "reel2bits API",
"description": "API instance",
"version": VERSION
},
"host": app.config["AP_DOMAIN"],
"basePath": "/",
"schemes": ["https"],
"securityDefinitions": {
"OAuth2": {
"type": "oauth2",
"flows": {
"authorizationCode": {
"authorizationUrl":
f"https://{app.config['AP_DOMAIN']}/oauth/authorize",
"tokenUrl":
f"https://{app.config['AP_DOMAIN']}/oauth/token",
"scopes": {
"read": "Grants read access",
"write": "Grants write access",
"admin": "Grants admin operations",
},
}
},
}
},
"consumes": ["application/json", "application/jrd+json"],
"produces": ["application/json", "application/jrd+json"],
}
db.init_app(app)
# ActivityPub backend
back = Reel2BitsBackend()
ap.use_backend(back)
# Oauth
config_oauth(app)
# Setup Flask-Security
security = Security(
app, user_datastore) # noqa: F841 lgtm [py/unused-local-variable]
@FlaskSecuritySignals.password_reset.connect_via(app)
@FlaskSecuritySignals.password_changed.connect_via(app)
def log_password_reset(sender, user):
if not user:
return
add_user_log(user.id, user.id, "user", "info",
"Your password has been changed !")
@FlaskSecuritySignals.reset_password_instructions_sent.connect_via(app)
def log_reset_password_instr(sender, user, token):
if not user:
return
add_user_log(user.id, user.id, "user", "info",
"Password reset instructions sent.")
@FlaskSecuritySignals.user_registered.connect_via(app)
def create_actor_for_registered_user(app, user, confirm_token):
if not user:
return
actor = create_actor(user)
actor.user = user
actor.user_id = user.id
db.session.add(actor)
db.session.commit()
@babel.localeselector
def get_locale():
# if a user is logged in, use the locale from the user settings
identity = getattr(g, "identity", None)
if identity is not None and identity.id:
return identity.user.locale
# otherwise try to guess the language from the user accept
# header the browser transmits. We support fr/en in this
# example. The best match wins.
return request.accept_languages.best_match(AVAILABLE_LOCALES)
@babel.timezoneselector
def get_timezone():
identity = getattr(g, "identity", None)
if identity is not None and identity.id:
return identity.user.timezone
@app.before_request
def before_request():
_config = Config.query.first()
if not _config:
flash(gettext("Config not found"), "error")
cfg = {
"REEL2BITS_VERSION_VER": VERSION,
"REEL2BITS_VERSION_GIT": GIT_VERSION,
"app_name": _config.app_name,
"app_description": _config.app_description,
}
if GIT_VERSION:
cfg["REEL2BITS_VERSION"] = "{0}-{1}".format(VERSION, GIT_VERSION)
else:
cfg["REEL2BITS_VERSION"] = VERSION
g.cfg = cfg
@app.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
# Tracks files upload set
sounds = UploadSet("sounds", AUDIO)
configure_uploads(app, sounds)
# Album artwork upload set
artworkalbums = UploadSet("artworkalbums",
Reel2bitsDefaults.artwork_extensions_allowed)
configure_uploads(app, artworkalbums)
# Track artwork upload set
artworksounds = UploadSet("artworksounds",
Reel2bitsDefaults.artwork_extensions_allowed)
configure_uploads(app, artworksounds)
# User avatars
avatars = UploadSet("avatars", Reel2bitsDefaults.avatar_extensions_allowed)
configure_uploads(app, avatars)
# Total max size upload for the whole app
patch_request_class(app, app.config["UPLOAD_TRACK_MAX_SIZE"])
app.flake_id = FlakeId()
if register_blueprints:
from controllers.main import bp_main
app.register_blueprint(bp_main)
from controllers.admin import bp_admin
app.register_blueprint(bp_admin)
# ActivityPub
from controllers.api.v1.well_known import bp_wellknown
app.register_blueprint(bp_wellknown)
from controllers.api.v1.nodeinfo import bp_nodeinfo
app.register_blueprint(bp_nodeinfo)
from controllers.api.v1.ap import bp_ap
# Feeds
from controllers.feeds import bp_feeds
app.register_blueprint(bp_feeds)
# API
app.register_blueprint(bp_ap)
from controllers.api.v1.auth import bp_api_v1_auth
app.register_blueprint(bp_api_v1_auth)
from controllers.api.v1.accounts import bp_api_v1_accounts
app.register_blueprint(bp_api_v1_accounts)
from controllers.api.v1.timelines import bp_api_v1_timelines
app.register_blueprint(bp_api_v1_timelines)
from controllers.api.v1.notifications import bp_api_v1_notifications
app.register_blueprint(bp_api_v1_notifications)
from controllers.api.tracks import bp_api_tracks
app.register_blueprint(bp_api_tracks)
from controllers.api.albums import bp_api_albums
app.register_blueprint(bp_api_albums)
from controllers.api.account import bp_api_account
app.register_blueprint(bp_api_account)
from controllers.api.reel2bits import bp_api_reel2bits
app.register_blueprint(bp_api_reel2bits)
# Pleroma API
from controllers.api.pleroma_admin import bp_api_pleroma_admin
app.register_blueprint(bp_api_pleroma_admin)
# OEmbed
from controllers.api.oembed import bp_api_oembed
app.register_blueprint(bp_api_oembed)
# Iframe
from controllers.api.embed import bp_api_embed
app.register_blueprint(bp_api_embed)
swagger = Swagger(
app,
template=template) # noqa: F841 lgtm [py/unused-local-variable]
# SPA catchalls for meta tags
from controllers.spa import bp_spa
app.register_blueprint(bp_spa)
@app.route("/uploads/<string:thing>/<path:stuff>", methods=["GET"])
@cross_origin(origins="*",
methods=["GET", "HEAD", "OPTIONS"],
expose_headers="content-length",
send_wildcard=True)
def get_uploads_stuff(thing, stuff):
if app.testing or app.debug:
directory = safe_join(app.config["UPLOADS_DEFAULT_DEST"], thing)
app.logger.debug(f"serving {stuff} from {directory}")
return send_from_directory(directory, stuff, as_attachment=True)
else:
app.logger.debug(f"X-Accel-Redirect serving {stuff}")
resp = Response("")
resp.headers[
"Content-Disposition"] = f"attachment; filename={stuff}"
resp.headers[
"X-Accel-Redirect"] = f"/_protected/media/{thing}/{stuff}"
resp.headers[
"Content-Type"] = "" # empty it so Nginx will guess it correctly
return resp
def render_tags(tags):
"""
Given a dict like {'tag': 'meta', 'hello': 'world'}
return a html ready tag like
<meta hello="world" />
"""
for tag in tags:
yield "<{tag} {attrs} />".format(
tag=tag.pop("tag"),
attrs=" ".join([
'{}="{}"'.format(a, html.escape(str(v)))
for a, v in sorted(tag.items()) if v
]),
)
@app.errorhandler(404)
def page_not_found(msg):
excluded = ["/api", "/.well-known", "/feeds", "/oauth/authorize"]
if any([request.path.startswith(m) for m in excluded]):
return jsonify({"error": "page not found"}), 404
html = get_spa_html(app.config["REEL2BITS_SPA_HTML"])
head, tail = html.split("</head>", 1)
request_tags = get_request_head_tags(request)
default_tags = get_default_head_tags(request.path)
unique_attributes = ["name", "property"]
final_tags = request_tags
skip = []
for t in final_tags:
for attr in unique_attributes:
if attr in t:
skip.append(t[attr])
for t in default_tags:
existing = False
for attr in unique_attributes:
if t.get(attr) in skip:
existing = True
break
if not existing:
final_tags.append(t)
head += "\n" + "\n".join(render_tags(final_tags)) + "\n</head>"
return head + tail
@app.errorhandler(403)
def err_forbidden(msg):
if request.path.startswith("/api/"):
return jsonify({"error": "access forbidden"}), 403
pcfg = {
"title": gettext("Whoops, something failed."),
"error": 403,
"message": gettext("Access forbidden"),
"e": msg,
}
return render_template("error_page.jinja2", pcfg=pcfg), 403
@app.errorhandler(410)
def err_gone(msg):
if request.path.startswith("/api/"):
return jsonify({"error": "gone"}), 410
pcfg = {
"title": gettext("Whoops, something failed."),
"error": 410,
"message": gettext("Gone"),
"e": msg
}
return render_template("error_page.jinja2", pcfg=pcfg), 410
if not app.debug:
@app.errorhandler(500)
def err_failed(msg):
if request.path.startswith("/api/"):
return jsonify({"error": "server error"}), 500
pcfg = {
"title": gettext("Whoops, something failed."),
"error": 500,
"message": gettext("Something is broken"),
"e": msg,
}
return render_template("error_page.jinja2", pcfg=pcfg), 500
@app.after_request
def set_x_powered_by(response):
response.headers["X-Powered-By"] = "reel2bits"
return response
# Register CLI commands
app.cli.add_command(commands.db_datas)
app.cli.add_command(commands.users)
app.cli.add_command(commands.roles)
app.cli.add_command(commands.tracks)
app.cli.add_command(commands.system)
return app
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_admin import Admin
from flask_login import LoginManager
from flask_mail import Mail
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hdjkfhuiy12ui3y12783yhjskbdks'
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:123456789@localhost/airlinedb?charset=utf8mb4'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['ROOT_PROJECT_PATH'] = app.root_path
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
mail = Mail(app=app)
db = SQLAlchemy(app=app)
ad = Admin(app=app, name="Bán vé chuyến bay", template_mode="Bootstrap4")
login = LoginManager(app=app)
from imp import reload
import datetime
import basic
reload(basic)
from basic import public
db, ATTACH_ROOT = public.db, public.ATTACH_ROOT
app.config['MAIL_SERVER'] = ''
app.config['MAIL_PORT'] = 994
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_DEBUG'] = True
app.config['MAIL_DEFAULT_SENDER'] = ''
app.config['MAIL_USERNAME'] = ''
app.config['MAIL_PASSWORD'] = ""
mails = Mail(app)
@c.task
def silk_mp3():
sql = """select p.id,p.audio
from post_future p
where COALESCE(p.tomp3,0)=0 and COALESCE(p.audio_flag,0)=0"""
l, t = db.select(sql)
if t > 0:
with app.app_context():
for i in l:
id, audio = i[0], i[1]
mp3 = audio.split('.')[0] + '.mp3'
path = os.path.join(ATTACH_ROOT, audio)
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
OAUTH2_CACHE_TYPE='simple',
OAUTHLIB_INSECURE_TRANSPORT=True,
SECRET_KEY='test_key',
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI',
'sqlite:///example.db'),
)
FlaskCLI(app)
Babel(app)
Mail(app)
Menu(app)
InvenioDB(app)
accounts = InvenioAccounts(app)
app.register_blueprint(accounts_blueprint)
InvenioOAuth2Server(app)
app.register_blueprint(settings_blueprint)
app.register_blueprint(server_blueprint)
@app.cli.group()
def fixtures():
"""Command for working with test data."""
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try:
app.config.from_object('local_settings')
except:
pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
mail = Mail(app) # Initialize Flask-Mail
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
# Define User model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_profile_id = db.Column(
db.Integer(), db.ForeignKey('user_profile.id', ondelete='CASCADE'))
# User authentication information
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
reset_password_token = db.Column(db.String(100),
nullable=False,
server_default='')
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='0')
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
# Relationships
user_profile = db.relationship('UserProfile',
uselist=False,
foreign_keys=[user_profile_id])
class UserProfile(db.Model):
id = db.Column(db.Integer, primary_key=True)
# User information
first_name = db.Column(db.String(50), nullable=False, default='')
last_name = db.Column(db.String(50), nullable=False, default='')
# Relationships
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
# Define Role model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define UserRoles model
class UserRoles(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_profile_id = db.Column(
db.Integer(), db.ForeignKey('user_profile.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE'))
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User, UserProfileClass=UserProfile)
user_manager = UserManager(db_adapter, app)
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username == 'user007').first():
user_profile1 = UserProfile(first_name='James', last_name='Bond')
db.session.add(user_profile1)
user1 = User(user_profile=user_profile1,
username='******',
email='*****@*****.**',
password=user_manager.hash_password('Password1'),
active=True)
db.session.add(user1)
user_profile1.roles.append(Role(name='secret'))
user_profile1.roles.append(Role(name='agent'))
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Home page</h2>
<p>This page can be accessed by anyone.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users
@app.route('/members')
@login_required # Use of @login_required decorator
def members_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Members page</h2>
<p>This page can only be accessed by authenticated users.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
# The Special page requires a user with 'special' and 'sauce' roles or with 'special' and 'agent' roles.
@app.route('/special')
@roles_required('secret',
['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Special Page</h2>
<p>This page can only be accessed by user007.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
return app
from flask import url_for, request, render_template, redirect, send_from_directory, g, session, abort, flash, jsonify
from functools import wraps
from lib import *
from coco_scheduling import *
import re
from flask.globals import session, request
from flask_mail import Mail, Message
from db_helper import DBAssistant
# from celery import Celery
app.config.from_object(__name__)
mail_ext = Mail(app)
# celery = Celery(app.name, broker=app.config['CELERY_BROKER_URL'])
# celery.conf.update(app.config)
PERIOD = {}
COLORPREFS = {0: "tomato", 1: "", 2: "yellow", 3: "lightgreen", 5: "lightgrey"}
courseComplete = {
} # for the current lecturer: dictionary for courses and resp. preferences for each of them
hrs = {
} # hours per week for every course of current lecturer (who is logged in now)
markedTimes = {}
allSolutions = []
incr = 0
newPrefs = 0
app.config.from_envvar('COCO_SETTINGS', silent=True)
db_assist = DBAssistant()
class OneLove(object):
class Result(object):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
api = None
app = None
blueprint = None
collect = Collect()
db = MongoEngine()
jwt = JWT()
mail = Mail()
security = Security()
socketio = None
toolbar = None
user_datastore = None
def __init__(self, app=None):
if app is not None:
if app.config['DEBUG']:
self.cors = CORS()
self.init_app(app)
def init_app(self, app):
global current_app
current_app = self
self.app = app
if app.config['DEBUG']:
self.cors.init_app(
self.app,
resources={r'/api/*': {
'origins': '*'
}},
)
from api import api_v0, api
self.api = api
self.blueprint = Blueprint(
'onelove',
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/static/onelove',
)
self.app.register_blueprint(self.blueprint)
self.app.register_blueprint(api_v0, url_prefix='/api/v0')
self.app.register_blueprint(apidoc.apidoc)
self.mail.init_app(self.app)
self.db.init_app(self.app)
self.user_datastore = MongoEngineUserDatastore(
self.db,
User,
Role,
)
self.security.init_app(
self.app,
self.user_datastore,
)
self.jwt.init_app(self.app)
self.collect.init_app(self.app)
if self.app.config.get('DEBUG_TB_PANELS', False):
from flask_debugtoolbar import DebugToolbarExtension
from flask_debug_api import DebugAPIExtension
self.toolbar = DebugToolbarExtension(self.app)
self.toolbar = DebugAPIExtension(self.app)
self.socketio = SocketIO(self.app, logger=True)
self.app.onelove = self
@jwt.authentication_handler
def authenticate(username, password):
try:
user = User.objects.get(email=username)
except User.DoesNotExist:
return None
result = OneLove.Result(
id=str(user.id),
email=user.email,
first_name=user.first_name,
last_name=user.last_name,
)
if verify_password(password, user.password):
return result
@jwt.identity_handler
def identity(payload):
try:
user = User.objects.get(id=payload['identity'])
except User.DoesNotExist:
user = None
return user
"""
Functions for setting up and starting the DockCI application server
"""
import logging
import mimetypes
from flask import Flask
from flask_mail import Mail
from dockci.models.config import Config
from dockci.util import setup_templates
APP = Flask(__name__)
MAIL = Mail()
CONFIG = Config()
APP.config.model = CONFIG # For templates
def app_init():
"""
Pre-run app setup
"""
logger = logging.getLogger('dockci.init')
logger.info("Loading app config")
APP.secret_key = CONFIG.secret
APP.config['MAIL_SERVER'] = CONFIG.mail_server
SPDX-License-Identifier: AGPL-3.0-only
"""
import html
import typing as t
import html2text
import structlog
from flask import current_app
from flask_mail import Mail, Message
import psef
import psef.models as models
from psef.errors import APICodes, APIException
mail = Mail() # pylint: disable=invalid-name
logger = structlog.get_logger()
def _send_mail(
html_body: str,
subject: str,
recipients: t.Optional[t.Sequence[t.Union[str, t.Tuple[str, str]]]],
mailer: t.Optional[Mail] = None,
) -> None:
logger.info(
'Sending email',
subject=subject,
html_body=html_body,
recipients=recipients,
)
from flask_admin import Admin
from flask_mail import Mail
import flask_excel as excel
from config import Config
from sqlalchemy import event
from elasticsearch import Elasticsearch
import logging
from logging.handlers import SMTPHandler
from geopy.geocoders import Nominatim
app = Flask(__name__)
db = SQLAlchemy()
migrate = Migrate()
security = Security()
admin = Admin()
mail = Mail()
geolocator = Nominatim(user_agent='Assignably')
#excel = Excel()
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
migrate.init_app(app, db)
mail.init_app(app)
excel.init_excel(app)
app.elasticsearch = Elasticsearch([
app.config['ELASTICSEARCH_URL']
]) if app.config['ELASTICSEARCH_URL'] else None
# Richard Darst, April 2015
import datetime
from flask import Flask
#from flask.ext.sqlalchemy import SQLAlchemy
from flask_sqlalchemy import SQLAlchemy
from flask_mail import Mail
from flask_user import login_required, UserManager, UserMixin, SQLAlchemyAdapter
from config import app
db = SQLAlchemy(app)
mail = Mail(app) # Initialize Flask-Mail
class User(db.Model, UserMixin):
__tablename__ = 'user'
uid = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
reset_password_token = db.Column(db.String(100),
nullable=False,
server_default='')
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
# User information
active = db.Column('is_active',
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_login import LoginManager
from flask_mail import Mail
from secrets import token_urlsafe
import hashlib
import os
import click
app = Flask(__name__)
app.config.from_object(Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db, render_as_batch=True)
login = LoginManager(app)
login.login_view = 'login'
mail = Mail(app)
bootstrap = Bootstrap(app)
if not app.debug:
if app.config['MAIL_SERVER']:
auth = None
if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])
secure = None
if app.config['MAIL_USE_TLS']:
secure = ()
mail_handler = SMTPHandler(
mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
fromaddr='no-reply@' + app.config['MAIL_SERVER'],
toaddrs=app.config['MAIL_ADMIN'],
subject='{} - Failure'.format(app.config['APPNAME']),
ENV_FILE = find_dotenv()
if ENV_FILE:
load_dotenv(ENV_FILE)
ENV_PARAM = {}
ENV_PARAM["AUTH0_CALLBACK_URL"] = env.get(constants.AUTH0_CALLBACK_URL)
ENV_PARAM["AUTH0_CLIENT_ID"] = env.get(constants.AUTH0_CLIENT_ID)
ENV_PARAM["AUTH0_CLIENT_SECRET"] = env.get(constants.AUTH0_CLIENT_SECRET)
ENV_PARAM["AUTH0_DOMAIN"] = env.get(constants.AUTH0_DOMAIN)
APP = Flask(__name__,
static_url_path='/build',
static_folder='../front-end/build')
CORS(APP)
mail = Mail(APP)
APP.secret_key = "client_secret"
API = Api(APP)
APP.register_blueprint(view_manager.blueprint)
db_user = env.get(constants.MYSQL_DATABASE_USER)
db_pass = env.get(constants.MYSQL_DATABASE_PASSWORD)
db_host = env.get(constants.MYSQL_DATABASE_HOST)
db_name = env.get(constants.MYSQL_DATABASE_DB)
db_sock = env.get(constants.MYSQL_DATABASE_SOCKET)
APP.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql://' + db_user + ':' + db_pass + '@' + db_host + '/' + db_name + db_sock
db.init_app(APP)
# If you are new server manager, you need to run this once.
db.create_all(app=APP)
