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)
