################ #### 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)