def create_app(app):
# config app
app.config.from_object(os.environ["APP_SETTINGS"])
# initiate extensions
db.init_app(app)
ma.init_app(app)
celery.init_app(app)
jack_apns.init_app(app)
# declare models
import models
# init app
with app.app_context():
# db.reflect()
# db.drop_all()
db.create_all()
app.register_blueprint(auth, url_prefix="/auth")
app.register_blueprint(user, url_prefix="/user")
app.register_blueprint(group, url_prefix="/group")
app.register_blueprint(post, url_prefix="/post")
app.register_blueprint(comment, url_prefix="/comment")
app.register_blueprint(invite, url_prefix="/invite")
app.register_blueprint(generic, url_prefix="/generic")
app.register_blueprint(rule, url_prefix="/rule")
def create_app():
load_dotenv(".env", verbose=True)
app = Flask(__name__)
app.config.from_object("default_config")
app.config.from_envvar("APPLICATION_SETTINGS")
api = Api(app)
@app.errorhandler(ValidationError)
def handle_marshmallow_validation(err):
return jsonify(err.messages), 400
@app.before_first_request
def create_tables():
db.create_all()
db.init_app(app)
ma.init_app(app)
login_manager.init_app(app)
# authorize.init_app(app)
jwt.init_app(app)
babel.init_app(app)
# Set up Casbin model config
app.config['CASBIN_MODEL'] = './src/casbinmodel.conf'
# Set headers where owner for enforcement policy should be located
app.config['CASBIN_OWNER_HEADERS'] = {'Authorization'}
# Set up Casbin Adapter
adapter = FileAdapter('./src/security_policy.csv')
casbin_enforcer.init_app(app, adapter)
# casbin_enforcer = CasbinEnforcer(app, adapter)
# casbin_enforcer = UpdatedCasbinEnforcer(adapter)
@app.route("/")
@casbin_enforcer.enforcer
def index():
return jsonify({"hello": "world"})
from authz.resources.user import UserRegister, UserLogin, UserLogout
api.add_resource(UserRegister, "/register")
api.add_resource(UserLogin, "/login")
api.add_resource(UserLogout, "/logout")
# from authlogin.resources.security import NewGroup, GroupResource, UserGroup
# api.add_resource(NewGroup, "/group")
# api.add_resource(GroupResource, "/group/<int:_id>")
# api.add_resource(UserGroup, "/usergroup/<int:_id>")
# # api.add_resource(UserGroup, "/usergroup")
from main.resources.store import NewStore, Store, StoreList
api.add_resource(NewStore, "/store")
api.add_resource(Store, "/store/<int:_id>")
api.add_resource(StoreList, "/stores")
return app
def main():
from db import db
from ma import ma
db.init_app(app)
ma.init_app(app)
# SQLAlchemy will create the tables just before the first request
@app.before_first_request
def create_tables():
db.create_all()
# starting the app
app.run(port=5000, debug=True)
class TestUserResource(TestCase):
db.init_app(app)
ma.init_app(app)
def setUp(self) -> None:
self.app = app.test_client()
def test_items_get_list(self):
response = self.app.get('/items')
self.assertEqual(response.status_code, 200)
def create_app(config_name):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(app_config[config_name])
app.config.from_pyfile('config.py')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
ma.init_app(app)
bluePrint = Blueprint('api', __name__, url_prefix='/api')
api = Api(bluePrint, doc='/doc', title='Sample Flask-RestPlus Application')
app.register_blueprint(bluePrint)
api.add_namespace(person_ns)
@app.before_first_request
def create_tables():
db.create_all()
person_ns.add_resource(Person, '/<id>')
person_ns.add_resource(PersonsList, '')
return app
def create_app(app):
#config
app.config.from_object(os.environ['APP_SETTINGS'])
#models
db.init_app(app)
ma.init_app(app)
with app.app_context():
from models.book import Book
from models.author import Author
from models.rating import Rating
from models.category import Category
from models.user import User
from models.log import ReadingLog
db.create_all()
db.session.commit()
#create endpoints
app.register_blueprint(endpoints)
def create_app(app):
#config
app.config.from_object(os.environ['APP_SETTINGS'])
#models
db.init_app(app)
ma.init_app(app)
with app.app_context():
from models.book import Book
from models.author import Author
from models.rating import Rating
from models.category import Category
from models.user import User
from models.log import ReadingLog
db.create_all()
db.session.commit()
#create endpoints
app.register_blueprint(endpoints)
def create_app(confif_filename):
app = Flask(__name__)
app.config.from_object(confif_filename)
from app import service_blueprint
app.register_blueprint(service_blueprint, url_prefix="/service")
from orm import orm
orm.init_app(app)
from ma import ma
ma.init_app(app)
from flask_migrate import Migrate
migrate = Migrate(app, orm)
return app
def create_app(config_name: str = "development") -> Flask:
"""
Factory for the creation of a Flask app.
:param config_name: the key for the config setting to use
:type config_name: str
:return: app: a Flask app instance
"""
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
jwt.init_app(app)
ma.init_app(app)
@app.errorhandler(ValidationError)
def handle_marshmallow_validation_error(err):
return jsonify(error=str(err)), 400
@app.errorhandler(401)
def resource_not_found(err):
return jsonify(error=str(err)), 401
@app.errorhandler(404)
def resource_not_found(err):
return jsonify(error=str(err)), 404
@app.errorhandler(409)
def resource_not_found(err):
return jsonify(error=str(err)), 409
app.register_blueprint(keynotes, url_prefix="/keynotes")
app.register_blueprint(meetings, url_prefix="/meetings")
app.register_blueprint(members, url_prefix="/members")
app.register_blueprint(permissions, url_prefix="/permissions")
app.register_blueprint(projects, url_prefix="/projects")
app.register_blueprint(roles, url_prefix="/roles")
app.register_blueprint(speakers, url_prefix="/speakers")
return app
def create_app():
app = Flask(__name__)
CORS(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:root@db:3306/order_planner'
db.init_app(app)
ma.init_app(app)
migrate = Migrate(app, db)
api = Api(app)
api.add_resource(UnitListResource, '/unit')
api.add_resource(UnitResource, '/unit/<unit_id>')
api.add_resource(RecipeListResource, '/recipe')
api.add_resource(RecipeResource, '/recipe/<recipe_id>')
api.add_resource(IngredientListResource, '/ingredient')
api.add_resource(IngredientResource, '/ingredient/<ingredient_id>')
return app
from flask import Flask
from flask_restful import Api
from dotenv import load_dotenv
from dotenv import load_dotenv
from db import db
from ma import ma
from resources.wallet import Wallet, WalletAmountPay, WalletAmountAdd
load_dotenv()
app = Flask(__name__)
app.config.from_object("default_config")
api = Api(app)
@app.before_first_request
def create_tables():
db.create_all()
api.add_resource(Wallet, "/wallet")
api.add_resource(WalletAmountPay, "/wallet/amount/pay")
api.add_resource(WalletAmountAdd, "/wallet/amount/receive")
if __name__ == "__main__":
db.init_app(app)
ma.init_app(app)
app.run(port=5000, debug=True)
@app.errorhandler(ValidationError)
def handle_marshmallow_validation(err): # except ValidationError as err
return jsonify(err.messages), 400
jwt = JWTManager(app)
# This method will check if a token is blacklisted, and will be called automatically when blacklist is enabled
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
return (
decrypted_token["jti"] in BLACKLIST
) # Here we blacklist particular JWTs that have been created in the past.
api.add_resource(Store, "/store/<string:name>")
api.add_resource(StoreList, "/stores")
api.add_resource(Item, "/item/<string:name>")
api.add_resource(ItemList, "/items")
api.add_resource(UserRegister, "/register")
api.add_resource(User, "/user/<int:user_id>")
api.add_resource(UserLogin, "/login")
api.add_resource(TokenRefresh, "/refresh")
api.add_resource(UserLogout, "/logout")
if __name__ == "__main__":
db.init_app(app)
ma.init_app(app) # link the flask-marshmallow to our app
app.run(port=5000, debug=True)
@login.user_loader
def load_user(user_id):
return UserModel.find_by_id(_id=user_id)
#set configs
flask_app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', '1nd2')
#db setup
flask_app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'POSTGRES_URL', DATABASE_URI)
flask_app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
flask_app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(flask_app)
ma.init_app(flask_app)
migrate = Migrate(flask_app, db)
@flask_app.before_first_request
def create_tables():
db.create_all()
#admin setup
class MyModelView(ModelView):
def is_accessible(self):
return current_user.is_authenticated
def inaccessible_callback(self, name, **kwargs):
def create_app():
db.init_app(app)
# tells the marshmallow what app to communicate with
ma.init_app(app)
oauth.init_app(app)
return app
UserLogout,
)
from resources.confirmation import Confirmation, ConfirmationByUser
from resources.offer import OfferList, Offer, OfferCreate, UserOfferList
app = Flask(__name__)
load_dotenv(".env", verbose=True)
app.config.from_object(
"default_config") # load default configs from default_config.py
app.config.from_envvar(
"APPLICATION_SETTINGS"
) # override with config.py (APPLICATION_SETTINGS points to config.py)
api = Api(app)
jwt = JWTManager(app)
db.init_app(app) # remove after migrations
ma.init_app(app) # remove after migrations
migrate = Migrate(app, db)
@app.before_first_request
def create_tables():
db.create_all()
@app.errorhandler(ValidationError)
def handle_marshmallow_validation(err):
return jsonify(err.messages), 400
@jwt.token_in_blocklist_loader
def check_if_token_in_blacklist(decrypted_token):
def handle_marshmallow_validation(err):
return jsonify(err.messages), 400
jwt = JWTManager(app)
# This method will check if a token is blacklisted, and will be called automatically when blacklist is enabled
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
return (
decrypted_token["jti"] in BLACKLIST
) # Here we blacklist particular JWTs that have been created in the past.
api.add_resource(Store, "/store/<string:name>")
api.add_resource(StoreList, "/stores")
api.add_resource(Item, "/item/<string:name>")
api.add_resource(ItemList, "/items")
api.add_resource(UserRegister, "/register")
api.add_resource(User, "/user/<int:user_id>")
api.add_resource(UserLogin, "/login")
api.add_resource(TokenRefresh, "/refresh")
api.add_resource(UserLogout, "/logout")
api.add_resource(UserConfirmation, "/user_confirm/<int:userid>")
if __name__ == "__main__":
db.init_app(app)
ma.init_app(app) #tell what flask to talk to
app.run(port=5000, debug=True)
def revoked_token_called():
return jsonify({
'description': 'The token has been revoked',
'error': 'token_revoked'
}), 401
api.add_resource(Items, '/items')
api.add_resource(Item, '/item/<string:name>')
api.add_resource(Stores, '/stores')
api.add_resource(Store, '/store/<string:name>')
api.add_resource(UserRegister, '/register')
api.add_resource(User, '/user/<int:user_id>')
api.add_resource(UserLogin, '/login')
api.add_resource(UserLogout, '/logout')
api.add_resource(TokenRefresh, '/refresh')
api.add_resource(Confirmation, '/user_confirmation/<string:confirmation_id>')
api.add_resource(ConfirmationByUser, '/confirmation/user/<int:user_id>')
api.add_resource(GithubLogin, '/login/github')
api.add_resource(GithubAuthorize,
'/login/github/authorized',
endpoint='github.authorize')
api.add_resource(SetUserPassword, '/user/set_password')
if __name__ == '__main__':
from db import db
db.init_app(app)
ma.init_app(app) # Attach flask-marshmallow to current app
oauth.init_app(app)
app.run(port=5000, debug=True)
api = Api(app)
api.add_resource(User, "/user/<int:user_id>")
api.add_resource(UserRegister, "/register")
api.add_resource(UserLogin, "/login")
api.add_resource(Store, "/store/<string:name>")
api.add_resource(StoreList, "/stores")
api.add_resource(Item, "/item/<string:name>")
api.add_resource(ItemList, "/items")
api.add_resource(TokenRefresh, "/refresh")
api.add_resource(UserLogout, "/logout")
@app.before_first_request # in run.py
def create_tables():
db.create_all()
if __name__ == "__main__":
from db import db # avoid circular import
db.init_app(app)
ma.init_app(app) # link Marschmallow schema
app.run(port=5000, debug=True)
"""
Linking UserModel directly in the Schema with flask_marshmellow -> marshmellow loads UserModel objects directly
and not dicts income_data >> model object
"""
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
return (
decrypted_token["jti"] in BLACKLIST
) # Here we blacklist particular JWTs that have been created in the past.
api.add_resource(Confirmation, "/user_confirmation/<string:confirmation_id>")
api.add_resource(ConfirmationByUser, "/confirmation/user/<int:user_id>")
api.add_resource(TokenRefresh, "/refresh")
api.add_resource(User, "/user/<int:user_id>")
api.add_resource(UserRegister, "/register")
api.add_resource(UserLogin, "/login")
api.add_resource(UserLogout, "/logout")
api.add_resource(ImageUpload, "/upload/image")
api.add_resource(Image, "/image/<string:filename>")
api.add_resource(Item, "/item/<string:name>")
api.add_resource(ItemList, "/items")
api.add_resource(ItemPriorityFind, "/items/show_priority/<int:priority>")
api.add_resource(ProfileUpload, "/upload/profile")
api.add_resource(Profile, "/profile/<int:user_id>")
api.add_resource(ShoppingList, "/shopping_list/<string:name>")
api.add_resource(ListOfShoppingLists, "/shopping_lists")
if __name__ == "__main__":
db.init_app(app) # init sqlalchemy for flask app
ma.init_app(app) # init marshmallow for flask app
app.run(port=5000)
