def create_flask_app(): app = Flask(__name__) app.config.from_mapping( SQLALCHEMY_DATABASE_URI= f'postgresql://{os.environ["POSTGRES_USER"]}:{os.environ["POSTGRES_PASSWORD"]}' f'@{os.environ["POSTGRES_URL"]}/{os.environ["POSTGRES_DB"]}') from .db import db, migrate app.config.from_json('../config.json') db.init_app(app) migrate.init_app(app, db) from .views import IncidentsList, IncidentsDetail api = Api(app) api.route(IncidentsList, 'incidents_list', '/incidents') api.route(IncidentsDetail, 'incidents_detail', '/incidents/<int:id>') return app
def create_app(**config): app = Flask(__name__) from . import cli app.cli.add_command(cli.tasks) app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/tasks_dev' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config.update(config) if 'DATABASE_URL' in os.environ: app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL'] from .extensions import db db.init_app(app) from .resources import TaskDetail, TaskList api = Api(app) api.route(TaskList, 'task_list', '/tasks') api.route(TaskDetail, 'task_detail', '/tasks/<uuid:id>') return app
def make_jsonapi(app): jsonapi = JsonApi(app=app) jsonapi.route(SubstanceList, "substance_list", f"{api_versioning_v1}/substances") jsonapi.route(SubstanceResource, "substance_detail", f"{api_versioning_v1}/substances/<id>") jsonapi.route( SubstanceIndexResource, "substance_index", f"{api_versioning_v1}/substances/_index", ) jsonapi.route( SubstanceSearchResultList, "resolved_substance_list", f"{api_versioning_v1}/resolver", )
} class ComputerDetail(ResourceDetail): schema = ComputerSchema data_layer = {"session": db.session, "model": Computer} class ComputerRelationship(ResourceRelationship): schema = ComputerSchema data_layer = {"session": db.session, "model": Computer} # Create endpoints api = Api(app) api.route(PersonList, "person_list", "/persons") api.route( PersonDetail, "person_detail", "/persons/<int:id>", "/computers/<int:computer_id>/owner", ) api.route(PersonRelationship, "person_computers", "/persons/<int:id>/relationships/computers") api.route(ComputerList, "computer_list", "/computers", "/persons/<int:id>/computers") api.route(ComputerDetail, "computer_detail", "/computers/<int:id>") api.route(ComputerRelationship, "computer_person", "/computers/<int:id>/relationships/owner") if __name__ == "__main__":
from commandment.enroll.util import generate_enroll_profile from commandment.cms.decorators import verify_cms_signers from commandment.plistutil.nonewriter import dumps as dumps_none from commandment.profiles.plist_schema import ProfileSchema from commandment.profiles import PROFILE_CONTENT_TYPE from commandment.pki.ca import get_ca from commandment.dep import smime from .resources import DEPProfileList, DEPProfileDetail, DEPProfileRelationship import plistlib import json dep_app = Blueprint('dep_app', __name__) api = Api(blueprint=dep_app) api.route(DEPProfileList, 'dep_profile_list', '/v1/dep/profiles/') api.route(DEPProfileDetail, 'dep_profile_detail', '/v1/dep/profiles/<int:dep_profile_id>') api.route(DEPProfileRelationship, 'dep_profile_devices', '/v1/dep/profiles/<int:dep_profile_id>/relationships/devices') @dep_app.route('/v1/dep/account', methods=["GET"]) def account(): pass @dep_app.route('/dep/certificate/download', methods=["GET"]) def certificate_download(): """Create a new key/certificate to upload to the DEP/ASM/ABM portal.
self_view_kwargs = {'id': '<id>'} self_view_many = 'artist_many' id = fields.Integer() name = fields.Str(required=True) birth_year = fields.Integer(load_only=True) genre = fields.Str() # Create resource managers and endpoints from flask_rest_jsonapi import Api, ResourceDetail, ResourceList class ArtistMany(ResourceList): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} class ArtistOne(ResourceDetail): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} api = Api(app) api.route(ArtistMany, 'artist_many', '/artists') api.route(ArtistOne, 'artist_one', '/artists/<int:id>') # main loop to run app in debug mode if __name__ == '__main__': app.run(debug=True)
class PersonList(ResourceList): # def query(self, view_kwargs): # query_ = self.session.query(CompanyModel) # return query_ schema = PersonSchema data_layer = {'session': db.session, 'model': CompanyModel} # class PersonDetail(ResourceDetail): # schema = PersonSchema # data_layer = {'session': db.session, # 'model': CompanyModel} # # Create endpoints api = Api(app) api.route(PersonList, 'person_list', '/personsapi') #api.route(PersonDetail, 'person_detail', '/personsapi/<int:id>') # api.route(PersonRelationship, 'person_computers', '/persons/<int:id>/relationships/computers') # api.route(ComputerList, 'computer_list', '/computers', '/persons/<int:id>/computers') # api.route(ComputerDetail, 'computer_detail', '/computers/<int:id>') # api.route(ComputerRelationship, 'computer_person', '/computers/<int:id>/relationships/owner') # def J(*args, **kwargs): # """Wrapper around jsonify that sets the Content-Type of the response to # application/vnd.api+json. # """ # response = jsonify(*args, **kwargs) # response.mimetype = 'application/vnd.api+json' # return response # # @app.route('/posts/', methods=['GET'])
class AdDetail(ResourceDetail): schema = AdSchema data_layer = {'session': db.session, 'model': Ad} class AdRelationship(ResourceRelationship): schema = AdSchema data_layer = {'session': db.session, 'model': Ad} # Create endpoints api = Api(app) api.route(PersonList, 'person_list', '/persons') api.route(PersonDetail, 'person_detail', '/persons/<int:id>', '/ads/<int:ad_id>/created_by') api.route(PersonRelationship, 'person_ads', '/persons/<int:id>/relationships/ads') api.route(AdList, 'ad_list', '/ads', '/persons/<int:id>/ads') api.route(AdDetail, 'ad_detail', '/ads/<int:id>') api.route(AdRelationship, 'ad_person', '/ads/<int:id>/relationships/created_by') @app.route('/') def index(): return "Hello !"
reserved_two = fields.Str() reserved_three = fields.Str() reserved_four = fields.Str() created_time = fields.DateTime() updated_time = fields.DateTime() class USBInstallList(ResourceList): schema = USBInstallSchema data_layer = { 'session' : db.session, 'model' : USBInstall } class USBInstallDetail(ResourceDetail): schema = USBInstallSchema data_layer = { 'session' : db.session, 'model' : USBInstall } api = Api(dt_flask) api.route(USBInstallList, 'usbinstall_list', '/api/v1/usbinstall') api.route(USBInstallDetail, 'usbinstall_detail', '/api/v1/usbinstall/<int:id>') @dt_flask.route('/api/v1/add_from_app', methods = ['POST',]) def insert_db_record_from_app(): def request_json_looks_good(request_json): return True def create_usb_install_object(request_json, right_here_right_now): new_record = USBInstall(status="New", fiery_iso=request_json["fiery_iso"], osiso_one=request_json["osiso_one"],osiso_two=request_json["osiso_two"],usersw_iso=request_json["usersw_iso"],product_name=request_json["product_name"],created_time=right_here_right_now, updated_time=datetime.now()) try: new_record.adobe_iso = request_json["adobe_iso"] except: pass try:
class PlayerOne(ResourceDetail): schema = PlayerSchema data_layer = {'session': db.session, 'model': Player} class RoleMany(ResourceList): schema = RoleSchema data_layer = {'session': db.session, 'model': Role} class RoleOne(ResourceDetail): schema = RoleSchema data_layer = {'session': db.session, 'model': Role} class PlayerRole(ResourceRelationship): schema = PlayerSchema data_layer = {'session': db.session, 'model': Player} api = Api(app) api.route(PlayerMany, 'player_many', '/players') api.route(PlayerOne, 'player_one', '/players/<int:id>') api.route(RoleOne, 'role_one', '/roles/<int:id>') api.route(RoleMany, 'role_many', '/roles') api.route(PlayerRole, 'player_roles', '/players/<int:id>/relationships/roles') if __name__ == '__main__': app.run(debug=True)
self_view_many = 'drone_many' id = fields.Integer() name = fields.Str(required=True) latitude = fields.Float(required=False) longitude = fields.Float(required=False) altitude = fields.Float(required=False) class DroneMany(ResourceList): schema = DroneSchema data_layer = {'session': db.session, 'model': Drone} class DroneOne(ResourceDetail): schema = DroneSchema data_layer = {'session': db.session, 'model': Drone} api = Api(app) api.route(DroneMany, 'drone_many', '/drones') api.route(DroneOne, 'drone_one', '/drones/<int:id>') # Create data abstraction layer class PilotSchema(Schema): class Meta: type_ = 'pilot' self_view = 'pilot_one' self_view_kwargs = {'id': '<id>'} self_view_many = 'pilot_many' id = fields.Integer() name = fields.Str(required=True) birth_year = fields.Integer(load_only=True) genre = fields.Str()
# Create resource managers class PersonList(ResourceList): schema = PersonSchema data_layer = {'session': db.session, 'model': Person} methods = ['GET', 'POST'] class PersonDetail(ResourceDetail): schema = PersonSchema data_layer = {'session': db.session, 'model': Person} methods = ['GET', 'POST'] # Create endpoints api = Api(app) api.route(PersonList, 'person_list', '/persons') api.route(PersonDetail, 'person_detail', '/persons/<int:id>') if __name__ == '__main__': # Start application app.run(debug=True) ''' curl --header "Content-Type: application/json" --request POST --data '{"data": {"type": "person","id": "4","name": "bhujay" , "email": "*****@*****.**"}}' http://localhost:5000/persons { "data": { "id": "4", "type": "person" }, "jsonapi": {
""" file: blueprint.py (igsn-user-api) author: Jess Robertson, [email protected] date: July 2019 description: IGSN API """ # pylint: disable=C0103 from flask import Blueprint from flask_rest_jsonapi import Api from .resources import UserList, UserDetail, RoleList, RoleDetail from .models import * blueprint = Blueprint('igsn_user_api', __name__) api = Api(blueprint=blueprint) # Users api.route(UserList, 'user_list', '/users') api.route(UserDetail, 'user_detail', '/users/<int:id>') api.route(RoleList, 'role_list', '/roles') api.route(RoleDetail, 'role_detail', '/roles/<int:id>')
# -*- coding: utf-8 -*- import os from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_rest_jsonapi import Api app = Flask(__name__) app.config.from_object(os.environ['APP_SETTINGS']) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) from resources import * api = Api(app) api.route(ClientList, 'client_list', '/clients') api.route(ClientDetail, 'client_detail', '/clients/<int:id>', '/users/<int:user_id>/owner') api.route(ClientRelationship, 'client_users', '/clients/<int:id>/relationships/users') api.route(UserList, 'user_list', '/users', '/clients/<int:id>/users') api.route(UserDetail, 'user_detail', '/users/<int:id>') api.route(UserRelationship, 'user_client', '/users/<int:id>/relationships/owner') if __name__ == '__main__': app.run()
isbn = fields.Str() email = fields.Str() class BookAll(ResourceList): schema = BookSchema data_layer = {'session': db.session, 'model': Books} class BookOne(ResourceDetail): schema = BookSchema data_layer = {'session': db.session, 'model': Books} api = Api(app) api.route(BookAll, 'book_all', '/books') api.route(BookOne, 'book_one', '/books/<int:id>') ################################################################################ ############################# VIEWS ########################################### @login_manager.user_loader def load_user(user_id): return User.query.get(int(user_id)) class LoginForm(FlaskForm): username = StringField('username', validators=[InputRequired(), Length(min=5, max=50)])
from flask_rest_jsonapi import Api, ResourceList, ResourceDetail from marshmallow_jsonapi import fields from marshmallow_jsonapi.flask import Schema api = Api(app) class ProductSchema(Schema): class Meta: type_ = 'product' self_view = 'product_detail' self_view_kwargs = {'id': '<id>'} self_view_many = 'products' id = fields.Integer(as_string=True, dump_only=True) name = fields.Str(required=True, dump_only=True) class ProductList(ResourceList): schema = ProductSchema data_layer = {'session': db.session, 'model': Product} class ProductDetail(ResourceDetail): schema = ProductSchema data_layer = {'session': db.session, 'model': Product} api.route(ProductList, 'products', '/products') api.route(ProductDetail, 'product_detail', '/products/<int:id>', '/products/<int:product_id>')
print("$ pip3 install flask_rest_jsonapi") raise from lib.Resources import HypervisorsList, HypervisorDetail, HypervisorRelationship from lib.Resources import VirtualMachineList, VirtualMachineDetail, VirtualMachineRelationship from lib.LibVirt import LibVirtMonitorInstance from lib.LibVirtData import libvirt_data app = Flask(__name__) app.config['SECRET_KEY'] = 'SGVsbG8sIHdvcmxkIQ==' app.config['DEBUG'] = True api = Api(app) # ~ socketio = SocketIO(app) api.route(HypervisorsList, 'hypervisors_list', '/hypervisors') api.route(HypervisorDetail, 'hypervisor_detail', '/hypervisors/<int:id>', '/virtual-machines/<string:virtual_machine_id>/hypervisor') api.route(HypervisorRelationship, 'hypervisor_virtual_machines', '/hypervisors/<int:id>/relationships/virtual-machines') api.route(VirtualMachineList, 'virtual_machine_list', '/virtual-machines', '/hypervisors/<int:id>/virtual-machines') api.route(VirtualMachineDetail, 'virtual_machine_detail', '/virtual-machines/<string:id>') api.route(VirtualMachineRelationship, 'virtual_machine_hypervisor', '/virtual-machines/<string:id>/relationships/hypervisor') if __name__ == '__main__': monitor_tasks = []
polar_angle = fields.Decimal(validate = validate.Range(min=0,max=1)) class PulseList(ResourceList): schema = PulseSchema data_layer = {'session': db.session, 'model': Pulse} class PulseDetail(ResourceDetail): schema = PulseSchema data_layer = {'session': db.session, 'model': Pulse } @app.route("/",methods=['GET']) def hellow(): return "hello world" @app.route("/pulses/download") def downloadpulses(): print("downloading pulses") api = Api(app) api.route(PulseList,'pulses_list','/pulses') api.route(PulseDetail,'pulse_detail','/pulses/<int:id>') if __name__ == "__main__": app.run(debug=True)
data_layer = {'session': db.session, 'model': Settings} class EntitiesList(ResourceList): schema = EntitiesSchema data_layer = {'session': db.session, 'model': Entities} class EntitiesDetail(ResourceDetail): schema = EntitiesSchema data_layer = {'session': db.session, 'model': Entities} # Create the API object api = Api(app) api.route(SettingsList, 'setting_list', '/api/settings') api.route(SettingsDetail, 'setting_detail', '/api/settings/<int:id>') api.route(EntitiesList, 'entity_list', '/api/entities') api.route(EntitiesDetail, 'entity_detail', '/api/entities/<int:id>') @app.route('/') def send_index(): return send_from_directory('web/dist/', 'index.html') @app.route('/css/<path:path>') def send_css(path): return send_from_directory('web/dist/css', path)
from commandment.enroll.util import generate_enroll_profile from commandment.cms.decorators import verify_cms_signers from commandment.plistutil.nonewriter import dumps as dumps_none from commandment.profiles.plist_schema import ProfileSchema from commandment.profiles import PROFILE_CONTENT_TYPE from commandment.pki.ca import get_ca from commandment.dep import smime from .resources import DEPProfileList, DEPProfileDetail, DEPProfileRelationship, DEPAccountList, DEPAccountDetail import plistlib import json dep_app = Blueprint('dep_app', __name__) api = Api(blueprint=dep_app) api.route(DEPProfileList, 'dep_profiles_list', '/api/v1/dep/profiles/', '/api/v1/dep/accounts/<int:dep_account_id>/profiles') api.route(DEPProfileDetail, 'dep_profile_detail', '/api/v1/dep/profiles/<int:dep_profile_id>') api.route(DEPProfileRelationship, 'dep_profile_devices', '/api/v1/dep/profiles/<int:dep_profile_id>/relationships/devices') api.route( DEPProfileRelationship, 'dep_profile_dep_account', '/api/v1/dep/profiles/<int:dep_profile_id>/relationships/dep_account') api.route(DEPAccountList, 'dep_accounts_list', '/api/v1/dep/accounts/') api.route(DEPAccountDetail, 'dep_account_detail', '/api/v1/dep/accounts/<int:dep_account_id>') @dep_app.route('/dep/certificate/download', methods=["GET"]) def certificate_download(): """Create a new key/certificate to upload to the DEP/ASM/ABM portal.
from flask import Blueprint, request from flask_rest_jsonapi import Api from commandment.apps.resources import ApplicationDetail, ApplicationList, ApplicationRelationship, \ ManagedApplicationList, ManagedApplicationDetail, ManagedApplicationRelationship, MASApplicationList, \ MASApplicationDetail, IOSApplicationList, IOSApplicationDetail api_app = Blueprint('applications_api', __name__) api = Api(blueprint=api_app) api.route(ApplicationList, 'applications_list', '/v1/applications') api.route(ApplicationDetail, 'application_detail', '/v1/applications/<int:application_id>') api.route(ApplicationRelationship, 'application_tags', '/v1/applications/<int:application_id>/relationships/tags') api.route(ManagedApplicationList, 'managed_applications_list', '/v1/managed_applications', '/v1/applications/<int:application_id>/managed_applications') api.route(ManagedApplicationDetail, 'managed_application_detail', '/v1/managed_applications/<int:managed_application_id>') api.route(ManagedApplicationRelationship, 'managed_application_device', '/v1/managed_applications/<int:application_id>/relationships/device') # Platform specific subclasses api.route(MASApplicationList, 'mas_applications_list', '/v1/applications/store/mac') api.route(MASApplicationDetail, 'mas_application_detail', '/v1/applications/store/mac/<int:application_id>') api.route(IOSApplicationList, 'ios_applications_list',
from flask import Blueprint from flask_rest_jsonapi import Api from commandment.profiles.resources import ProfilesList, ProfileDetail, ProfileRelationship profiles_api_app = Blueprint('profiles_api', __name__) api = Api(blueprint=profiles_api_app) # Profiles (Different to profiles returned by inventory) api.route(ProfilesList, 'profiles_list', '/v1/profiles') api.route(ProfileDetail, 'profile_detail', '/v1/profiles/<int:profile_id>') api.route(ProfileRelationship, 'profile_tags', '/v1/profiles/<int:profile_id>/relationships/tags') # api.route(PayloadsList, 'payloads_list', '/v1/payloads') # api.route(PayloadDetail, 'payload_detail', '/v1/payloads/<int:payload_id>')
class PriorityDetail(ResourceDetail): schema = PrioritySchema data_layer = {'session': db.session, 'model': Priority} class FeatureRequestDetail(ResourceDetail): schema = FeatureRequestSchema data_layer = {'session': db.session, 'model': FeatureRequest} class FeatureRequestList(ResourceList): schema = FeatureRequestSchema data_layer = {'session': db.session, 'model': FeatureRequest} # Create endpoints api = Api(app) api.route(ClientList, 'client_list', '/clients') api.route(ClientDetail, 'client_detail', '/clients/<int:id>') api.route(ProductAreaList, 'product_area_list', '/product_areas') api.route(ProductAreaDetail, 'product_area_detail', '/product_areas/<int:id>') api.route(PriorityList, 'priority_list', '/priorities') api.route(PriorityDetail, 'priority_detail', '/priorities/<int:id>') api.route(FeatureRequestList, 'feature_request_list', '/feature_requests') api.route(FeatureRequestDetail, 'feature_request_detail', '/feature_requests/<int:id>') if __name__ == '__main__': # Start application app.run(debug=True)
schema = RecordSchema data_layer = {'session': db.session, 'model': Record} class UserRecord(ResourceRelationship): schema = UserSchema data_layer = {'session': db.session, 'model': User} class TournRecord(ResourceRelationship): schema = TournSchema data_layer = {'session': db.session, 'model': Tourn} api = Api(app) api.route(UserMany, 'user_many', '/users') api.route(UserOne, 'user_one', '/users/<int:id>') api.route(TournMany, 'tourn_many', '/tourns') api.route(TournOne, 'tourn_one', '/tourns/<int:id>') api.route(RecordOne, 'record_one', '/records/<int:id>') api.route(RecordMany, 'record_many', '/records') api.route(UserRecord, 'user_records', '/users/<int:id>/relationships/records') api.route(TournRecord, 'tourn_records', '/tourns/<int:id>/relationships/records') # main loop to run app in debug mode if __name__ == '__main__': app.secret_key = 'test' app.run(host=str(get_info(2)), port=int(get_info(3)), debug=False)
id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) db.create_all() class EntrySchema(Schema): class Meta: type_ = 'entry' self_view = 'entry_one' self_view_kwargs = {'id': '<id>'} self_view_many = 'entry_many' id = fields.Integer() name = fields.Str(required=True) class EntryMany(ResourceList): schema = EntrySchema data_layer = {'session': db.session, 'model': Entry} class EntryOne(ResourceDetail): schema = EntrySchema data_layer = {'session': db.session, 'model': Entry} api = Api(app) api.route(EntryMany, 'entry_many', '/entries') api.route(EntryOne, 'entry_one', '/entries/<int:id>') if __name__ == '__main__': app.run(debug=True)
artist_id = fields.Integer(required=True) class ArtworkMany(ResourceList): schema = ArtworkSchema data_layer = {'session': db.session, 'model': Artwork} class ArtworkOne(ResourceDetail): schema = ArtworkSchema data_layer = {'session': db.session, 'model': Artwork} class ArtistArtwork(ResourceRelationship): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} api = Api(app) api.route(ArtworkOne, 'artwork_one', '/artworks/<int:id>') api.route(ArtworkMany, 'artwork_many', '/artworks') api.route(ArtistArtwork, 'artist_artworks', '/artists/<int:id>/relationships/artworks') # main loop to run app in debug mode if __name__ == '__main__': # Create the table db.create_all() app.run(debug=True)
def create_app(config_filename=None, host="localhost"): app = Flask(__name__) # app.config.update(SQLALCHEMY_DATABASE_URI="sqlite://") app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///test.db" db.init_app(app) api = Api(app) api.route(PersonList, "person_list", "/persons") api.route( PersonDetail, "person_detail", "/persons/<int:id>", "/computers/<int:id>/owner" ) api.route( PersonRelationship, "person_computers", "/persons/<int:id>/relationships/computers", ) api.route( ComputerList, "computer_list", "/computers", "/persons/<int:person_id>/computers", ) api.route(ComputerDetail, "computer_detail", "/computers/<int:id>") api.route( ComputerRelationship, "computer_person", "/computers/<int:id>/relationships/owner", ) with app.app_context(): db.create_all() create_api(app, host) return app
} } class ComputerDetail(ResourceDetail): schema = ComputerSchema data_layer = {'session': db.session, 'model': Computer} class ComputerRelationship(ResourceRelationship): schema = ComputerSchema data_layer = {'session': db.session, 'model': Computer} # Create endpoints api = Api(app) api.route(PersonList, 'person_list', '/persons') api.route(PersonDetail, 'person_detail', '/persons/<int:id>', '/computers/<int:computer_id>/owner') api.route(PersonRelationship, 'person_computers', '/persons/<int:id>/relationships/computers') api.route(ComputerList, 'computer_list', '/computers', '/persons/<int:id>/computers') api.route(ComputerDetail, 'computer_detail', '/computers/<int:id>') api.route(ComputerRelationship, 'computer_person', '/computers/<int:id>/relationships/owner') if __name__ == '__main__': # Start application app.run(debug=True)
weaknesses = fields.Dict() # Create resource managers and endpoints class PokemonMany(ResourceList): schema = PokemonSchema data_layer = {'session': db.session, 'model': Pokemon} class PokemonOne(ResourceDetail): schema = PokemonSchema data_layer = {'session': db.session, 'model': Pokemon} api = Api(app) api.route(PokemonMany, 'pokemon_many', '/pokemon') api.route(PokemonOne, 'pokemon_one', '/pokemon/<int:id>') @app.route("/pokemon/<string:name>") def user_detail(name): schema = PokemonSchema() p = Pokemon.query.filter_by(name=name).first() pdict = schema.dump(p) print(pdict) return pdict @app.route("/types/<string:type1>/<string:type2>")
data_layer = {'session': db.session, 'model': Review, 'methods': {'query': query, 'before_create_object': before_create_object}} class ReviewDetail(ResourceDetail): schema = ReviewSchema data_layer = {'session': db.session, 'model': Review} class ReviewRelationship(ResourceRelationship): schema = ReviewSchema data_layer = {'session': db.session, 'model': Review} # Create endpoints api = Api(app) api.route(BookList, 'book_list', '/books') api.route(BookDetail, 'book_detail', '/books/<int:id>', '/reviews/<int:review_id>/book') api.route(BookRelationship, 'book_reviews', '/books/<int:id>/relationships/reviews') api.route(ReviewList, 'review_list', '/reviews', '/books/<int:id>/reviews') api.route(ReviewDetail, 'review_detail', '/reviews/<int:id>') api.route(ReviewRelationship, 'review_book', '/reviews/<int:id>/relationships/book') if __name__ == '__main__': # Start application app.run(debug=True)