Ejemplo n.º 1
1
def create_app(db_name=None):
    app = Flask(__name__)
    app.config.from_object(config)
    if db_name:
        config.MONGO_DATABASE = db_name

    mongo, db = HapPyMongo(config)
    app.permanent_session_lifetime = timedelta(hours=2)

    auth = CloudAuth(app, db)
    app.context_processor(template_functions.view_functions)

    Admin(app)

    @app.before_first_request
    def logger():
        if not app.debug:
            app.logger.addHandler(logging.StreamHandler())
            app.logger.setLevel(logging.INFO)

    @app.before_request
    def before_request():
        g.db, g.auth = db, auth

    defaults.application_initialize(db, app)
    views.BaseView.register(app)
    views.GlobalManageView.register(app)
    views.QueryView.register(app)

    if db_name:
        return app, db
    else:
        return app
Ejemplo n.º 2
1
    def start():
        """
        Start the application
        """
        config_type = "DevelopmentConfig"
        if len(sys.argv) == 2:
            if sys.argv[1] == "dev":
                config_type = "DevelopmentConfig"
            elif sys.argv[1] == "test":
                config_type = "TestConfig"
            elif sys.argv[1] == "prod":
                config_type = "ProductionConfig"
        app = Flask(__name__)
        app.config.from_object("conf.config.%s" % config_type)
        app.secret_key = getRandomInteger(128)
        app.permanent_session_lifetime = timedelta(seconds=10)
        FORMAT = "%(asctime)s %(levelname)s: " "%(message)s [in %(pathname)s:%(lineno)d]"
        logging.basicConfig(filename=app.config["LOGFILE"], level=logging.DEBUG, format=FORMAT)
        PYSTHClient.init_controllers(app)

        @app.errorhandler(400)
        def bad_request(exception):
            """Bad Request"""
            data = dict(status=exception.code, error=str(exception), description=bad_request.__doc__)
            return jsonify(data), 400

        @app.errorhandler(404)
        def page_not_found(exception):
            """Page Not Found"""
            data = dict(status=exception.code, error=str(exception), description=page_not_found.__doc__)
            return jsonify(data), 404

        if app.config["DEBUG"] is True:

            @app.errorhandler(500)
            def error(exception):
                """Internal Server Error"""
                data = dict(status=exception.code, error=str(exception), description=error.__doc__)
                return jsonify(data), 500

        @app.errorhandler(403)
        def forbidden(exception):
            """Forbidden"""
            data = dict(status=exception.code, error=str(exception), description=forbidden.__doc__)
            return jsonify(data), 403

        # noinspection PyUnusedLocal
        @app.before_first_request
        def bootstrap():
            """
            Call the bootstrap function
            """
            Bootstrap()

        with app.app_context():
            Base.do_first_request()
        app.run(app.config["HOST"], app.config["PORT"])
Ejemplo n.º 3
0
def create_app(config_name):
    app = Flask(__name__)
    CORS(app)
    app.config.from_object(config[config_name])

    import logging
    from logging.handlers import RotatingFileHandler
    _handler = RotatingFileHandler(app.config['LOGGER_NAME'], maxBytes=10000, backupCount=1)
    _handler.setLevel(logging.DEBUG)
    app.logger.addHandler(_handler)

    pagedown.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    bootstrap.init_app(app)
    app.secret_key = app.config['SECRET_KEY']
    app.permanent_session_lifetime = timedelta(minutes=5)

    login_manager.init_app(app)
    db.init_app(app)
    from .api_1_0 import api as api_1_0_blueprint
    app.register_blueprint(api_1_0_blueprint, url_prefix='/api')
    from .base import base
    app.register_blueprint(base)
    from .rest_api import rest_api
    app.register_blueprint(rest_api, url_prefix='/rest')

    from .models import Role
    @app.before_first_request
    def build_up_before_start():
        Role.insert_roles()
    return app
def create_app(config_name):

    application = Flask(__name__,
                        static_folder='static/',
                        static_url_path=configs[config_name].ASSET_PATH)

    init_app(
        application,
        configs[config_name],
        bootstrap=bootstrap,
        data_api_client=data_api_client,
        login_manager=login_manager
    )

    application.permanent_session_lifetime = timedelta(hours=1)
    from .main import main as main_blueprint
    from .status import status as status_blueprint

    url_prefix = application.config['URL_PREFIX']
    application.register_blueprint(status_blueprint, url_prefix=url_prefix)
    application.register_blueprint(main_blueprint, url_prefix=url_prefix)
    login_manager.login_view = 'main.render_login'
    main_blueprint.config = application.config.copy()

    init_frontend_app(application, data_api_client, login_manager)

    application.add_template_filter(parse_document_upload_time)

    @application.context_processor
    def extra_template_variables():
        return {
            'generic_contact_email': application.config['GENERIC_CONTACT_EMAIL'],
        }

    return application
Ejemplo n.º 5
0
def create_app():
    application = Flask(__name__)
    application.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_URI
    # application.config['BABEL_DEFAULT_LOCALE'] = 'ru-ru'
    application.config['SECRET_KEY'] = SECRET_KEY
    application.permanent_session_lifetime = timedelta(minutes=30)

    Triangle(application)
    assets.init_app(application)
    api.init_app(application)
    api.application = application
    db.init_app(application)
    admin.init_app(application)
    login_manager.init_app(application)
    application.db = db
    application.api = api

    babel = Babel(application)
    @babel.localeselector
    def get_locale():
        return request.accept_languages.best_match(["ru"])

    init_logging(application)

    return application
Ejemplo n.º 6
0
def create_app(config_filename='config.default.DevelopmentConfig'):
    app = Flask(__name__)
    app.config.from_object(config_filename)

    app.secret_key = app.config['SECRET_KEY']
    app.permanent_session_lifetime = timedelta(minutes=app.config['SESSION_ALIVE_MINUTES'])
    app.session_interface = ItsdangerousSessionInterface()
    # SOCKET
    # url = '127.0.0.1'
    # client_socket.connect((url, 8000))

    # logging module
    log_filepath = os.path.join(app.config['ROOT_DIR'], 'app_server/log')
    log.init(log_filepath=log_filepath, log_level=app.config['LOG_LEVEL'])
    log.info("CREATE HIMS APP : "+__name__)

    db.init_app(app)
    bcrypt.init_app(app)
    login_manager.init_app(app)

    from youngs_server.api.auth_controllers import api_auth
    from youngs_server.api.member_controllers import api_member
    from youngs_server.api.lecture_controllers import api_lecture
    from youngs_server.api.question_controllers import api_question

    app.register_blueprint(api_auth)
    app.register_blueprint(api_member)
    app.register_blueprint(api_lecture)
    app.register_blueprint(api_question)
    return app
Ejemplo n.º 7
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)
    bootstrap.init_app(app)
    # mail.init_app(app)
    moment.init_app(app)
    db.init_app(app)
    login_manager.init_app(app)
    admin.init_app(app)
    # Todo-rezwan follow this guide for auto renewing session
    # http://stackoverflow.com/questions/19760486/resetting-the-expiration-time-for-a-cookie-in-flask
    # http://stackoverflow.com/questions/19760486/resetting-the-expiration-time-for-a-cookie-in-flask
    app.permanent_session_lifetime = timedelta(minutes=60)  # adding session time out. working

    # attach routes and custom error pages here
    from main import main as main_blueprint
    app.register_blueprint(main_blueprint)
    from .auth import auth as auth_blueprint
    app.register_blueprint(auth_blueprint, url_prefix='/auth')
    from .admin import admin_panel as admin_blueprint
    app.register_blueprint(admin_blueprint, url_prefix='/admin')

    db.app = app
    db.create_all()


    return app
Ejemplo n.º 8
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(app_config[config_name])
    app.permanent_session_lifetime = timedelta(minutes=5)
    init_models()
    register_blueprints(app)
    return app
Ejemplo n.º 9
0
def create_app(config_name):

    application = Flask(__name__,
                        static_folder='static/',
                        static_url_path=configs[config_name].STATIC_URL_PATH)

    init_app(
        application,
        configs[config_name],
        bootstrap=bootstrap,
        data_api_client=data_api_client,
        feature_flags=feature_flags,
        login_manager=login_manager
    )
    # Should be incorporated into digitalmarketplace-utils as well
    csrf.init_app(application)

    application.permanent_session_lifetime = timedelta(hours=1)
    from .main import main as main_blueprint
    from .status import status as status_blueprint

    application.register_blueprint(status_blueprint, url_prefix='/admin')
    application.register_blueprint(main_blueprint, url_prefix='/admin')
    login_manager.login_view = 'main.render_login'
    main_blueprint.config = application.config.copy()

    @application.before_request
    def remove_trailing_slash():
        if request.path != '/' and request.path.endswith('/'):
            return redirect(request.path[:-1], code=301)

    application.add_template_filter(parse_document_upload_time)

    return application
Ejemplo n.º 10
0
    def flask(cls, name, config=None, debug=False, **kwargs):
        template_folder = kwargs.pop('template_folder', tmpl_dir)
        app = Flask(name, template_folder=template_folder, **kwargs)
        if config:
           app.config.from_object(config)
        app.permanent_session_lifetime = timedelta(minutes=60)
        app.debug = debug

        if app.config.get('COUCHDB_DATABASE',None) is None:
           app.config['COUCHDB_DATABASE'] = name.lower()

        assert app.secret_key is not None, "flask config does not specify a secret key"
        return app
Ejemplo n.º 11
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object('config')
    bootstrap.init_app(app)
    # moment.init_app(app)
    db.init_app(app)
    login_manager.init_app(app)
    app.permanent_session_lifetime = timedelta(hours=24)

    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)

    from .auth import auth as auth_blueprint
    app.register_blueprint(auth_blueprint)

    return app
Ejemplo n.º 12
0
def create_app(config_name):
    application = Flask(
        __name__,
        static_folder='static/',
        static_url_path=configs[config_name].STATIC_URL_PATH
    )

    application.config['NOTIFY_ENVIRONMENT'] = config_name
    application.config.from_object(configs[config_name])

    init_app(application)
    csrf.init_app(application)

    @csrf.error_handler
    def csrf_handler(reason):
        if 'user_id' not in session:
            application.logger.info(
                u'csrf.session_expired: Redirecting user to log in page'
            )

            return application.login_manager.unauthorized()

        application.logger.info(
            u'csrf.invalid_token: Aborting request, user_id: {user_id}',
            extra={'user_id': session['user_id']})

        abort(400, reason)

    login_manager.init_app(application)
    admin_api_client.init_app(application)
    proxy_fix.init_app(application)

    from .main import main as main_blueprint
    application.permanent_session_lifetime = timedelta(hours=1)
    application.register_blueprint(main_blueprint, url_prefix='/admin')
    login_manager.login_view = 'main.render_login'

    main_blueprint.config = application.config.copy()

    @application.before_request
    def remove_trailing_slash():
        if request.path != '/' and request.path.endswith('/'):
            return redirect(request.path[:-1], code=301)

    application.add_template_filter(datetimeformat)

    return application
Ejemplo n.º 13
0
def create_app():
    app = Flask(__name__)
    app.config['SECRET_KEY'] = 'THIS IS JUST A TEST WEBPAGE !'
    app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@[email protected]/maizi'
    app.config['BABEL_DEFAULT_LOCALE'] = 'en'
    app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
    from flask.json import JSONEncoder

    class CustomJSONEncoder(JSONEncoder):
        """This class adds support for lazy translation texts to Flask's
        JSON encoder. This is necessary when flashing translated texts."""

        def default(self, obj):
            from speaklater import is_lazy_string
            if is_lazy_string(obj):
                try:
                    return unicode(obj)  # python 2
                except NameError:
                    return str(obj)  # python 3
            return super(CustomJSONEncoder, self).default(obj)

    app.json_encoder = CustomJSONEncoder

    bootstrap.init_app(app)
    db.init_app(app)
    login_manager.init_app(app)
    pagedown.init_app(app)
    Gravatar(app, size=64)
    babel.init_app(app)

    from auth import auth as auth_blueprint
    from main import main as main_blueprint
    app.register_blueprint(auth_blueprint)
    app.register_blueprint(main_blueprint)

    app.permanent_session_lifetime = timedelta(minutes=5)

    @app.template_test('current_link')
    def is_current_link(link):
        return link == request.path

    @babel.localeselector
    def get_locale():
        return current_user.locale

    return app
Ejemplo n.º 14
0
def create_manager(deed_api_client=make_deed_api_client()):
    app = Flask(__name__)
    app.config.from_pyfile('config.py')

    manager = Manager(app)
    app.url_map.strict_slashes = False

    setattr(searchdeed, 'deed_api_client', deed_api_client)

    app.register_blueprint(health, url_prefix='/health')
    app.register_blueprint(searchdeed)
    app.register_blueprint(borrower_landing)
    app.secret_key = app.config['APP_SECRET_KEY']

    app.permanent_session_lifetime = timedelta(minutes=20)

    return manager
Ejemplo n.º 15
0
def create_app(config_name):
    app = Flask(__name__)

    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)

    app.config.from_object(config[config_name])
    app.permanent_session_lifetime = timedelta(minutes=5)

    config[config_name].init_app(app)
    bootstrap.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    db.init_app(app)

    # 附加路由和自定义的错误页面
    return app
Ejemplo n.º 16
0
def create_app(config_name):
	app = Flask(__name__)
	app.config.from_object(config[config_name])
	app.permanent_session_lifetime = timedelta(minutes = 10)
	config[config_name].init_app(app)
	mail.init_app(app)
	moment.init_app(app)
	db.init_app(app)

	# attach routes and custom error pages here

	from main import main as main_blueprint
	app.register_blueprint(main_blueprint)


	file_handler = RotatingFileHandler('logs/nights_watch.log',
		'a',									# Append
		1 * 1024 * 1024 * 1024,					# 10 MB
		20)										# Max 20 log files
	
	#mail_handler = SMTPHandler(
	#	mailhost=(app.config["MAIL_SERVER"], app.config["MAIL_PORT"]),
	#	fromaddr=app.config["MAIL_SENDER"],
	#	toaddrs=app.config["MAIL_TO"],
	#	subject=app.config["MAIL_SUBJECT_PREFIX"])

	log_format_file = logging.Formatter('%(asctime)s %(levelname)s: %(message)s \
	[at %(pathname)s:%(lineno)d]')

	#log_format_email = logging.Formatter('%(asctime)s %(levelname)s: %(message)s')

	file_handler.setFormatter(log_format_file)
	#mail_handler.setFormatter(log_format_email)

	app.logger.setLevel(logging.INFO)

	file_handler.setLevel(logging.INFO)
	#mail_handler.setLevel(logging.WARNING)

	app.logger.addHandler(file_handler)
	#app.logger.addHandler(mail_handler)

	app.logger.info('application started!!!')

	return app
Ejemplo n.º 17
0
    def setUp(self):
        application = Flask(__name__)
        application.config['TESTING'] = True
        application.secret_key = 'you will not guess'
        application.permanent_session_lifetime = timedelta(seconds=1)

        login_manager.init_app(application)
        self.application = application
        with self.application.test_client() as c:
            with c.session_transaction() as sess:
                sess['user_id'] = '1'

        schema_file = open(os.path.join(settings.EQ_SCHEMA_DIRECTORY, "0_star_wars.json"))
        schema = schema_file.read()
        # create a parser
        self.schema_json = json.loads(schema)
        parser = SchemaParserFactory.create_parser(self.schema_json)
        self.questionnaire = parser.parse()
def create_app(config_name):

    application = Flask(__name__, static_folder="static/", static_url_path=configs[config_name].STATIC_URL_PATH)

    init_app(
        application,
        configs[config_name],
        bootstrap=bootstrap,
        data_api_client=data_api_client,
        feature_flags=feature_flags,
        login_manager=login_manager,
    )
    # Should be incorporated into digitalmarketplace-utils as well
    csrf.init_app(application)

    application.permanent_session_lifetime = timedelta(hours=1)
    from .main import main as main_blueprint
    from .status import status as status_blueprint

    application.register_blueprint(status_blueprint, url_prefix="/admin")
    application.register_blueprint(main_blueprint, url_prefix="/admin")
    login_manager.login_view = "main.render_login"
    main_blueprint.config = application.config.copy()

    @application.before_request
    def remove_trailing_slash():
        if request.path != "/" and request.path.endswith("/"):
            return redirect(request.path[:-1], code=301)

    @application.template_filter("timeformat")
    def timeformat(value):
        return datetime.strptime(value, formats.DATETIME_FORMAT).strftime(DISPLAY_TIME_FORMAT)

    @application.template_filter("dateformat")
    def dateformat(value):
        return datetime.strptime(value, formats.DATETIME_FORMAT).strftime(DISPLAY_DATE_FORMAT)

    @application.template_filter("displaydateformat")
    def display_date_format(value):
        return value.strftime(DISPLAY_DATE_FORMAT)

    return application
Ejemplo n.º 19
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    config[config_name].init_app(app)

    db.init_app(app)
    bootstrap.init_app(app)
    mail.init_app(app)
    login_manager.init_app(app)

    # security setting
    app.secret_key="youdon'tknwhatIT1s"
    app.permanent_session_lifetime = datetime.timedelta(minutes=30)

    # register blueprint
    from .main import main as main_blueprint

    app.register_blueprint(main_blueprint)

    return app
Ejemplo n.º 20
0
def create_app(config_name):
    app = Flask(__name__)

    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)

    from .auth import auth as auth_blueprint
    app.register_blueprint(auth_blueprint, url_prefix='/auth')

    app.config.from_object(config[config_name])
    app.permanent_session_lifetime = timedelta(minutes=5)

    config[config_name].init_app(app)
    bootstrap.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    db.init_app(app)
    login_manager.init_app(app)

    return app
Ejemplo n.º 21
0
def create_app(db_name=None):
    app = Flask(__name__)
    app.config.from_object(config)
    if db_name:
        config.MONGO_DATABASE = db_name

    Admin(app)
    Engine(app)
    mongo, db = HapPyMongo(config)
    app.permanent_session_lifetime = timedelta(hours=2)
    auth = CloudAuth(app, db)

    custom_filters = {
        name: function for name, function in getmembers(template_filters)
        if isfunction(function)
    }
    app.jinja_env.filters.update(custom_filters)
    app.context_processor(template_functions.utility_processor)

    @app.before_first_request
    def logger():
        if not app.debug:
            app.logger.addHandler(logging.StreamHandler())
            app.logger.setLevel(logging.INFO)

    @app.before_request
    def before_request():
        g.db, g.auth = db, auth

    defaults.application_initialize(db, app)
    views.ProductsView.register(app)
    views.MiscView.register(app)
    views.FeedbackView.register(app)
    views.GlobalManageView.register(app)

    if db_name:
        return app, db
    else:
        return app
Ejemplo n.º 22
0
def create_app(config=config.dev_config, school_name=None):
	""" The main entry point where the application is created """
	# Create the application
	app = Flask(__name__)    
    # User only logged in for 10 minutes before getting auto logged out
	app.permanent_session_lifetime = timedelta(seconds=600)
	# Default configurations
	app.config.from_object(config)
	# Configuration overrides
	app.config.from_pyfile('../application.cfg', silent=True)
	# In "multi-school" mode, each school is run as a separate app.
	# And each is run under the root directory (eg. domain.net/school)
	if school_name is not None:
		app.config['SCRIPT_NAME'] = '/'+school_name
	app.config['SCHOOL'] = school_name or app.config['DEFAULT_SCHOOL']

	# Register everything
	register_extensions(app)
	register_views(app)
	register_template_filters(app)
	configure_hooks(app)
	return app
def create_app(config_name):
    application = Flask(__name__,
                        static_folder='static/',
                        static_url_path=configs[config_name].STATIC_URL_PATH)

    init_app(
        application,
        configs[config_name],
        data_api_client=data_api_client,
        feature_flags=feature_flags,
        login_manager=login_manager,
    )
    application.permanent_session_lifetime = timedelta(hours=1)
    from .main import main as main_blueprint
    from .status import status as status_blueprint

    application.register_blueprint(status_blueprint,
                                   url_prefix='/suppliers')
    application.register_blueprint(main_blueprint,
                                   url_prefix='/suppliers')
    login_manager.login_view = 'main.render_login'
    main_blueprint.config = application.config.copy()

    csrf.init_app(application)

    @application.before_request
    def remove_trailing_slash():
        if request.path.endswith('/'):
            return redirect(request.path[:-1], code=301)

    @application.before_request
    def refresh_session():
        session.permanent = True
        session.modified = True

    return application
Ejemplo n.º 24
0
web_service = Flask(__name__,
                    static_url_path=WEB_SERVICE_CONFIG["static_url_path"],
                    static_folder=WEB_SERVICE_CONFIG["static_files_path"],
                    template_folder=WEB_SERVICE_CONFIG["templates_path"])
socket_service = SocketIO(web_service)
web_service.config['DEBUG'] = WEB_SERVICE_CONFIG["debug"]
web_service.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_CONFIG[
    "connection_string"]
web_service.config['SECRET_KEY'] = WEB_SERVICE_CONFIG["security_secret_key"]
web_service.config['SECURITY_PASSWORD_HASH'] = WEB_SERVICE_CONFIG[
    "security_password_hash"]
web_service.config['SECURITY_PASSWORD_SALT'] = WEB_SERVICE_CONFIG[
    "security_password_salt"]
if WEB_SERVICE_CONFIG["expire_session"]:
    session.permanent = True
    web_service.permanent_session_lifetime = timedelta(
        minutes=WEB_SERVICE_CONFIG["session_timeout_in_minutes"])
    web_service.config['SESSION_REFRESH_EACH_REQUEST'] = WEB_SERVICE_CONFIG[
        "refresh_session_on_each_request"]

# Flask-SQLAlchemy
db = SQLAlchemy(web_service)
import server.database.models  # Do NOT remove this import - it pulls up all models for SQLAlchemy module.

db.create_all()

# Flask-Security
from server.database.models.user.users import Users
from server.database.models.user.roles import Roles
from server.web.utils import ModifiedLoginForm

user_datastore = SQLAlchemySessionUserDatastore(db.session, Users, Roles)
Ejemplo n.º 25
0
    path = os.path.abspath('.')

    if not os.path.exists('database'):
        os.mkdir(os.path.join(path, 'database'))

    static_folder = os.path.join(path, 'static')
    template_folder = os.path.join(path, 'templates')

    app = Flask(__name__,
                template_folder=template_folder,
                static_folder=static_folder)
else:
    app = Flask(__name__)

app.config['SECRET_KEY'] = get_random_bytes(0x20)
app.permanent_session_lifetime = timedelta(
    minutes=SessionConst.SESSION_TTL.value)

# Protection against CSRF attack
CSRFProtect(app)

# databases
account_db = Account()
profile_db = Profile()


# core functions
def login_required(func):
    def wrapper(*args, **kwargs):
        if not 'logged_in' in session:
            return redirect(url_for('index'))
        elif not session['logged_in']:
Ejemplo n.º 26
0
    print(request.cookies)
    return 'wam'


def sea():
    name = request.args.get('name')
    print('name  ----> {}'.format(name))
    return name

class A(object):
    x = 1
    gen = (lambda x: (x for _ in range(10)))(x)

if __name__ == '__main__':
    app.secret_key = '2e3ew8w4r4dod'
    app.session_cookie_name = 'u300000'
    from datetime import timedelta
    # session.permanent = True
    app.permanent_session_lifetime = timedelta(minutes=10)
    print(app.url_map)
    app.run(host='0.0.0.0', debug=True, port=3001, use_reloader=False)
    # use tornado container run flask app
    import tornado.wsgi
    import tornado.httpserver
    import tornado.ioloop
    import tornado.web
    from tornado.wsgi import WSGIContainer
    container = tornado.wsgi.WSGIContainer(app)
    server = tornado.httpserver.HTTPServer(container)
    # server.listen(8000)
    # tornado.ioloop.IOLoop.instance().start()
Ejemplo n.º 27
0
import stripe
import json
import os
import uuid

from flask import Flask, render_template, jsonify, request, session, send_from_directory
from dotenv import load_dotenv, find_dotenv

load_dotenv(find_dotenv())
stripe.api_key = os.getenv("STRIPE_SECRET_KEY")
app = Flask(__name__)

# session secret key
app.secret_key = "not so super secret key"
# session data to be persisted for 365 days
app.permanent_session_lifetime = datetime.timedelta(days=365)


@app.route("/")
def home():
    return render_template("index.html")


@app.route("/favicon.ico")
def favicon():
    return send_from_directory(os.path.join(app.root_path, "static"),
                               "favicon.ico")


@app.route("/cart", methods=["GET"])
def get_cart():
Ejemplo n.º 28
0
import sys
from datetime import timedelta
from flask import Flask
from flask_wtf.csrf import CSRFProtect
from config import ProductionConfig
from views.lib import Conn
import os

app = Flask(__name__)
app.secret_key = os.environ.get('SECRET_KEY') or os.urandom(64)
app.config.from_object(ProductionConfig)
csrf = CSRFProtect()
csrf.init_app(app)
Mongo = Conn.MongoDB(app.config.get('DB'), app.config.get('PORT'), app.config.get('DBNAME'),
                     app.config.get('DBUSERNAME'), app.config.get('DBPASSWORD'))
app.permanent_session_lifetime = timedelta(hours=6)
page_size = 30
sys.path.append(sys.path[0] + '/vulscan/vuldb/')
file_path = os.path.split(os.path.realpath(__file__))[0] + '/../vulscan/vuldb/'
Ejemplo n.º 29
0
from helpers.database import *
from helpers.reader import read
from obs.obsws import obs_connector

# This function is not yet ready.
# from helpers.pdf import render

# ########################################################### #
# #                     App Config                          # #
# ########################################################### #
app = Flask(__name__)
app.secret_key = b'aFvAUaVyaxW7ENbT4S2HDyQW3n0EEGnJYtehL9kG29LUaYWu56g4-KE5aZl3ck4xJkXEku4PoduaYK3k'
app.config["SECRET_KEY"] = 'aFvAUaVyaxW7ENbT4S2HDyQW3n0EEGnJYtehL9kG29LUaYWu56g4-KE5aZl3ck4xJkXEku4PoduaYK3k'
# Sets the secret key, used for signing sessions, and making sure they are not tampered with.

app.permanent_session_lifetime = timedelta(days=365)  # max time the session is stored.
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=365)

auth_key = 'Yv326fIgqRoZocoYo5jjU0OAR_rJe6LpzCkbAr6F'

# End Config
app.debug = False

for_testing_purpose = False


# ########################################################### #
# #                    Main application                     # #
# ########################################################### #
@app.route('/test')
def this_testing():
Ejemplo n.º 30
0
params = urllib.parse.quote_plus(
    "Driver={ODBC Driver 17 for SQL Server};Server=tcp:apiservice.database.windows.net,1433;Database=ApiService;Uid=apiserviceAdmin;Pwd=BenTeo18062416;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;"
)

app = Flask(__name__)
app.config[
    'SQLALCHEMY_DATABASE_URI'] = "mssql+pyodbc:///?odbc_connect=%s" % params
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)

FlaskUUID(app)
Bootstrap(app)

app.config['SECRET_KEY'] = 'EdrMedeso2020'
app.permanent_session_lifetime = datetime.timedelta(minutes=5)


def token_required(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        token = request.args.get('token')
        try:
            jwt.decode(token, app.config['SECRET_KEY'])
            return f(*args, **kwargs)
        except:
            return jsonify({'error':
                            'Need a valid token to view this page'}), 401

    return wrapper
Ejemplo n.º 31
0
limiter = Limiter(app, global_limits=['20 per minute'])

# Load configuration from the environment
secret_key = os.environ.get('SECRET_KEY')
signing_key = os.environ.get('SIGNING_KEY')
if not secret_key: raise Exception("SECRET_KEY not set")
if not signing_key: raise Exception("SIGNING_KEY not set")

app.config['SERVER_NAME'] = os.environ.get('SERVER_NAME')
app.config['SECRET_KEY'] = secret_key
app.config['BOT_NAME'] = 'edsgar'
app.config['SESSION_LIFETIME_DAYS'] = 90  # Used in a template

tokenizer = Tokenizer(signing_key)

app.permanent_session_lifetime = timedelta(
    days=app.config['SESSION_LIFETIME_DAYS'])


@app.before_request
def before_request():
    session.permanent = True


# This is needed because of a stupid, old bug in Flask
@app.errorhandler(400)
@app.errorhandler(401)
@app.errorhandler(404)
@app.errorhandler(429)
@app.errorhandler(500)
@app.errorhandler(Exception)
def show_error_page(error):
Ejemplo n.º 32
0
# -*- coding: utf-8 -*-
from flask import Flask,redirect,url_for,render_template,session,request
import os
import threading
import subprocess
import sys
from datetime import timedelta

app = Flask(__name__)
app.secret_key = os.urandom(24)
#session.permanent = True
app.permanent_session_lifetime = timedelta(minutes=30)

#消息循环队列初始化
cache_msg=['']*30
cache_msg_num=0

#配置初始化
try:
    import xml.etree.cElementTree as ET
except ImportError:
    import xml.etree.ElementTree as ET
configxml = ET.ElementTree(file='rmcsconfig.xml')
mcargs = configxml.find('mcargs').text
javaexe = configxml.find('javaexe').text
expires = configxml.find('expires').text

#启动进程
p = subprocess.Popen(mcargs, executable=javaexe, universal_newlines=True, stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE, shell = False)

Ejemplo n.º 33
0
Archivo: app.py Proyecto: iluddy/flock
from flask import got_request_exception
from celery import Celery
import __builtin__

# Argument parser
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("-c")
args = arg_parser.parse_args()

# Config
cfg = read_config_file(args.c)

# Create App
app = Flask(__name__, static_url_path='')
app.secret_key = SECRET_KEY
app.permanent_session_lifetime = SESSION_DURATION
documentor = Autodoc(app)
app.config['MONGODB_SETTINGS'] = {
    'db': cfg["database"]["name"],
    'host': cfg["database"]["host"],
    'port': cfg["database"]["port"]
}

# Celery
app.config['CELERY_BROKER_URL'] = cfg['redis']['url']
app.config['CELERY_RESULT_BACKEND'] = cfg['redis']['url']

def make_celery(app):
    celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL'])
    celery.conf.update(app.config)
    TaskBase = celery.Task
Ejemplo n.º 34
0
# log.setLevel(logging.DEBUG)
# log.addHandler(handler)

app.cache = redis.StrictRedis(**app.config.get('REDIS_CONFIG'))

app.cache.set("saDir", SA_DIR)
app.cache.set("uid_track", 1)
app.cache.set("session_data", {})

app.config['UPLOAD_FOLDER'] = os.path.dirname(os.path.abspath(__file__)) + SA_DIR
app.config['STATIC_FOLDER'] = os.path.dirname(os.path.abspath(__file__)) + '/static'

# app.session_interface = RedisSessionInterface(app.cache, key_prefix='SESSION')
app.session_interface = RedisSessionInterface(app.cache, key_prefix='SESSION',
                                            use_signer=True, permanent=False)
app.permanent_session_lifetime = datetime.timedelta(hours=1)

try:
    os.mkdir(SA_DIR)
except Exception as E:
    app.logger.info("[%s] mkdir() -- [%s] : %s" % \
                        (ctime(), SA_DIR, E))

# def reset_cache(sessionID):
#     session_data = {
#         "false_upload": True,
#         # "stdOut": '',
#         # "stdOut_conv": ''
#     }
#     app.cache.hmset("session_data:%s" % sessionID, session_data)
Ejemplo n.º 35
0
    return SECRETE_KEY


VARIFICATION_CODE = {"email": "nan", "code": generate_key()}


def encrpt(password):
    passwd = password.encode()
    salt = bcrypt.gensalt()
    hashed = bcrypt.hashpw(passwd, salt)
    return hashed


app = Flask(__name__)
app.secret_key = 'random string'
app.permanent_session_lifetime = timedelta(
    hours=5)  #save section for x mins/hours

#index_page


@app.route('/')
@app.route('/home')
def index():
    global PREVIOUS
    PREVIOUS = "team"
    return render_template('index.html')


@app.route("/check_otp", methods=['GET', 'POST'])
def check_otp():
    if request.method == 'POST':
Ejemplo n.º 36
0
#处理utf8编码,统一python2和python3的编码,两个版本测试通过
defaultencoding = 'utf-8'
if sys.getdefaultencoding() != defaultencoding:
    reload(sys)
    sys.setdefaultencoding(defaultencoding)


app = Flask(project_name)
app.config['SECRET_KEY'] = project_secret_key
app.debug = project_debug
# app.config['DEBUG'] = True
toolbar = DebugToolbarExtension(app)

#session过期时间10分钟
app.permanent_session_lifetime = datetime.timedelta(seconds=project_session_timeout)

#flask返回结果中支持中文
app.config['JSON_AS_ASCII'] = False

if os.path.exists('/var/log/flaskuserpwd.txt'):
    # print('文件存在,不需要再创建用户名和密码')
    pass
else:
    print('创建用户名和密码')

    username = ''.join(random.choice(string.ascii_lowercase) for _ in range(8))

    password = ''.join(random.choice(string.ascii_letters) for i in range(14))
    password = password[:7] + '#' + password[7:]
Ejemplo n.º 37
0
from datetime import timedelta

from flask import Flask, redirect, url_for, render_template
from mural import bp_home, bp_avisos, bp_noticias, bp_anuncios, bp_banner, bp_universidade, bp_usuarios, \
    bp_logs
from mural.mod_base.auth import SESSION_LIMIT, Auth
from mural.mod_base.base_model import error_404_response
from mural.mod_universidade import Universidade

app = Flask(__name__,
            template_folder='mural/templates',
            static_url_path='/static',
            static_folder='mural/static')

app.secret_key = b'_8#y2P"g8l1x\n\xec]/'
app.permanent_session_lifetime = timedelta(minutes=SESSION_LIMIT)


@app.context_processor
def inject_auth():
    universidade = Universidade()
    universidade.select(1)
    return dict(auth=Auth(), universidade=universidade)


@app.errorhandler(404)
def not_found(e):
    return error_404_response()


app.register_blueprint(bp_home)
Ejemplo n.º 38
0
from config import Config
from redis import Redis
from datetime import timedelta
import rq

app = Flask(__name__)
app.config.from_object(Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
bootstrap = Bootstrap(app)
moment = Moment(app)
login = LoginManager(app)
login.login_view = 'login'
login.login_message = 'Please log in to access this service.'
login.login_message_category = 'info'
app.permanent_session_lifetime = timedelta(
    minutes=app.config['SESSION_LIFETIME_MINUTES'])
app.redis = Redis.from_url(app.config['REDIS_URL'])
app.task_queue = rq.Queue('roulette-tasks', connection=app.redis)

from app import routes, models, errors

import logging
from logging.handlers import RotatingFileHandler
import os


def cleanup():
    pass


def startup():
Ejemplo n.º 39
0
from flask import Flask, redirect, flash, render_template, jsonify, session, url_for, request
from datetime import timedelta
from flask_sqlalchemy import SQLAlchemy
from CLIENT import Client
# ----global variables----
LenText = 3
LenPwd = 1
messages = []
clients = {}
username = ""
# -----creating heed-----
heed = Flask(__name__)
heed.secret_key = "heed"
heed.permanent_session_lifetime = timedelta(minutes=30)
# -----database-----
heed.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///chat.sqlite3'
heed.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
DataBase = SQLAlchemy(heed)

# ----- class to initialize and save in DataBase -----
class Users(DataBase.Model):
    _id = DataBase.Column("id", DataBase.Integer, primary_key=True)
    name = DataBase.Column(DataBase.String(100))
    username = DataBase.Column(DataBase.String(100))
    password = DataBase.Column(DataBase.String(100))
    email = DataBase.Column(DataBase.String(100))
    def __init__(self, name, username, password, email):
        self.name = name
        self.username = username
        self.password = password
Ejemplo n.º 40
0
from flask import g, current_app

DATABASE = './db.sqlite'
def get_db():
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = sqlite3.connect(DATABASE)
    return db

def parse_column_headers(res):
    return [r[0] for r in res.description]
# ========== for sqlite ==========

app=Flask(__name__) # 透過__name__確定app檔案位置,方便找到其他構成app的檔案
app.secret_key='hello' # session的key可隨意設定字串 
app.permanent_session_lifetime=timedelta(minutes=100) #設定session能夠被儲存在server上的時間

# conn=cx_Oracle.connect("Group6/[email protected]:1521/Group6",encoding="UTF-8")
# conn=cx_Oracle.connect('Group6', 'Group666', "140.117.69.58:1521/Group6",encoding="UTF-8")

# tns=cx_Oracle.makedsn('140.117.69.58',1521,'orcl')
# conn=cx_Oracle.connect('Group6','Group666',tns)
# conn = cx_Oracle.connect('Group6/[email protected]/Group6')

# ========== for sqlite ==========
@app.teardown_appcontext
def close_connection(exception):
    db = getattr(g, '_database', None)
    if db is not None:
        db.close()
# ========== for sqlite ==========
Ejemplo n.º 41
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author: cc
# @Date  :2019-04-12

import os
from datetime import timedelta

from flask import Flask

import pymysql
pymysql.install_as_MySQLdb()

app = Flask(__name__)

app.secret_key = 'zhBRxENODp7PqTqWNO7lj7wvgwPEgc'

prefix = 'sqlite:////'

app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv(
    'DATABASE_URL', prefix + os.path.join(app.root_path, 'ibook.db.sqlite'))
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

app.permanent_session_lifetime = timedelta(seconds=60)

from ibook import views, models
Ejemplo n.º 42
0
#coding: utf8
import os
from datetime import timedelta
from flask import Flask, session, render_template, request, redirect
import urllib

app = Flask(__name__)

app.secret_key = os.urandom(24)
app.permanent_session_lifetime = timedelta(seconds=30 * 24 * 60 * 60)


@app.route('/login')
def login():
    session.permanent = True
    referer = request.args.get('referer', None)
    if referer is not None:
        referer = referer.strip()
    if 'name' in session:
        if referer is not None:
            return redirect(referer + '?ticket=' + _makeTicket())
    return render_template('login.html', **dict(referer=referer))


@app.route('/dologin')
def doLogin():
    '''这里其实忽略了判断是否登录的流程'''
    session.permanent = True
    referer = request.args.get('referer', None)
    if referer is not None:
        referer = urllib.unquote(referer.strip())
Ejemplo n.º 43
0
    productname = brandinfo["Vendor"] + " " + brandinfo["ProductName"]
    lc = brandinfo["License"]
    print(productname)
    file.close()
with open("lang\\en-US.json", encoding="utf-8") as file:
    lang = json.load(file)
    file.close()
with open(lc, encoding="utf-8") as file:
    license1 = file.readlines()
    file.close()
app = Flask(__name__)
app.register_blueprint(apimodule, url_prefix="/api")
app.register_blueprint(oobeui, url_prefix="/oobe")
app.secret_key = "ThEMoSTSeCuRePassWORdINThEWorLD"
year = datetime.now().strftime('%Y')
app.permanent_session_lifetime = timedelta(days=10)
build = "0110"
branch = "centralbeta1_5.210906"
fullbuildname = build + "." + branch
hasher = Hashing()


@app.route('/license')
def license():
    return render_template("nano/license.html",
                           productname=productname,
                           year=year,
                           license=license1)


def gensession():
Ejemplo n.º 44
0
from flask import Flask, escape, request, render_template, url_for, flash, redirect, session, json
from flask_restful import Api, Resource, reqparse
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime, timedelta
import hashlib
app = Flask(__name__)
app.config["SECRET_KEY"] = "6810527e5f4636beca705e70625e96bc"
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///database.sqlite3"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.permanent_session_lifetime = timedelta(weeks=52)
api = Api(app)
db = SQLAlchemy(app)


###########################################################################
#FUNCTIONS
###########################################################################
def hash_password(password):
    return hashlib.sha256(password.encode('utf-8')).hexdigest()


def check_login():
    try:
        if User.query.filter_by(name=session["name"]).filter_by(
                password=session["password"]).first():
            return True
        return False
    except Exception:
        return False

Ejemplo n.º 45
0
import mysql.connector
from flask import (Flask, flash, redirect, render_template, request, session,
                   url_for)

import datetime

from Helper import DataSizeRange
from Helper import Generator as Gen
from Helper import Validator as Val

app = Flask(__name__)
app.debug = True
app.secret_key = "12345"  # use a better secret_key
app.templates_auto_reload = True
app.cache_type = "null"
app.permanent_session_lifetime = datetime.timedelta(hours=1)

DATABASE_NAME = "pill_code_db"  # mysql db_name
USERNAME = "******"
HOST = "localhost"
PASSWORD = ""


# function to read the article content and title
def read_title_and_post(article_id):

    try:
        id = article_id

        db_conn = mysql.connector.connect(host=HOST,
                                          user=USERNAME,
Ejemplo n.º 46
0
def create_app():
    app = Flask(__name__)

    # 初始化配置
    app.config.from_object(config)
    config.init_app(app)
    config_logging(app)

    # db配置
    db.init_app(app)

    # mongo
    mongo.init_app(app)

    # 控制器配置
    from controllers import default_blueprints
    for blueprint in default_blueprints:
        app.register_blueprint(blueprint)

    # 开启 CsrfProtect 模块
    csrf.init_app(app)

    @login_manager.user_loader
    def load_user(user_id):
        from models import User
        user = db.session.query(User).get(int(user_id))
        user.nickname = user.to_dict()['nickname']
        return user

    login_manager.init_app(app)
    # cookie有效期
    app.permanent_session_lifetime = datetime.timedelta(minutes=24 * 60)
    login_manager.remember_cookie_duration = datetime.timedelta(days=1)

    # 访问静态资源
    def public_file(filename):
        return send_from_directory(app.config.get("UPLOAD_FOLDER"), filename)

    app.add_url_rule("/public/<filename>", "public_file", build_only=True)

    app.wsgi_app = SharedDataMiddleware(
        app.wsgi_app, {"/public": app.config.get("UPLOAD_FOLDER")},
        cache=False
        # tips: http://stackoverflow.com/questions/11515804/zombie-shareddatamiddleware-on-python-heroku
    )

    # favicon.ico
    @app.route('/favicon.ico')
    def favicon():
        return send_from_directory(app.static_folder,
                                   'favicon.ico',
                                   mimetype='image/vnd.microsoft.icon')

    # Robots
    @app.route('/robots.txt')
    def robots():
        return send_from_directory(app.static_folder, 'robots.txt')

    # sitemap.xml
    @app.route('/sitemap<name>')
    def sitemap(name):
        return send_from_directory(app.static_folder, 'sitemap%s' % name)

    # 过滤器处理
    configure_template_filters(app)

    # 错误处理
    configure_error_handlers(app)

    return app
Ejemplo n.º 47
0
# Website by Ben Grudzien, refer to techwithtim

from flask import Flask, redirect, url_for, render_template, request, session, flash  # Allows for redirects, render function allows for external html
# Request determines GET or POST

from datetime import timedelta
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)  # Creating flask instance
app.secret_key = "password"  # could be any string lol, good to be complex (needed for session)
app.config[
    'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.sqlite3'  # User is table name
app.config["SQLALCHEMY_TRACK_MODIFCICATIONS"] = False  # gets rid of errors
app.permanent_session_lifetime = timedelta(
    minutes=5)  # Store log in session data from 5 days/mins

db = SQLAlchemy(app)


# Avoid quereies and writing this in python
class users(db.Model):
    _id = db.Column("id", db.Integer, primary_key=True)
    name = db.Column(db.String(100))
    email = db.Column(
        db.String(100))  # Adding string column to database called email

    def __init__(self, name, email):
        self.name = name
        self.email = email

Ejemplo n.º 48
0
        scheme = environ.get('HTTP_X_FORWARDED_PROTO')
        if scheme:
            environ['wsgi.url_scheme'] = scheme
        return self.app(environ, start_response)


app = Flask(__name__)
app.config['DEBUG'] = False
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MAX_CONTENT_LENGTH'] = 32 * 1024 * 1024  # 32 MB upload file max
app.config['UPLOAD_FOLDER'] = "/tmp/flask_uploads"
app.config['SESSION_PERMANENT'] = True
app.config["SESSION_COOKIE_NAME"] = "mynode_session_id"
app.secret_key = get_flask_secret_key()
timeout_days, timeout_hours = get_flask_session_timeout()
app.permanent_session_lifetime = timedelta(days=timeout_days,
                                           hours=timeout_hours)
app.register_error_handler(LoginError, handle_login_exception)

app.wsgi_app = ReverseProxied(app.wsgi_app)

my_logger = logging.getLogger('FlaskLogger')
my_logger.setLevel(logging.DEBUG)
handler = logging.handlers.RotatingFileHandler(filename='/var/log/flask',
                                               maxBytes=2000000,
                                               backupCount=2)
my_logger.addHandler(handler)
app.logger.addHandler(my_logger)
app.logger.setLevel(logging.INFO)

app.register_blueprint(mynode_bitcoin)
app.register_blueprint(mynode_lnd)
Ejemplo n.º 49
0
from datetime import timedelta, datetime
from random import random
from urllib.parse import urlparse, quote
from functools import wraps

import env_config as config
from fingerprint import FingerprintAgent, FingerprintRecorder, FingerprintHelper
from tracking import TrackingRecorder
from entropy_helper import EntropyHelper
from util import number_format, detect_browser_and_platform, get_tool_recommendation
from db import Db

app = Flask(__name__)
app.secret_key = config.secret_key
app.debug = config.debug
app.permanent_session_lifetime = timedelta(days=config.epoch_days)
app.config.update(
    USE_MATOMO=config.use_matomo,
    MATOMO_URL=config.matomo_url,
    MATOMO_SITE_ID=config.matomo_site_id,
)

if config.sentry_dsn:
    sentry_sdk.init(config.sentry_dsn, integrations=[FlaskIntegration()])


def read_keyfile():
    global key
    with open(
            config.keyfile,
            'rb',
Ejemplo n.º 50
0
#!/usr/bin/env python
# encoding: utf-8
'''
@author: chenc
@time: 2018/10/18 1:41 PM
@desc:
'''
# from flask import Blueprint, Flask
#
# # app = Blueprint('app', __name__,)
# app = Flask(__name__)
# # from app.user import views

from flask import Flask
import pymysql

from app import config
from app.echoImg.exts import db

pymysql.install_as_MySQLdb()

app = Flask(__name__)
# app.secret_key = "123asdzxc"
app.permanent_session_lifetime=60*60*2
app.config.from_object(config)
db.init_app(app)
Ejemplo n.º 51
0
                   url_for)
from os import getenv
import logging

from views import index, load, generate
import src.user as user

load_dotenv()
application = Flask(__name__)

application.logger.handlers = []
application.logger.addHandler(logging.StreamHandler())

application.secret_key = getenv('AUTH_KEY')
session_timeout = int(getenv('SESSION_TIMEOUT_IN_MINUTES'))
application.permanent_session_lifetime = timedelta(minutes=session_timeout)
user.initialize_users()

Database.initialize()

modules = [index, load, generate]
for module in modules:
    application.register_blueprint(module.routes)


def authorize(username, password):
    if not user.is_valid_login(username, password):
        return False
    session.permanent = True
    session['username'] = username
    return True
Ejemplo n.º 52
0
#!/usr/bin/python
#-*- coding: utf-8 -*-

from flask import Flask, jsonify, redirect, url_for, request
from datetime import timedelta
import json
import auth, config
import re

import vcl

app = Flask(import_name=__name__, static_folder='../static')
app.secret_key = config.secret_key
app.permanent_session_lifetime = timedelta(minutes=config.token_live_time)
auth = auth.ApiAuth()

@app.before_request
def before_request():
    if vcl.config.is_dev == False:
        url = str(request.url).replace(request.host_url, '')
        is_api = True if re.match(r'^api/', url) else False
        if is_api:
            auth.update_session_tbl();

@app.route('/')
@auth.login_required
def index():
    return redirect(url_for('static', filename='switch/index.html'))


@app.route('/api/token/', methods=['POST'])
Ejemplo n.º 53
0
"""
app.config['MAIL_SERVER'] = ""
app.config['MAIL_PORT'] = ""
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******' 

app.config['SQLALCHEMY_DATABASE_URI'] =\
	'sqlite:///' + os.path.join (basedir, 'data.sqlite')
#app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
#uncomment this line if you want to use Heroku, comment instead the one before it
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True

app.config['UPLOAD_FOLDER'] = './static/balls'

app.permanent_session_lifetime = timedelta(seconds=60)
app.config['SECRET_KEY'] = 'veryhard2guess'
#be more original

FTP_USER = '******'
FTP_PASS = '******'
FTP_HOST = 'ftp.ftp.com'
#again, environmental variables are preferred
manager = Manager(app)
bootstrap = Bootstrap(app)
db = SQLAlchemy(app)
mail = Mail(app)
db.drop_all()


login_manager = LoginManager()
Ejemplo n.º 54
0
# encoding: utf-8
from flask import Flask, request, render_template, redirect, session, flash
from Log_Analysis import GetTopN
from functools import wraps
import userdb as user
import datetime
from userdb import user_delete, change_user_password, get_accesslogs

app = Flask(__name__)
app.secret_key = '13123dfasdf'

# 设置session有效期是600秒
app.permanent_session_lifetime = datetime.timedelta(seconds=10 * 60)


# 登陆验证装饰器
def login_required(func):
    @wraps(func)
    def inner(*args, **kwargs):
        if not session:
            return redirect('/login/')
        ret = func(*args, **kwargs)
        return ret

    return inner


@app.route('/')
@login_required
def hello_world():
    title = '51Reboot'
Ejemplo n.º 55
0
import sys
from datetime import timedelta
from flask import Flask
from Config import ProductionConfig
from views.lib import Conn
import os

app = Flask(__name__)
app.secret_key = os.environ.get('SECRET_KEY') or os.urandom(64)
app.config.from_object(ProductionConfig)
Mongo = Conn.MongoDB(app.config.get('DB'), app.config.get('PORT'), app.config.get('DBNAME'),
                     app.config.get('DBUSERNAME'), app.config.get('DBPASSWORD'))
app.permanent_session_lifetime = timedelta(hours=6)
page_size = 60
sys.path.append(sys.path[0] + '/vulscan/vuldb/')
file_path = os.path.split(os.path.realpath(__file__))[0] + '/../vulscan/vuldb/'
Ejemplo n.º 56
0
if not os.path.exists(LOG_PATH):
    os.makedirs(LOG_PATH)

handler = RotatingFileHandler(LOG_PATH + '/debug.log',
                              maxBytes=10000,
                              backupCount=1)
handler.setFormatter(
    logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
#### initial logger ####

#### initial sesion ####
from datetime import timedelta
app.config['SECRET_KEY'] = 'random'
app.permanent_session_lifetime = timedelta(seconds=60 * 60 *
                                           10)  # session expire time
#### initial sesion ####

#### initial database ####
app.config.from_pyfile('config/database.cfg')
db.init_app(app)
#### initial database ####

#### router ####
from werkzeug.routing import Rule

urlpatterns = {
    Rule('/', endpoint='index'),
}

for rule in urlpatterns:
Ejemplo n.º 57
0
#"moron", "idiot", "fool"
#]

# The ideal tsundere greeting is cold and hostile while betraying a
# lingering sense of affection. Constantly search for it.

# Set up Flask app
app = Flask(__name__)

# Database URL, or sqlite in-memory database
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL')
# Secret key (for sessions/cookies)
app.secret_key = os.environ.get('SECRET_KEY') or 'yolodesu'

# Sessions last for 100 years
app.permanent_session_lifetime = timedelta(days=36500)

# Import the rest of the tsundiary stuff
from tsundiary.views import *
from tsundiary.models import User, db
from tsundiary.utils import their_date
import tsundiary.jinja_env

migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)

############
# App funcs

@app.before_request
Ejemplo n.º 58
0
from flask import Flask, redirect, url_for, render_template, request, session, flash
from datetime import timedelta
app = Flask(__name__)
app.secret_key = "Your Mom Ugly"
app.permanent_session_lifetime = timedelta(days=5)

@app.route('/')
def home():
    return render_template('home.html')

@app.route('/login', methods=['GET', 'POST'])
def login():
    error = None
    if request.method == 'POST':
        if request.form['username'] != 'admin' or request.form[
                'password'] != 'admin':
            error = 'Invalid Credentials. Please try again.'
        else:
            session['logged_in'] = True
            return redirect(url_for('welcome'))
    return render_template('login.html', error=error)

@app.route("/logout")
def logout():
    session.pop('logged_in', None)
    return redirect(url_for("login"))

@app.route("/admin")
def admin():
    return render_template('admin.html')
Ejemplo n.º 59
0
                    tree['children'].append(dict(name=fn.replace(
                        os.getcwd() + os.path.sep, "")))

    return tree


def d2d_close_instance(uid):

    while True:
        try:
            if d2d_instances[uid]['alive'] == 0:
                # clean up the global dicts, deletes the instances
                del(d2d_instances[uid])
                break

            d2d_instances[uid]['alive'] = 0
            time.sleep(SESSION_LIFETIME)
        except:
            print('Unable to shutdown thread ' + str(uid))
            break

if __name__ == "__main__":
    app.secret_key = os.urandom(24)
    app.permanent_session_lifetime = SESSION_LIFETIME
    app.debug = DEBUG
    app.json_encoder = plotly.utils.PlotlyJSONEncoder
    app.run(threaded=True,
            host="127.0.0.1",
            port=int("5000")
            )
Ejemplo n.º 60
0
# db = db(mySqluser, mySqlpasswd)
# print(db.insert("users", "email, passwd, username", "'*****@*****.**', 'joe', 'joe'"))

site = Flask(__name__)

site.register_blueprint(home)
site.register_blueprint(login)
site.register_blueprint(user)
site.register_blueprint(logout)
site.register_blueprint(signup)
site.register_blueprint(upload)
site.register_blueprint(voter)

with open("creds.json") as credsFile:
    creds = json.load(credsFile)
    key = creds["key"]

site.secret_key = key
site.permanent_session_lifetime = timedelta(days=7)

site.config['UPLOAD_FOLDER'] = "static\\uploads"
UPLOADED_FILES_DEST = "static\\uploads"
UPLOADS_DEFAULT_DEST = "static\\uploads"
# # fikse sesion
# lage sign up / login
# sette opp db mysql eller sqlalchemy ?


if __name__ == "__main__":
    site.run(debug=True)