def create_app():
# name is a pre-defined python variable which is set to the name of the module in which it is used
# the flask object implements a WSGI application - once it is created it acts as a central repository
# for view functions, url rules, template config, etc
# should be created in main module or __init__.py of your package
app = Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
'db': 'kart_db',
'host': '172.21.0.2',
'port': 27017,
'authentication_source': 'admin',
'username': '******',
'password': '******'
}
#print('cf: ' + str(dir(config_filename)))
#app.config.from_object('settings')
app.config.from_envvar('FLASK_MODULE_SETTINGS')
#app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqlconnector://root:[email protected]:3306/mange_takk_db'
#app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# initialize extensions so that extension knows the name of the application object
api.init_app(app)
cors.init_app(app)
# right now all cross origin requests are allowed - need to change this config
# src: https://stackoverflow.com/questions/26980713/solve-cross-origin-resource-sharing-with-flask
# cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
db.init_app(app)
jwt.init_app(app)
return app
def init_app(app, **kwargs):
# pylint: disable=unused-argument
api_blueprint = Blueprint(
'api', __name__, url_prefix='/api/v' + api.version[0:1]
) #TODO: if you want to modify the name of the api change the url_prefix (for now it is /api/v1)
api.init_app(api_blueprint)
app.register_blueprint(api_blueprint)
def register_extensions(app):
db.init_app(app)
mail.init_app(app)
debug_toolbar.init_app(app)
migrate.init_app(app, db)
api.init_app(app)
return None
def register_extensions(app):
db.init_app(app)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
app.register_blueprint(blueprint)
cors.init_app(app)
def create_app(config=None):
new_app = Flask(__name__,
template_folder='../react_app/build',
static_folder='../react_app/build/static')
new_app.config.from_object(config)
with new_app.app_context():
jwt.init_app(new_app)
bcrypt.init_app(new_app)
cors.init_app(new_app)
mysql.init_app(new_app)
mail.init_app(new_app)
from model import temp_blacklist
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
return decrypted_token['jti'] in temp_blacklist
# Let react handle routing
@new_app.route('/', defaults={'path': ''})
@new_app.route('/<path:path>')
def serve(path):
if path and os.path.exists(safe_join(new_app.template_folder, path)):
return send_from_directory(new_app.template_folder, path)
else:
return send_from_directory(new_app.template_folder, 'index.html')
from resources.authentication import (UserRegistration, UserLogin,
TokenRefresh, UnsetToken, AdminLogin,
AdminRegister)
from resources.user import GetUserInfo, UpdateUserInfo
from resources.products import (TrackProduct, NewComments, GetComments,
GetSpecificProduct)
from resources.admin import Announcement
api.add_resource(UserRegistration, '/register')
api.add_resource(UserLogin, '/login')
api.add_resource(TokenRefresh, '/refresh')
api.add_resource(UnsetToken, '/revoke')
api.add_resource(GetUserInfo, '/user')
api.add_resource(UpdateUserInfo, '/user/<string:option>')
api.add_resource(TrackProduct, '/product')
api.add_resource(GetSpecificProduct,
'/product/<string:retailer>/<string:pid>')
api.add_resource(NewComments, '/comment')
api.add_resource(GetComments,
'/comment/<string:retailer>/<string:prod_id>')
api.add_resource(AdminLogin, '/admin-login')
api.add_resource(AdminRegister, '/admin-register')
api.add_resource(Announcement, '/announcement')
api_bp = Blueprint('api', __name__)
api.init_app(api_bp)
new_app.register_blueprint(api_bp, url_prefix='/api')
return new_app
def register_api(app):
from extensions import api
from resources import FilmApi, FilmListApi, SignupApi, LoginApi
from resources.errors import errors
api.errors = errors
api.add_resource(FilmApi, '/api/v1/film/<int:film_id>')
api.add_resource(FilmListApi, '/api/v1/film')
api.add_resource(SignupApi, '/api/v1/signup')
api.add_resource(LoginApi, '/api/v1/login')
api.init_app(app)
def create_app(script_info=None):
app = Flask(__name__)
load_dotenv(".env", verbose=True)
app_settings = os.environ.get("APP_SETTINGS")
if not app_settings:
raise ValueError(
'APP_SETTINGS environment variable is not set. Aborting.')
app.config.from_object(app_settings)
# Migration purposes
from models import user, remaining_employee, company, address # NOQA
jwt.init_app(app)
db.init_app(app)
api.init_app(app)
ma.init_app(app)
migrate.init_app(app, db)
init_celery(app)
mail.init_app(app)
api.add_resource(UserLogin, "/login")
api.add_resource(UserRegister, "/register")
api.add_resource(UserRegister, "/register/<string:confirmation_token>")
api.add_resource(User, "/user")
api.add_resource(UserList, "/users")
api.add_resource(UserInvite, "/invite")
@app.route('/ping')
def pong():
return 'pong'
@api.errorhandler(Unauthorized)
def unauthorized_page(error):
return {"message": "401, change this on prod."}, 401
@api.errorhandler(Forbidden)
def forbidden_page(error):
return {"message": "403, change this on prod."}, 403
@api.errorhandler(NotFound)
def page_not_found(error):
return {"message": "404, change this on prod."}, 404
@api.errorhandler(MethodNotAllowed)
def method_not_allowed(error):
return {"message": "405, change this on prod."}, 405
@api.errorhandler(InternalServerError)
def server_error_page(error):
return {"message": "500, change this on prod."}, 500
return app
def register_extensions(app):
""" Initialize Database """
# Order matters: Initialize SQLAlchemy before Marshmallow
db.app = app
db.init_app(app)
""" Initialize API """
api.app = app
api.init_app(app)
""" Initialize Marshmallow """
ma.app = app
ma.init_app(app)
def extensions(app):
"""
Register 0 or more extensions (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
migrate.init_app(app, db)
cors.init_app(app)
bcrypt.init_app(app)
api.init_app(app)
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
migrate.init_app(app, db)
api.init_app(app)
dynaconf.init_app(app)
api.add_resource(ClientResource, '/client', '/client/<int:id_client>')
api.add_resource(BookResource, '/book', '/book/<int:id_book>')
return app
def create_app(config_name='dev'):
app = Flask(__name__)
app.config.from_object(config_factory[config_name])
db.init_app(app)
api.init_app(app)
cors.init_app(app)
migrate.init_app(app, db)
ma.init_app(app)
router_register(app)
return app
def register_extensions(app):
db.init_app(app)
migrate.init_app(app, db)
cors.init_app(app, supports_credentials=True)
api.init_app(app, version='1.0', title='Swagger API',
description='API для сервиса интерактовной карты благоустройства г. Москва')
api.add_namespace(ns_map)
api.add_namespace(ns_data_set)
api.add_namespace(ns_reports)
api.add_namespace(ns_dictionary)
def register_extension(app):
db.init_app(app)
# the callbacks needs to be supplied before init_app
jwt.identity_callback = identity
jwt.authentication_callback = authenticate
jwt.init_app(app)
api.add_resource(Item, '/item/<string:name>')
api.add_resource(ItemList, '/items')
api.add_resource(Store, '/store/<string:name>')
api.add_resource(StoreList, '/stores')
api.add_resource(UserRegistor, '/register')
api.init_app(app)
def create_app(config=None):
app = Flask('scaffold', instance_relative_config=True)
if config is not None:
app.config.from_object(config)
init_logger(app)
logger.info('starting %s' % app.name)
db.init_app(app)
cors.init_app(app)
celery.config_from_object(app.config)
login_manager.init_app(app)
api.init_app(app)
init_api(api, app)
logger.info('started %s' % app.name)
return app
def create_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = CREDENTIALS['database']['db_url']
cors = CORS(app, resources={r"/*": {"origins": "*"}})
api.add_resource(translation_endpoint.TranslationByIdEndpoint,
'/translation/<id>')
api.add_resource(translation_endpoint.TranslationByLanguageEndpoint,
'/translation/lang/<language>')
api.add_resource(exercise_endpoint.ExerciseEndpoint, '/exercise')
api.init_app(app)
db.init_app(app)
return app
def create_app():
app = Flask(__name__)
CORS(app, supports_credentials=True)
app.config.from_object(settings)
# db
db.init_app(app)
migrate.init_app(app, db)
# api
views.init(api)
api.init_app(app)
redis.init_app(app)
return app
def create_app(conf=None) -> Flask:
conf = conf or get_config()
app = Flask(__name__)
app.config.from_object(conf)
# register with app
db.init_app(app)
migrate.init_app(app, db)
api.init_app(app)
middleware_manager.init_app(app)
jwt.init_app(app)
secret_generator_cli.init_app(app)
if conf.DEBUG:
code_generator.init_app(app)
seeds.init_app(app)
return app
def create_app(db_uri, keys_dir_path):
app = Flask(__name__)
private_key = ''
public_key = ''
with open(keys_dir_path + '/jwtRS256.key', 'r') as content_file:
private_key = content_file.read()
with open(keys_dir_path + '/jwtRS256.key.pub', 'r') as content_file:
public_key = content_file.read()
app.config['JWT_ALGORITHM'] = 'RS256'
app.config['JWT_PUBLIC_KEY'] = public_key
app.config['JWT_PRIVATE_KEY'] = private_key
app.config['JWT_IDENTITY_CLAIM'] = 'sub'
app.config['JWT_USER_CLAIMS'] = 'payload'
app.config['JWT_CLAIMS_IN_REFRESH_TOKEN'] = False
app.config['JWT_ERROR_MESSAGE_KEY'] = 'message'
app.config['JWT_TOKEN_LOCATION'] = ('headers', 'cookies')
app.config['SQLALCHEMY_DATABASE_URI'] = db_uri
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['PROPAGATE_EXCEPTIONS'] = True
from extensions import (
api,
jwt,
db,
)
jwt.init_app(app)
db.init_app(app)
import models
with app.app_context():
db.create_all()
import resources
resources.BaseResource.register(api)
api.init_app(app)
CORS(app)
return app
def register_extensions_production(app):
"""Register Flask extensions."""
from extensions import api
api.init_app(app)
cors.init_app(app, supports_credentials=True)
# need this for true prod
cors.init_app(
app,
resources={
r"/*": {"origins": "https://www.icarusmed.com"}
},
supports_credentials=True)
jwt.init_app(app)
csrf.init_app(app)
return None
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
app.json_encoder = JSONEncoder
blueprint = Blueprint("api", __name__)
#app.register_blueprint(blueprint)
api.init_app(blueprint)
app.register_blueprint(blueprint)
mars.init_app(app)
mongo.init_app(app)
#bcrypt.init_app(app)
api.add_namespace(namespace_chat)
api.add_namespace(namespace_auth)
api.add_namespace(namespace_user)
api.add_namespace(namespace_requirements)
return app
def initialize_app():
app = Flask(os.getenv('MONGO_DBNAME', 'MobileMechanic'))
app.config.from_object('configuration.DevelopmentConfig')
# config_prefix is used incase we want to add more databases
mongo.init_app(app, config_prefix='MONGO')
jwt = JWT(app, authenticate, identity)
api_base_string = '/mobilemechanic/api/v1.0/'
api.add_resource(UserAPI, api_base_string + 'users/<int:user_id>')
api.add_resource(TokenAPI, api_base_string + 'users/<int:user_id>/token')
api.add_resource(MechanicAPI,
api_base_string + 'users/<int:user_id>/mechanic')
api.add_resource(JobAPI, api_base_string + 'users/<int:user_id>/jobs')
api.add_resource(
ImageUploadAPI,
api_base_string + 'users/<int:user_id>/jobs/<job_id>/picture')
api.add_resource(
QuotesAPI,
api_base_string + 'users/<int:user_id>/jobs/<job_id>/quotes')
api.init_app(app)
return app
def register_extensions(app):
api.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
# Third part modules
from flask import Blueprint
# Local modules
from . import views
from extensions import api
bp = Blueprint('api', __name__, url_prefix='/api')
api.init_app(bp)
views.configure(bp, api)
from flask import Flask
import config
from extensions import db, cors, api
from auth.views import auth_bp
from network.views import network_bp
app = Flask(__name__)
app.config.from_object(config.Config)
# registers app
db.init_app(app)
cors.init_app(app)
api.init_app(app)
# registers blueprint
app.register_blueprint(auth_bp)
app.register_blueprint(network_bp)
if __name__ == "__main__":
app.run(debug=True, port=4444)
