Ejemplo n.º 1
0
def create_app(test_config=None):
    app = Flask(__name__)
    if not test_config:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)
    database = create_engine(app.config["DB_URL"],
                             encoding="utf-8",
                             max_overflow=0)  # 데이터베이스와 연결
    app.database = database  # Flask instance의 attribute로 가리킴

    @app.route("/ping", methods=["GET"])
    def ping():
        return ping
        return "pong"

    @app.route("/sign-up", methods=["POST"])
    def sign_up():
        new_user = request.json
        new_user_id = insert_user(new_user)
        new_user = get_user(new_user_id)
        return jsonify(new_user)

    @app.route("/tweet", methods=["POST"])
    def tweet():
        user_tweet = request.json
        tweet = user_tweet["tweet"]
        if len(tweet) > 300:
            return "300자를 초과했습니다", 400
        insert_tweet(user_tweet)
        return "", 200

    @app.route("/timeline/<int:user_id>", methods=["GET"])
    def timeline(user_id):
        return jsonify(dict(user_id=user_id, timeline=get_timeline(user_id)))
Ejemplo n.º 2
0
def create(config):
    """http://flask.pocoo.org/docs/patterns/appfactories/"""

    app = Flask(__name__.split('.')[0])

    # Load YAML config into app.config
    if not isinstance(config, dict):
        with open(os.path.join(app.instance_path, config)) as f:
            config = yaml.load(f)
    config.update({k.upper(): v for k, v in config["flask"].items()})
    app.config.update(config)
    del config
    
    # Configure logging
    logging.config.dictConfig(app.config["logging"])

    # Initialize database
    app.database = Database(app)

    # Load blueprints
    from .views.submit import submit
    app.register_blueprint(submit)

    if False and app.debug:
        app.logger.warning("Debug mode is on. Do not use this in production.")
        from .views.debug import debug
        app.register_blueprint(debug)

    return app
Ejemplo n.º 3
0
def create(config):
    """http://flask.pocoo.org/docs/patterns/appfactories/"""

    app = Flask(__name__.split('.')[0])

    # Load YAML config into app.config
    if not isinstance(config, dict):
        with open(os.path.join(app.instance_path, config)) as f:
            config = yaml.load(f)
    config.update({k.upper(): v for k, v in config["flask"].items()})
    app.config.update(config)
    del config

    # Configure logging
    logging.config.dictConfig(app.config["logging"])

    # Initialize database
    app.database = Database(app)

    # Load blueprints
    from .views.submit import submit
    app.register_blueprint(submit)

    if False and app.debug:
        app.logger.warning("Debug mode is on. Do not use this in production.")
        from .views.debug import debug
        app.register_blueprint(debug)

    return app
Ejemplo n.º 4
0
def create_app(test_config=None):
    app = Flask(__name__)

    app.json_encoder = CustomJSONEncoder

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)
    app.database = database

    # ping
    @app.route("/ping", methods=['GET'])
    def ping():
        return "pong"

    # 회원가입 엔드포인트
    @app.route("/sign-up", methods=['POST'])
    def sign_up():
        new_user = request.json
        new_user_id = insert_user(new_user)
        new_user = get_user(new_user_id)

        return jsonify(new_user)

    @app.route('/tweet', methods=['POST'])
    def tweet():
        user_tweet = request.json
        tweet = user_tweet['tweet']

        if len(tweet) > 300:
            return '300자를 초과했습니다', 400

        insert_tweet(user_tweet)

        return '', 200

    @app.route('/timeline/<int:user_id>', methods=['GET'])
    def timeline(user_id):
        return jsonify({'user_id': user_id, 'timeline': get_timeline(user_id)})

    @app.route('/follow', methods=['POST'])
    def follow():
        payload = request.json
        insert_follow(payload)

        return '', 200

    @app.route('/unfollow', methods=['POST'])
    def unfollow():
        payload = request.json
        insert_unfollow(payload)

        return '', 200

    return app
Ejemplo n.º 5
0
def create_app():
    app = Flask(__name__)
    app.config.from_pyfile('config.py')

    database = create_engine(app.config['DB_URL'], encoding='utf-8')
    app.database = database

    @app.route('/sign-up', methods=['POST'])
    def sign_up():
        user = request.json
        user_id = app.database.execute(
            text("""
                                                INSERT INTO user (
                                                email,
                                                password
                                               ) VALUES (
                                                :email,
                                                :password
                                               )
                                                """), user).lastrowid

        return "", 200

    from .views import main_views
    app.register_blueprint(main_views.bp)

    return app
Ejemplo n.º 6
0
def create_app(test_config=None):
    app = Flask(__name__)

    CORS(app)
    app.json_encoder = CustomJSONEncoder

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config["DB_URL"],
                             encoding="utf-8",
                             max_overflow=0)
    app.database = database

    @app.route("/find-single/<string:index>", methods=["GET"])
    def findSingle(index):
        # result = bf.findBetween("창",1, 2, 5)
        # return result[0]['text']
        result = bf.findByIndex(index)
        return makeTr(result[0])

    @app.route("/remember", methods=["GET"])
    def remember():
        num = random.randrange(0, len(list))
        dict = list[num]
        dict['index'] = num
        return json.dumps(dict)

    @app.route("/remember/answer", methods=["POST"])
    def rememberAnswer():
        num = {"num": random.randint(1, 12)}
        return json.dumps(num)

    @app.route("/json/find-single/<string:index>", methods=["GET"])
    def jsonFindSingle(index):
        result = bf.findByIndex(index)
        return json.dumps(result[0])

    @app.route("/json/find-between", methods=["GET"])
    def jsonFindBetween():
        book = request.args.get('book', default="창", type=str)
        chapter = request.args.get('chapter', default=1, type=int)
        verseFrom = request.args.get('verseFrom', default=1, type=int)
        verseTo = request.args.get('verseTo', default=1, type=int)
        verses = bf.findBetween(book, chapter, verseFrom, verseTo)
        return json.dumps(verses)

    @app.route("/find-between", methods=["GET"])
    def findBetween():
        book = request.args.get('book', default="창", type=str)
        chapter = request.args.get('chapter', default=1, type=int)
        verseFrom = request.args.get('verseFrom', default=1, type=int)
        verseTo = request.args.get('verseTo', default=1, type=int)
        verses = bf.findBetween(book, chapter, verseFrom, verseTo)
        return makeTable(verses)

    return app
Ejemplo n.º 7
0
def create_app(cfg='dev'):
    app = Flask(__name__)
    CORS(app)
    config = config_meta.get(cfg)
    app.config.from_object(config)
    app.database = connect_to_db(app.config)
    create_tables(app.database)
    return app
Ejemplo n.º 8
0
def create_app(test_config=None, instance_relative_config=True):

    app = Flask(__name__)  # create flask application
    cors = CORS(app)
    app.config.from_mapping(  #dev environment
        SECRET_KEY='dev')

    app.config['CORS_HEADERS'] = 'Content-Type'

    app.config['MYSQL_HOST'] = 'remotemysql.com'
    app.config['MYSQL_USER'] = '******'
    app.config['MYSQL_PASSWORD'] = '******'
    app.config['MYSQL_DB'] = 'fhiZCqtsqe'
    app.config['MYSQL_CURSORCLASS'] = 'DictCursor'

    app.database = MySQL(
        app
    )  #we assign the mysql object to app.database here, we cannot create the object after any
    #request made, this will throw an error. We need to create in the beginning only

    try:  #when instance_relative_config = True (look at the parameter)
        os.makedirs(
            app.instance_path
        )  #app.instance_path -> all the config details are stored. I dont know what config details
    except OSError:  #if we are using a local db, it would be stored here.
        pass

    from . import db  #We initialize app related stuff here -> go to db file for more details
    db.init_app(
        app
    )  # we are basically calling the init_app() function from here by importing it

    from . import auth  # Here, auth contains some functions which can be classified as a view of specific type
    app.register_blueprint(
        auth.bp
    )  # NOT MVC VIEW. Here, view is basically a set of related events that can happen
    #like, authentication can be one view and you can have other such views
    # here, view name is bp
    #We are telling flask that, the view bp belongs to this particular object 'app', and when we
    # do this, by default , all the functions that route using 'bp' get registered to this
    # particular object

    from . import view  # same as before. This is another view
    app.register_blueprint(view.vw)

    from . import user
    app.register_blueprint(user.ur)

    from . import genres
    app.register_blueprint(genres.genre)

    from . import friends
    app.register_blueprint(friends.friend)

    from . import book
    app.register_blueprint(book.bk)

    return app
def create_app(test_config=None):
    app = Flask(__name__)

    app.json_encoder = CustomJSONEncoder

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config["DB_URL"],
                             encoding="utf-8",
                             max_overflow=0)
    app.database = database

    @app.route("/ping", methods=["GET"])
    def ping():
        return "pong"

    @app.route("/sign-up", methods=["POST"])
    def sign_up():
        new_user = request.json
        new_user_id = insert_user(new_user)
        new_user = get_user(new_user_id)

        return jsonify(new_user)

    @app.route("/tweet", methods=["POST"])
    def tweet():
        user_tweet = request.json
        tweet = user_tweet["tweet"]

        if len(tweet) > 300:
            return "300자를 초과 했습니다", 400

        insert_tweet(user_tweet)

        return "", 200

    @app.route("/follow", methods=["POST"])
    def follow():
        payload = request.json
        insert_follow(payload)

        return "", 200

    @app.route("/unfollow", methods=["POST"])
    def unfollow():
        payload = request.json
        insert_unfollow(payload)

        return "", 200

    @app.route("/timeline/<int:user_id>", methods=["GET"])
    def timeline(user_id):
        return jsonify({"user_id": user_id, "timeline": get_timeline(user_id)})

    return app
Ejemplo n.º 10
0
def create_app(test_config=None):
    print("FLASK IS LOADING...")
    app = Flask(__name__)
    app.json_encoder = CustomJSONEncoder

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(
        'mysql+mysqlconnector://root:password@localhost:3306/miniter?charset=utf8',
        encoding='utf-8',
        max_overflow=0)
    app.database = database

    @app.route("/sign-up", methods=['POST'])
    def sign_up():
        new_user = request.json
        new_user_id = app.database.execute(
            text("""
            INSERT INTO users(
             name,
             email,
             profile,
                hashed_password
             ) VALUES (
              :name,
             :email,
             :profile,
             :password
             )
             """), new_user).lastrowid
        row = app.database.execute(
            text("""
            SELECT 
            id,
            name,
            email,
            profile 
            FROM uesrs
            WHERE id = :userid
            """), {
                'user_id': new_user_id
            }).fetchone()

        created_user = {
            'id': row['id'],
            'name': row['name'],
            'email': row['email'],
            'profile': row['profile'],
        } if row else None

        return jsonify(created_user)

    return app
Ejemplo n.º 11
0
def create_app(test_config=None):  # 1)
    app = Flask(__name__)
    app.json_encoder = CustomJSONEncoder
    if test_config is None:  # 2)
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)  # 3)
    app.database = database  # 4)

    @app.route("/sign-up", methods=['POST'])
    def sign_up():
        new_user = request.json
        sql = "INSERT INTO " + "users(name,email,profile,hashed_password)" + "VALUES (:name,:email,:profile,:password)"
        new_user_id = app.database.execute(text(sql), new_user).lastrowid  # 2)

        return jsonify(new_user_id)

    @app.route('/tweet', methods=['POST'])
    def tweet():
        user_tweet = request.json
        tweet = user_tweet['tweet']

        sql = "INSERT INTO" + "tweets(user_id, tweet)" + " VALUES (:id,:tweet)"

        if len(tweet) > 300:
            return '300자를 초과했습니다', 400

        app.database.execute(text(sql), user_tweet)  # 2)

        return '', 200

    @app.route('/timeline/<int:user_id>', methods=['GET'])
    def timeline(user_id):
        sql = "SELECT t.user_id, t.tweet " + "FROM tweets t" +\
              " LEFT JOIN users_follow_list ufl ON ufl.user_id = :user_id"+ \
              "WHERE t.user_id = :user_id" + " OR t.user_id = ufl.follow_user.id"
        rows = app.database.execute(text(sql), {'user_id': user_id}).fetchall()

        timeline = [
            {  # 2)
                'user_id': row['user_id'],
                'tweet': row['tweet']
            } for row in rows
        ]

        return jsonify({  # 3)
            'user_id': user_id,
            'timeline': timeline
        })

    return app
Ejemplo n.º 12
0
def create_app(test_config=None):
    app = Flask(__name__)

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)
    app.database = database

    @app.route("/sign-up", methods=['POST'])
    def sign_up():
        new_user = request.json
        new_user_id = app.database.execute(
            text(""" 	# 1)
            INSERT INTO users(
                name,
                email,
                profile,
                hashed_password
            ) VALUES (
                :name,
                :email,
                :profile,
                :password
            )
        """), new_user).lastrowid  # 2)

        row = current_app.database.execute(
            text("""
            SELECT
                id,
                name,
                email,
                profile
            FROM users
            WHERE id =:user_id
        """), {
                'user_id': new_user_id
            }).fetchone()  # 3)

        created_user = {  # 4)
            'id': row['id'],
            'name': row['name'],
            'email': row['email'],
            'profile': row['profile']
        } if row else None

        return jsonify(created_user)

    return app
Ejemplo n.º 13
0
def create_app(test_config=None):
    app = Flask(__name__)

    if test_config is None:
        app.config.from_pyfile("dbconfig.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config["DB_URL"],
                             encoding="UTF-8",
                             max_overflow=0)
    app.database = database

    @app.route("/sign-up", methods=["POST"])
    def sign_up():
        print(request.json)
        new_user = request.json
        new_user_id = insert_user(new_user)
        new_user = get_user(new_user_id)

        return jsonify(new_user)

    @app.route("/tweet", methods=["POST"])
    def tweet():
        user_tweet = request.json
        tweet = user_tweet["tweet"]

        if len(tweet) > 300:
            return "300자를 초과하였습니다.", 400

        insert_tweet(user_tweet)

        return "트윗이 등록되었습니다.", 200

    @app.route("/follow", methods=["POST"])
    def follow():
        payload = request.json
        insert_follow(payload)

        return "팔로워가 등록되었습니다.", 200

    @app.route("/unfollow", methods=["POST"])
    def unfollow():
        payload = request.json
        remove_follow(payload)

        return "팔로워가 삭제되었습니다.", 200

    @app.route("/timeline/<int:user_id>", methods=["GET"])
    def timeline(user_id):
        return jsonify({"user_id": user_id, "timeline": get_timeline(user_id)})

    return app
Ejemplo n.º 14
0
def create_app(test_config = None):
    app = Flask(__name__)
    
    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.from_pyfile(test_config)
        
    database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0)
    app.database = database
    
    return app
Ejemplo n.º 15
0
def create_app(test_config=None):  # 1)
    app = Flask(__name__)
    app.json_encoder = CustomJSONEncoder
    if test_config is None:  # 2)
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)  # 3)
    app.database = database  # 4)

    return app
Ejemplo n.º 16
0
def create_app(test_config=None):
    app = Flask(__name__)
    api = Api(app)
    app.config['ERROR_404_HELP'] = False

    if test_config is None:
        app.config.from_pyfile("./db/config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)
    app.database = database

    api.add_namespace(Test, '/test')
    api.add_namespace(User, '/user')

    return app
Ejemplo n.º 17
0
def create_app(config_name):
    """
    Usage: Factory function used to setup the application instance
    :return: application instance
    """
    app = Flask(__name__)
    app.database = database
    app.current_user = current_user
    app.config.from_object(config[config_name])
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(username):
        for user in app.database:
            if user.username == username:
                return user

    from . import views
    app.register_blueprint(views.views)
    return app
Ejemplo n.º 18
0
def create_app(config_name):
    """
    Usage: Factory function used to setup the application instance
    :return: application instance
    """
    app = Flask(__name__, template_folder='../api_docs')
    app.database = DATABASE
    app.config.from_object(config[config_name])
    app.config['BUNDLE_ERRORS'] = True

    @app.route('/')
    def api_docs():
        """ Route to the api docs"""
        from flask import render_template
        return render_template('api.html')

    # Register Blueprint here
    app.register_blueprint(v1, url_prefix="/api/v1")

    return app
Ejemplo n.º 19
0
def create_app(config_name):
    """
    Usage: Factory function used to setup the application instance
    :return: application instance
    """
    app = Flask(__name__)
    app.database = database
    app.config.from_object(config[config_name])
    app.config['JWT_SECRET_KEY'] = 'super-secret'
    app.config['JWT_BLACKLIST_ENABLED'] = True
    app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access', 'refresh']
    app.jwt = JWTManager(app)
    app.blacklist = set()

    @app.jwt.token_in_blacklist_loader
    def check_if_token_in_blacklist(decrypted_token):
        jti = decrypted_token['jti']
        return jti in app.blacklist

    app.register_blueprint(v1, url_prefix="/api/v1")
    return app
Ejemplo n.º 20
0
def create_app():
    application = Flask(__name__)
    if os.environ.get('APP_ENV') == 'prod':
        print('prod')
        application.config.from_object('config_prod')
    elif os.environ.get('APP_ENV') == 'dev':
        print('dev')
        application.config.from_object('config_dev')
    else:
        print('local')
        application.config.from_object('config_local')
        print("SECRET_KEY : ", application.config.get("SECRET_KEY"))

    application.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    # application.secret_key = 'samplewithflask'

    CORS(application, supports_credentials=True)
    configure_extensions(application)

    # TODO DB Pool 설정
    database = create_engine(application.config['DB_URL'], encoding='utf-8')
    application.database = database


    CORS(application, supports_credentials=True)

    @application.route('/sign-up', methods=['POST'])
    def sign_up():
        user = request.json
        user_id = app.database.execute(text("""
                                            INSERT INTO user(
                                                email,
                                                password
                                            ) VALUE (
                                                :email,
                                                :password
                                            )
                                            """), user).lastrowid
        return "OK", 200
    return application
Ejemplo n.º 21
0
def create_app(test_config=None):
    app = Flask(__name__)
    app.run(host='0.0.0.0', port=8080)

    app.json_encoder = CustomJSONEncoder

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)
    app.database = database

    @app.route("/ping", methods=['GET'])
    def ping():
        return "pong"

    @app.route("/update", methods=['POST'])
    def update():
        req = requests.get(
            'http://openapi.seoul.go.kr:8088/414a5975666b796a3132324142416376/json/culturalEventInfo/1/1'
        )
        originList = req.json
        info = insert_origin(originList)
        cinfo = get_origin(info)

        return jsonify(cinfo)

    @app.route("/preference", methods=['POST'])
    def preference():
        new_prefernce = request.json
        new_prefernce_id = insert_prefernce(new_prefernce)
        new_prefernce = get_prefernce(new_prefernce_id)

        return jsonify(new_prefernce)

    return app
Ejemplo n.º 22
0
def create_app():  #flask run 했을 경우 자동 실행
    app = Flask(__name__)
    #Flask class 객체화 -> 이  app 변수가 Flask 웹 API애플리케이션이다
    #app 변수에 API설정과 엔드포인트들을 추가하면 APi 완성

    database = create_engine(db_url, encoding='utf-8', max_overflow=0)
    app.database = database

    @app.route("/score", methods=['GET'])
    #Flask의 route 데코레이터 사용해서 엔드포인트 등록. score함수를 엔드포인트 함수로 등록
    #고유주소=score,method=GET
    def score():  #user table을 보여주는 함수
        result = app.database.execute(text("""SELECT * FROM user;"""))
        row = result.fetchone()

        return jsonify(row._mapping['id'])

    #@app.route("/ping",methods=["GET"])
    #def ping():
    #return "pong"

    return app
Ejemplo n.º 23
0
def application(database_uri,
                exclude_tables=[],
                include_models=[],
                read_only=True,
                schema=None):
    """Return an application instance connected to the database described in
    *database_uri*.

    :param str database_uri: The URI connection string for the database
    :param list exclude_tables: A list of tables to exclude from the API
                                service
    :param list include_models: A list of user-defined models to include in the
                             API service
    :param bool read_only: Only allow HTTP GET commands for all endpoints
    :param str schema: Use the specified named schema instead of the default
    """
    app = Flask('flask_sandman')
    app.config['SQLALCHEMY_DATABASE_URI'] = database_uri
    app.config['SANDMAN2_READ_ONLY'] = read_only
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.classes = []
    # Database
    from .database import DATABASE as db
    db.init_app(app)
    app.database = db
    # Administration
    from .admin import administration
    # admin = Admin(app, base_template = 'layout.html', template_mode = 'bootstrap3')
    admin = administration(app)
    # Sandman
    sandman(app,
            database=db,
            include_models=include_models or [],
            exclude_tables=exclude_tables or [],
            read_only=read_only,
            admin=admin,
            schema=schema)
    return app
Ejemplo n.º 24
0
def create_app(test_config=None):
    app = Flask(__name__)
    app.json_encoder = CustomJSONEncoder

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

#생성한 Engin 객체를 Flask 객체에 저장
    database = create_engine(app.config['DB_URL'], encoding='utf-8')
    app.database = database

    # @app.route("/sign-up",methods=['post'])
    # def sign_up():
    #     new_user = request.json
    #     new_user_id = app.database.execute(text
    #     ("""
    #     Insert into users(name,email,profile,hashed_password) values (:name, :email, :profile, :password)
    #     """),new_user).lastrowid
    #     row = current_app.database.execute(text
    #     ("""
    #     select id, name,email,profile from users where id = :user_id
    #     """),{'user_id':new_user_id}).fetchone()

    #     created_user = {
    #     'id':row['id'],
    #     'name':row['name'],
    #     'email':row['email'],
    #     'profile':row['profile']
    #     }if row else None

    #     return jsonify(created_user)

    #Flask 객체를 리턴.create_app 이라는 함수는 Flask가 자동 인지하여 Flask 객체를 찾아서 실행
    return app
Ejemplo n.º 25
0
def create_app(test_config=None):
    app = Flask(__name__)

    CORS(app)

    app.json_encoder = CustomJSONEncoder

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)
    app.database = database

    @app.route("/ping", methods=['GET'])
    def ping():
        return "pong"

    @app.route("/sign-up", methods=['POST'])
    def sign_up():
        new_user = request.json
        new_user['password'] = bcrypt.hashpw(
            new_user['password'].encode('UTF-8'), bcrypt.gensalt())

        new_user_id = insert_user(new_user)
        new_user = get_user(new_user_id)

        return jsonify(new_user)

    @app.route('/login', methods=['POST'])
    def login():
        credential = request.json
        email = credential['email']
        password = credential['password']
        user_credential = get_user_id_and_password(email)

        if user_credential and bcrypt.checkpw(
                password.encode('UTF-8'),
                user_credential['hashed_password'].encode('UTF-8')):
            user_id = user_credential['id']
            payload = {
                'user_id': user_id,
                'exp': datetime.utcnow() + timedelta(seconds=60 * 60 * 24)
            }
            token = jwt.encode(payload, app.config['JWT_SECRET_KEY'], 'HS256')

            return jsonify({
                'user_id': user_id,
                'access_token': token.decode('UTF-8')
            })
        else:
            return '', 401

    @app.route('/tweet', methods=['POST'])
    @login_required
    def tweet():
        user_tweet = request.json
        user_tweet['id'] = g.user_id
        tweet = user_tweet['tweet']

        if len(tweet) > 300:
            return '300자를 초과했습니다', 400

        insert_tweet(user_tweet)

        return '', 200

    @app.route('/follow', methods=['POST'])
    @login_required
    def follow():
        payload = request.json
        payload['id'] = g.user_id

        insert_follow(payload)

        return '', 200

    @app.route('/unfollow', methods=['POST'])
    @login_required
    def unfollow():
        payload = request.json
        payload['id'] = g.user_id

        insert_unfollow(payload)

        return '', 200

    @app.route('/timeline/<int:user_id>', methods=['GET'])
    def timeline(user_id):
        return jsonify({'user_id': user_id, 'timeline': get_timeline(user_id)})

    @app.route('/timeline', methods=['GET'])
    @login_required
    def user_timeline():
        user_id = g.user_id

        return jsonify({'user_id': user_id, 'timeline': get_timeline(user_id)})

    return app
Ejemplo n.º 26
0
def create_app(test_config=None):
    app = Flask(__name__)

    CORS(app)

    if not test_config:
        app.config.from_pyfile("config.py")
    else:
        app.config.update(test_config)

    database = create_engine(app.config["DB_URL"], encoding="utf-8", max_overflow=0)  # 데이터베이스와 연결
    app.database = database  # Flask instance의 attribute로 가리킴
    app.config["JWT_SECRET_KEY"] = "boseop"

    @app.route("/ping", methods=["GET"])
    def ping():
        return "pong"

    @app.route("/sign-up", methods=["POST"])
    def sign_up():
        new_user = request.json
        new_user["password"] = bcrypt.hashpw(password=new_user["password"].encode("utf-8"),
                                             salt=bcrypt.gensalt())
        new_user_id = insert_user(new_user)
        new_user = get_user(new_user_id)
        return jsonify(new_user)

    @app.route("/login", methods=["POST"])
    def login():
        credential = request.json
        email = credential["email"]
        password = credential["password"]
        user_credential = get_user_id_and_password(email)

        if user_credential and bcrypt.checkpw(password=password.encode("utf-8"),
                                              hashed_password=user_credential["hashed_password"].encode("utf-8")):
            user_id = user_credential["id"]
            payload = {
                "user_id": user_id,
                "exp": datetime.utcnow() + timedelta(seconds = 60 * 60 * 24)
            }
            token = jwt.encode(payload=payload,
                               key=app.config["JWT_SECRET_KEY"],
                               algorithm="HS256")
            return jsonify({
                "access_token": token.decode("utf-8")
            })
        else:
            return "", 401

    @app.route("/tweet", methods=["POST"])
    @login_required
    def tweet():
        user_tweet = request.json
        user_tweet['id'] = g.user_id
        tweet = user_tweet["tweet"]

        if len(tweet) > 300:
            return "300자를 초과했습니다", 400

        insert_tweet(user_tweet)

        return "", 200

    @app.route("/timeline/<int:user_id>", methods=["GET"])
    def timeline(user_id):
        return jsonify(dict(user_id=user_id, timeline=get_timeline(user_id)))

    @app.route("/timeline", methods=["GET"])
    @login_required
    def user_timeline():
        user_id = g.user_id

        return jsonify({
            "user_id": user_id,
            "timeline": get_timeline(user_id)
        })

    @app.route("/follow", methods=["POST"])
    @login_required
    def follow():
        payload = request.json
        payload['id'] = g.user_id
        insert_follow(payload)
        return "", 200

    @app.route("/unfollow", methods=["POST"])
    @login_required
    def unfollow():
        payload = request.json
        payload['id'] = g.user_id

        insert_unfollow(payload)
        return "", 200

    return app  # Flask instance를 return
Ejemplo n.º 27
0
from flask import Flask, render_template, redirect, url_for, request, session, flash, g
from functools import wraps
import sqlite3

app = Flask(__name__)

# configuration variable
app.secret_key = 'my password'
app.database = "sample.db"


# login required decorator
def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            flash('You need to login first.')
            return redirect(url_for('login'))
    return wrap

# set up first route with a decorator 

@app.route('/')
@login_required 
def home():
    #return "Hello world"
    # g is specific to flask to store a temporary task
    g.db = connect_db() # this creates the connection object
    cur = g.db.execute('select * from posts')
Ejemplo n.º 28
0
from flask import Flask, render_template, g
#Import SQLlite for database
import sqlite3

app = Flask(__name__)

#Setup Database
app.database = "M2MWebsite/sample.db"

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

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

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

@app.route('/users/')
def users():
    #Create temporary connection object
    g.db = connect_db()
    #query the database
    cur = g.db.execute('select * from users')
    #Cast data to dictionary
    users = [dict(id=row[0],cardID=row[1],name=row[2],credit=row[3],bottles=row[4]) for row in cur.fetchall()]
    #Close database connection
    g.db.close()
Ejemplo n.º 29
0
from flask import Flask, render_template, url_for, g
import sqlite3

app = Flask(__name__)

app.database = "familjen.db"


def connect_db():
	return sqlite3.connect(app.database)

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

@app.route('/members')
def members():
	g.db = connect_db()
	cur = g.db.execute('select * from members')
	members = [dict(imageref=row[0], name=row[1], about=row[2], joined=row[3]) for row in cur.fetchall()]
	g.db.close()
	return render_template('members.html', members = members)

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

@app.route('/activities')
def activities():
	g.db = connect_db()
	cur = g.db.execute('select * from parties')
Ejemplo n.º 30
0
from flask import Flask, render_template, redirect, url_for, request, session, flash, g
from functools import wraps
import sqlite3


app = Flask(__name__)

app.secret_key = "my precious"
app.database = "flask.db"


def login_required(test):
	@wraps(test)
	def wrap(*args, **kwargs):
		if 'logged_in' in session:
			return test(*args, **kwargs)
		else:
			flash('You need to login first.')
			return redirect(url_for('login'))
	return wrap

@app.route('/')
@login_required
def home():
        g.db = connect_db()
        query = g.db.execute('SELECT * FROM posts')
        posts = [dict(title=row[0], description=row[1]) for row in query.fetchall()]
        g.db.close()
        return render_template('index.html',posts=posts)

@app.route('/welcome')
Ejemplo n.º 31
0
from mapping_model import Property, Image
from sqlalchemy.orm import scoped_session, sessionmaker, Query
from sqlalchemy.orm import relationship, backref
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import join



app = Flask(__name__)


#Next was the original database
#app.database = "realstate.db"
#Next is the database created with flask admin
app.database = "propertyRS.db"

app.secret_key = "xcFtjs3Ji896Ghm"

#Next lines are for SQL Alchemy use
engine = create_engine("sqlite:////tmp/propertyRS.db")
Base = declarative_base()
Base.metadata.reflect(engine)



@app.route('/', methods=['GET', 'POST'])
def home():
	if request.method == 'POST':		
		if request.form['state'] != "" :	
			stateValue = request.form['state']
Ejemplo n.º 32
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-


from flask import Flask, render_template, redirect, url_for, request, session, flash, g
from functools import wraps
import sqlite3

app = Flask(__name__)
app.secret_key = 'a secret key'
app.database = 'blog.db'

def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            flash('Enter username and password.')
            return redirect(url_for('login'))
    return wrap

@app.route('/')
@login_required
def home():
    g.db = connect_db()
    cur = g.db.execute('select * from posts')
    posts = [dict(title=row[0], description=row[1]) for row in cur.fetchall()]
    g.db.close()
    return render_template('index.html', posts=posts)  
    
Ejemplo n.º 33
0
from flask import Flask, request, render_template, g
import sqlite3 as sl
import os
from twilio.rest import TwilioRestClient

app = Flask(__name__)

sec_k = os.urandom(24)
app.secret_key = sec_k

app.database = "reg.db"

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

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

@app.route('/request_handler', methods=['GET', 'POST'])
def request_handler():
	name = request.form['yourname']
	email = request.form['youremail']
	num = request.form['yournum']
	g.db = connect_db()
	params = (str(name), str(email), str(num))
	curr = g.db.cursor()
	curr.execute("INSERT INTO registrations VALUES (?, ?, ?)", params)
	cur = g.db.execute('SELECT * FROM registrations')
	regs = [dict(name=row[0], email=row[1], phone=row[2]) for row in cur.fetchall()]
Ejemplo n.º 34
0
def create_app(test_config=None):
    app = Flask(__name__)
    app.debug = True

    if test_config is None:
        app.config.from_pyfile("config.py")
    else:
        print(f"test config == {test_config}")
        app.config.update(test_config)

    database = create_engine(app.config['DB_URL'],
                             encoding='utf-8',
                             max_overflow=0)
    app.database = database

    CORS(app)

    @app.route('/ping', methods=['GET'])
    def ping():
        return jsonify('{"name" : "pong"}')

    @app.route('/users', methods=['GET'])
    @login_required
    @vip_required
    def all_users():
        rows = database.execute(
            text("""
       SELECT
           u.id,
           u.name,
           u.email,
           accnt.account_type
       FROM users as u
       JOIN accounts accnt ON u.account_id = accnt.id
       """)).fetchall()
        if rows is None:
            return '', 404
        return jsonify([{
            'id': row['id'],
            'name': row['name'],
            'email': row['email'],
            'account_type': row['account_type']
        } for row in rows])

    @app.route('/user/<int:id>', methods=['GET'])  ## /user/1
    def get_user(id):
        sql = text("""
           SELECT
               u.id,
               u.name,
               u.email,
               accnt.account_type
           FROM users as u
           JOIN accounts accnt ON u.account_id = accnt.id
           WHERE u.id = :id
           """)

        parameters = {'id': id}
        row = database.execute(sql, parameters).fetchone()

        return jsonify({
            'id': row['id'],
            'name': row['name'],
            'email': row['email'],
            'account_type': row['account_type']
        }) if row else ('', 404)

    @app.route('/login', methods=['POST'])
    def login():
        credential = request.json
        email = credential['email']
        password = credential['password']
        row = database.execute(
            text("""
            SELECT
                id,
                hashed_password
            FROM users
            WHERE email = :email
        """), {
                'email': email
            }).fetchone()

        if row and bcrypt.checkpw(password.encode('UTF-8'),
                                  row['hashed_password'].encode('UTF-8')):
            user_id = row['id']
            payload = {
                'user_id':
                user_id,
                'exp':
                datetime.utcnow() +
                timedelta(seconds=app.config['JWT_EXP_DELTA_SECONDS'])
            }
            token = jwt.encode(payload, app.config['JWT_SECRET_KEY'], 'HS256')

            return jsonify({'access_token': token.decode('UTF-8')})
        else:
            return '', 401

    @app.route('/user', methods=['POST'])
    def create_user():
        new_user = request.json
        new_user['password'] = bcrypt.hashpw(
            new_user['password'].encode('UTF-8'), bcrypt.gensalt())

        print(f"new user ==> {new_user}")

        rowcount = database.execute(
            text("""
            INSERT INTO users (
                name,
                email,
                hashed_password, account_id
            ) SELECT
                :name,
                :email,
                :password,
                accnt.id
            FROM accounts as accnt
            WHERE accnt.account_type = :account_type
        """), new_user).rowcount

        print(f"row count == {rowcount}")

        return ('', 200) if rowcount == 1 else ('', 500)

    return app
Ejemplo n.º 35
0
from flask import Flask, render_template, redirect, url_for, request, session, flash, g, Blueprint, abort
from jinja2 import TemplateNotFound
from flask.json import jsonify
from functools import wraps
from flask.ext.sqlalchemy import SQLAlchemy
import sqlite3

from views.header import header

app = Flask(__name__)

app.register_blueprint(header.header)

app.secret_key = "my precious"
app.database = 'testjwz.db'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///posts.db'
#app.config.from_object(os.environ['APP_SETTINGS'])
from models import *
db = SQLAlchemy(app)

def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            flash('You need to login first.')
            return redirect(url_for('login'))
    return wrap
    
@app.route('/', methods=['GET', 'POST'])
Ejemplo n.º 36
0
from flask import Flask, g, session, render_template, jsonify, request, redirect, url_for
import databaseservice
from users import Users, confirmed_password_valid
from gamebuilder import GameBuilder
from gameengine import GameEngine
from gameconfigurations import save_internet_game

app = Flask(__name__)
app.config.from_object(__name__)
app.secret_key = \
    '\xd1\xd1\xb9H\xb6\x0e\x0f\xc3*\xb7\xef\xe7\x02GZ\xd1\xeb\xe4\xcd\xa1\x86c2k'
app.database = 'adventure_game.db'

def connect_database():
  """ Connect to app.database and return the connection object. """
  return databaseservice.connect_database(app.database)

def initialize_database():
  """ Initialize the database. """
  with app.open_resource('schema.sql') as schema:
    databaseservice.initialize_database(app.database, schema)

@app.before_request
def before_request():
  """ open dictionary/db connection"""
  database_connection = connect_database()
  database_cursor = database_connection.cursor()
  g.database_service = databaseservice.DatabaseService( \
      database_connection, database_cursor)

Ejemplo n.º 37
0
	str = unicode

psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY)



app = Flask(__name__)
app.config.from_object(os.environ['SDV_APP_SETTINGS'].strip('"'))
recaptcha = ReCaptcha(app=app)
app.secret_key = app.config['SECRET_KEY']
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True
app.wsgi_app = ProxyFix(app.wsgi_app)
if app.config['USE_SQLITE'] == True:
	app.database = app.config['DB_SQLITE']
	app.sqlesc = '?'
	def connect_db():
		return sqlite3.connect(app.database)
else:
	app.database = 'dbname='+app.config['DB_NAME']+' user='******'DB_USER']+' password='******'DB_PASSWORD']
	app.sqlesc = '%s'
	def connect_db():
		return psycopg2.connect(app.database)

def md5(md5file):
	h = hashlib.md5()
	if type(md5file) == io.BytesIO:
		h.update(md5file.getvalue())
	else:
		for chunk in iter(lambda: md5file.read(4096), b""):
Ejemplo n.º 38
0
#!/usr/bin/env python
# -*- Coding: Utf-8 -*-

"""
IS211 Assignment 13: Flask web dev part II
"""

import sqlite3

from flask import Flask, render_template, request, redirect, url_for, g

app = Flask(__name__)

app.database = 'hw13.db'


@app.route('/')
def start():
    """
    First page
    """
    return redirect('/login')


@app.route('/login', methods=['GET', 'POST'])
def login():
    """
    Login form processing
    On success: go to /dashboard
    On fail: Go to /login with error
    """
Ejemplo n.º 39
0
def init(uri=None, db="trackeame"):
    app = Flask(__name__)
    app.config["MONGO_URI"] = os.environ.get("MONGOLAB_URI", uri)
    mongo = MongoClient(app.config["MONGO_URI"])
    app.mongo = mongo
    app.database = mongo[db]

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

    @app.route("/api/users")
    def get_users():
        output = []
        users = app.database.users.find()
        for user in users:
            output.append({"name": user["name"], "lastname": user["lastname"], "sex": user["sex"]})
        return jsonify(output)

    @app.route("/api/users", methods=['POST'])
    def add_user():
        users = app.database.users
        name = request.json["name"]
        lastname = request.json["lastname"]
        sex = request.json["sex"]
        id = users.insert({"name": name, "lastname": lastname, "sex": sex})

        user = users.find_one({'_id': id})
        result = {"name": user["name"], "lastname": user["lastname"], "sex": user["sex"]}

        return jsonify(result)

    @app.route("/api/locations", methods=['DELETE'])
    def clear_locations():
        locations = app.database.locations

        try:
            locations.delete_many({})
        except KeyError:
            abort(403)

        result = {"ok": 1}

        return jsonify(result)

    @app.route("/api/locations", methods=['POST'])
    def add_locations():
        locations = app.database.locations

        cuadrantes = {"N": 1, "S":-1, "W":-1, "E": 1}

        try:
            posiciones = request.json["posiciones"]
            posiciones_parseadas = []
            ultima_posicion = None

            for posicion in posiciones.split("\n"):
                if posicion is not '':
                    nueva_posicion = {}
                    print(posicion)
                    try:
                        tipo, hora_gcm, validez, latitud, polo, longitud, hemisferio, dato1, dato2, fecha, dato3, dato4, dato5 = posicion.split(",")

                        if latitud is not '' and longitud is not '':
                            tiempo_hora = datetime( int(fecha[4:6]), int(fecha[2:4]), int(fecha[0:2]), int(hora_gcm[0:2]), int(hora_gcm[2:4]), int(hora_gcm[4:6]))

                            nueva_posicion["timestamp"] = datetime.timestamp(tiempo_hora)
                            nueva_posicion["latitud"] = (int(latitud[0:2]) + (float(latitud[2:9]) / 60)) * cuadrantes[polo]
                            nueva_posicion["longitud"] = (int(longitud[0:3]) + (float(longitud[3:10]) / 60)) * cuadrantes[hemisferio]
                            nueva_posicion["tiempo_de_parada"] = 0

                            if tipo == "$PARADA" and ultima_posicion is not None:
                                ultima_posicion["tiempo_de_parada"] = nueva_posicion["timestamp"] - ultima_posicion["timestamp"]

                            posiciones_parseadas.append(nueva_posicion)
                            ultima_posicion = nueva_posicion
                    except Exception:
                        pass

            if len(posiciones_parseadas) > 0:
                locations.insert_many(posiciones_parseadas)

        except KeyError:
            abort(403)

        resultado = {"ok": 1}

        return jsonify(resultado)

    @app.route("/api/locations")
    def get_locations():
        output = []
        locations = app.database.locations.find()
        for location in locations:
            output.append({"posicion": {
                "timestamp": location["timestamp"],
                "latitud": location["latitud"],
                "longitud": location["longitud"],
                "tiempoDeParada": location["tiempo_de_parada"]
            }})
        return jsonify(output)

    return app
Ejemplo n.º 40
0
import sqlite3
import string
import urllib2
from math import floor
from sqlite3 import OperationalError
from urlparse import urlparse

from BeautifulSoup import BeautifulSoup
from flask import Flask, request, render_template, redirect, flash

host = 'http://localhost:5000/'

app = Flask(__name__)
app.database = 'example.db'
app.secret_key = 'super secret key'


def createTable():
    create_table = '''CREATE TABLE IF NOT EXISTS WEB_URL (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        url string NOT NULL UNIQUE,
        short string,
        hits INT,
        t TIMESTAMP
        DEFAULT CURRENT_TIMESTAMP,
        title string
        ); '''

    with sqlite3.connect('example.db') as conn:
        cursor = conn.cursor()
        try:
Ejemplo n.º 41
0
from flask import Flask, flash, redirect, render_template, g, request, url_for
import sqlite3

app = Flask(__name__)
app.database = "blog_posts.db"
app.secret_key = 'super spooky secret key'

# A list of words and their corresponding translations for our app
# words = {"Bonjour": "hello", "Jambon": "ham", "Fromage": "cheese"}


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

@app.route('/france', methods=['GET', 'POST'])
def france():
    g.db = connect_db()
    cur = g.db.execute("select * from words where language= ?", ("French",))
    words = [dict(word=row[0], translation=row[1]) for row in cur.fetchall()]
    g.db.close()
    print(words)
    points = 0
    if request.method == "POST":
        for word, translation in words.items():
            if request.form[word] == translation:
                points += 1
        flash(str(points))
        return redirect(url_for('france'))
    return render_template("france.html", words=words)
Ejemplo n.º 42
0
import time
from flask import Flask,  redirect, url_for, request, jsonify
from functools import wraps 
import json

app = Flask(__name__)
app.database = './messages.db'
app.secret_key = 'CucumberSec'

from views import *

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


Ejemplo n.º 43
0
from flask import Flask


app = Flask(__name__)
app.database = 'WODTracker.db'
app.debug = True
app.secret_key = 'dev'
# Setup database
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///WODTracker.db'

import WODTracker.views
from views import *

app.add_url_rule('/',
	view_func=Index.as_view('index'),
	methods=['GET','POST'])
app.add_url_rule('/newuser',
	view_func=NewUser.as_view('new_user'),
	methods=['GET','POST'])
app.add_url_rule('/recordworkout',
	view_func=WorkoutView.as_view('workout'),
	methods=['GET','POST'])
app.add_url_rule('/newexercise',
	view_func=ExerciseView.as_view('new_exercise'),
	methods=['GET','POST'])
app.add_url_rule('/weighin',
	view_func=WeighInView.as_view('weighin'),
	methods=['GET','POST'])
app.add_url_rule('/calendar',
	view_func=CalendarView.as_view('calendar'),
	methods=['GET'])
    date    :   10/24/15
    project :   Independent

"""

# import the modules we need
import os
import sqlite3

from flask import Flask, render_template, request, g

# Create the recipesnremedieslication object
recipesnremedies = Flask(__name__)
# recipesnremedies.debug = True
# Add in a configuration variable for the database, assign
recipesnremedies.database = "cookbook.db"

# use decorators to link the function to a url
@recipesnremedies.route('/', methods=['GET', 'POST'])
def home():
    """ Function for flask interaction with the html webpage - homepage or index"""

    try:
        # g is a temp object specific to flask and it stores the database 
        # connection in this case
        # this value is reset after each request use it to connect and store
        # the db object
        g.db = connect_db()
        cur= g.db.execute('SELECT * FROM recipes')
        
        # cast the data to a dictionary
Ejemplo n.º 45
0
# import the Flask class from the flask module
from flask import Flask, render_template, redirect, url_for, request, session, flash, g, Markup
from pymongo import MongoClient
from textblob import TextBlob
import plotly.plotly as py
import numpy as np
import plotly.graph_objs as go
from plotly import tools
import plotly.tools as tls
py.sign_in('nashc', '3nzdm0kuzk')


# create the application object
app = Flask(__name__)
app.database = 'press'
app.collection = 'mini1'

def textblob_sentiment(text):
	'''
		Use TextBlog package to get sentiment values for each press release text
		
		INPUT:
		- text: release text string

		OUTPUT:
		- (polarity, subjectivity): tuple containing the sentiment values
	'''
	#create TextBlog object and use inherent methods to get polarity and subjectivity
	blob = TextBlob(text)
	polarity = blob.sentiment.polarity
Ejemplo n.º 46
0
Archivo: hi.py Proyecto: ahdrage/flask
from flask import Flask, render_template, redirect, url_for, request, g 
import sqlite3


app = Flask(__name__)
app.database = "toplist.db"



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


@app.route('/result')
def result():
    g.db = connect_db()
    cur = g.db.execute('select * from listing')
    listing = [dict(Year=row[0], Week=row[1], Artist=row[2], Title=row[3], SpotUrl=row[4], SpotID=row[5], Image=row[6]) for row in cur.fetchall()]
  
    g.db.close()
    return render_template('result.html', listing=listing)


def connect_db():
	return sqlite3.connect(app.database)



Ejemplo n.º 47
0
Archivo: app.py Proyecto: zesk06/scores
    FILE_URI = os.path.join(THIS_DIR, 'target/scores.yml')
    DATABASE_URI = 'mongodb://<dbuser>:<dbpassword>@<instance>.mlab.com:<port>/<dbname>_test'
    if 'TEST_DATABASE_URI' in os.environ:
        DATABASE_URI = os.environ['TEST_DATABASE_URI']


app = Flask(__name__)
app.config.from_object(Config)

# used by flask-login
app.secret_key = 'idontwanttobeinthepubliccode'
login_manager = flask_login.LoginManager()
login_manager.init_app(app)
login_manager.login_view = "login"

app.database = None


def get_db():
    """Return the Database
    :rtype: database.Database"""
    if app.database is None:
        print('connecting to %s' % app.config['DATABASE_URI'])
        app.database = database.Database(app.config['DATABASE_URI'])
    return app.database


@login_manager.user_loader
def user_loader(login):
    # retrieve user from database
    print('user_loader')
Ejemplo n.º 48
0
# import the Flask class from the flask module
from flask import Flask, render_template, redirect, url_for, request, session, flash
from functools import wraps
import sqlite3
from Classes import *
from pony.orm import *
import bcrypt


# create the application object
app = Flask(__name__)

app.secret_key = "tomato"
app.database = "notice_db.db"


def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            flash('Access denied: You must login first.')
            return redirect(url_for('login'))
    return wrap


# use decorators to link the function to a url
@app.route('/', methods=['GET', 'POST'])
@db_session
def login():
Ejemplo n.º 49
0
from flask import Flask, request, session, g, redirect, url_for, abort, render_template, flash
from apscheduler.schedulers.background import BackgroundScheduler
import sqlite3 as lite
from webCrawler import getAllFoods
from contextlib import closing
from flask_mail import Mail, Message


app = Flask(__name__)

app.config.from_object(__name__)
app.config["DEBUG"] = True
app.database = "WhatsCookin\'.db"

app.config.update(
DEBUG = True,
MAIL_SERVER = 'smtp.gmail.com',
MAIL_PORT=465,
MAIL_USE_SSL=True,
MAIL_USERNAME = '******',
MAIL_PASSWORD = '******'
)
#Create mail object
mail = Mail(app)
app.config.from_object(__name__)

#Create the database------------------------------------------------------------
def connect_db():
	return lite.connect(app.database)

#Creates the database if it doesnt exist
Ejemplo n.º 50
0
from functools import wraps
import sqlite3
import os
from config import Config # import the Config class from module config
# 



# create the application object
app = Flask(__name__)

# app.config.from_object(os.environ['APP_SETTINGS']) # application configuration
app.config.from_object('config')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///posts.db'
app.database = "posts.db"
app.secret_key = "This-is-confidential"


# create the app with security default login being profile route
# app.config['SECURITY_POST_LOGIN'] = '******'

# create and config the database object
db = SQLAlchemy(app)

from models import *

# gthub oauth configuration
# client_id = app.config['GITHUB_CLIENT_ID']
# client_secret = app.config['GITHUB_CLIENT_SECRET']
Ejemplo n.º 51
0
from flask import Flask, jsonify, render_template, request, g, redirect, request
import sqlite3, json

app = Flask(__name__)
app.database = "chart_data.db"
entries = ""
def connect_db():
	return sqlite3.connect(app.database)


@app.route('/', methods=['POST'])
def index():
		#getdata()
		g.db = connect_db()
		#g.db.execute('insert into ghosts (title, description) values (?, ?)',[request.form['title'], request.form['description']])
		g.db.execute('insert into chart_table (name,test_value) values ("Shreyas","23")')
		cur = g.db.execute('select * from chart_table')
		entries = [dict(test_value=row[1],name=row[0]) for row in cur.fetchall()]
		g.db.close()
		#print entries

		with open("static\chartson.json","w") as outfile:
			json.dump(
			entries,outfile) #

		return render_template('index.html', entries=entries)



if __name__ == '__main__':
    app.run(debug=True)
Ejemplo n.º 52
0
import re
import time

# labels: list
# data list
from multiprocessing import Process

# Private - utils is the regex, redditBot is the bot class, redditDatabase is the actually storing and extracting from database
from scripts import utils, redditBot, redditDatabase

# create application object
app = Flask(__name__)
# change database name later
app.database =  {
    'database': 'reddit_data',
    'user': '******',
    'password': '******',
    'host': 'localhost'
}
# secret key for cookies *MUST CHANGE FOR SECURITY*
app.secret_key = b'\xd0\x10\x0b$\x0fk\xbe%\xc6\x1b\xe4\xd1\xf0\xe0\xd4\x0210\xc5R\x80X\x98+'

# landing page with text field
# route() decorator to tell Flask what URL should trigger our function.
@app.route('/', methods=['GET', 'POST'])
def home():
    error = None
    if request.method == 'POST':
        session['url'] = request.form['url'] #storing this information while the user is browsing
        session['isBotOn'] = False #bot isn't on yet
        if (utils.getPostID(session['url']) == False):
            error = "You're tripping! Enter a reddit post URL!"
Ejemplo n.º 53
0
from flask import Flask, render_template, request, g
app = Flask(__name__)

import inspect, os
app.database = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) + '/propcalc.db'
import sqlite3
def connect_to_database():
	return sqlite3.connect(app.database)

@app.route("/")
def main():
	g.db = connect_to_database()
	current = g.db.execute('select * from subjects')
	subjects = current.fetchall()
	return render_template('my_properties.html', subjects=subjects)

import ast
@app.route("/edit_property/<subject>")
def edit_property(subject):
	subject = ast.literal_eval(subject)
	return render_template('edit_property.html', subject=subject)

from lib.prop_calc import *
@app.route('/sales_approach/<subject>', methods=['GET', 'POST'])
@app.route('/sales_approach/', defaults={'subject': None}, methods=['GET', 'POST'])
def sales_approach(subject):
	if request.method == 'POST':
		subject = {}
		for field in request.form:
			subject[field] = request.form[field]
		subject['address'] = subject['street'] + ' ' + subject['city'] + ', ' + subject['state'] + ' ' + subject['zipcode']
Ejemplo n.º 54
0
from functools import wraps
import sqlite3
import os
app = Flask(__name__)
def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            flash('You need to login first.')
            return redirect(url_for('login'))
    return wrap

app.secret_key = os.urandom(24)
app.database='sample.db'
conn=sqlite3.connect('sample.db')


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

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

@app.route('/sef')
def sef():
Ejemplo n.º 55
0
from flask import Flask, render_template, redirect, url_for, request, session,flash, g
from functools import wraps
import random
import sqlite3

app = Flask(__name__)

app.secret_key = "f0a9fja09fjaf0aif90afi0a9fi90aif90aif09aif90aif09aifajf09ajf09ajf09ajf09ajf0a"
app.database = "hangman.db"

def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            flash('Please Log In')
            return redirect(url_for('login'))
    return wrap

@app.route('/')
@login_required
def start():
    #return app.send_static_file('index.html')
    return render_template('index.html')

def getTypes(type):
    g.db = connect_db()
    if type is None:
        qu = g.db.execute('select * from type')
    else:
Ejemplo n.º 56
0
from flask import Flask, g, render_template, redirect, request, url_for, session, flash
from functools import wraps
import sqlite3
from datetime import datetime
import urllib

app = Flask(__name__)
app.secret_key = "not a good secret"
app.database = "blog.db"
app.config['DEBUG'] = True


def connect_db():
    return sqlite3.connect(app.database)


def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            return redirect(url_for('login'))
    return wrap


@app.route('/')
@app.route('/index')
def index():
    g.db = connect_db()
    cur = g.db.execute('SELECT * FROM posts WHERE pub_status="published" ORDER BY `date_posted` DESC')
Ejemplo n.º 57
0
import os
import torch
import pickle
from flask import Flask, jsonify, request
from sqlalchemy import create_engine, text
from model.net import SenCNN
from model.split import split_morphs
from model.utils import Tokenizer, PadSequence

app = Flask(__name__)
app.config.from_pyfile("config.py")
app.database = create_engine(app.config["DB_URL"],
                             encoding="utf-8",
                             max_overflow=0)

# preprocessor & model
num_classes = app.config["MODEL"]["num_classes"]
max_length = app.config["MODEL"]["length"]

with open("model/checkpoint/vocab.pkl", mode="rb") as io:
    vocab = pickle.load(io)
pad_sequence = PadSequence(length=max_length,
                           pad_val=vocab.to_indices(vocab.padding_token))
tokenizer = Tokenizer(vocab=vocab, split_fn=split_morphs, pad_fn=pad_sequence)

model = SenCNN(num_classes=app.config["MODEL"]["num_classes"], vocab=vocab)
ckpt = torch.load("model/checkpoint/best.tar",
                  map_location=torch.device("cpu"))
model.load_state_dict(ckpt["model_state_dict"])
model.eval()
Ejemplo n.º 58
0
from flask import Flask, flash, g, session, \
	redirect, render_template, request, url_for
import sqlite3


app = Flask(__name__)

app.secret_key = "secret"
app.database = "database.db"



@app.route('/')
def index():
	g.db = connect_db()
	cur = g.db.execute('SELECT * FROM posts')
	posts = [dict(title=row[0], description=row[1]) for row in cur.fetchall()]
	g.db.close()
	return render_template('index.html', posts=posts)


@app.route('/login/', methods = ["GET", "POST"])
def login():
	error = None
	if request.method == "POST":
		lg = request.form['username']
		pw = request.form['password']
		g.db = connect_db()
		cur = g.db.execute('SELECT * FROM users')
		users_dict = [dict(login=row[0], password=row[1]) for row in cur.fetchall()]
		g.db.close()
Ejemplo n.º 59
0
from flask import Flask, render_template, url_for, request, redirect, session, flash, g, json, jsonify
from functools import wraps
from requests.auth import HTTPBasicAuth
import sqlite3
from rauth import OAuth2Service
app = Flask(__name__)
app.database = "DeltaDB1.db"
app.secret_key = "oh baby"
import requests
from flask_bcrypt import Bcrypt
bcrypt = Bcrypt(app)


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


@app.route('/login', methods=['POST'])
def login():
    username = request.form['username']
    password = request.form['password']
    g.db = connect_db()
    user1 = g.db.execute("SELECT * FROM Flyers WHERE username=?", (username, ))
    print user1
    user = [
        dict(first_name=row[1],
             last_name=row[2],
             username=row[5],
             password=row[4],
             uuid=row[0],
Ejemplo n.º 60
0
from flask import Flask, render_template, redirect, url_for, request, session, flash, g, Markup
from functools import wraps
from subprocess import check_output
from hashlib import sha256
from uuid import uuid4
import sqlite3


app = Flask(__name__)

app.config.from_object('config')
app.database = app.config['DATABASE']
app.script = app.config['SCRIPT']
app.secret_key = app.config['SECRET_KEY']

###################################### NON-PAGE FUNCTIONS ###################################

##
# Login Required Decorator
def login_required(f):
    @wraps(f)
    def wrap(*args, **kwargs):
        if 'logged_in' in session:
            return f(*args, **kwargs)
        else:
            flash('You must be logged in to view this page.')
            return redirect(url_for('login'))
    return wrap

##
# Admin Required Decorator