import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.authn.serializers import authn_orgunit_request
from rest_api_demo.api.authn.parsers import orgunit_request_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import AuthnOrgUnit
log = logging.getLogger(__name__)
ns = api.namespace(
'authn/orgunits',
description='Operations related to oganizational units within accounts')
@ns.route('/')
class OrgUnitsCollection(Resource):
@api.expect(orgunit_request_arguments)
@api.marshal_with(authn_orgunit_request)
def get(self):
"""
Returns OrgUnits
"""
args = orgunit_request_arguments.parse_args(request)
user_id = args.get('user-id')
practice_name = args.get('practice-name')
location_name = args.get('location-name')
return AuthnOrgUnit.query.filter(AuthnOrgUnit.id == user_id).one()
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.petstore.business import create_pet
from rest_api_demo.api.petstore.serializers import pet
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Pet
log = logging.getLogger(__name__)
ns = api.namespace('petstore/pets',
description='Operations related to petstore')
@ns.route('/')
class PetCollection(Resource):
@api.marshal_list_with(pet)
def get(self):
"""
Returns list of petstore pets.
"""
pets = Pet.query.all()
return pets
@api.response(201, 'Pet successfully created.')
@api.expect(pet)
def post(self):
"""
Creates a new Petstore pet.
"""
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_category, delete_category, update_category
from rest_api_demo.api.blog.serializers import category, category_with_posts
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Category
log = logging.getLogger(__name__)
ns = api.namespace('AIDS/categories',
description='Operations related to AIDS categories')
@ns.route('/')
class CategoryCollection(Resource):
@api.marshal_list_with(category)
def get(self):
"""
Returns list of AIDS categories.
"""
categories = Category.query.all()
return categories
@api.response(201, 'Category successfully created.')
@api.expect(category)
def post(self):
"""
Creates a new AIDS performance category.
"""
from flask import request
from flask_restplus import Resource
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.restplus import api
from pets_api.database.models import Pet
from flask import Flask, request, jsonify, flash, url_for, redirect, render_template
ns = api.namespace('/pet', description='Operations related to pets')
# endpoint to add a new pet
@app.route('/', methods=['GET', 'POST'])
def pet():
if request.method == "POST":
pet_name = request.form.get('pet_name')
photoUrls = request.form.get('photoUrls')
status = request.form.get('status')
category = request.form.get('category')
pet_category = Category.query.filter_by(category_name=category).first()
if pet_name == '':
return render_template("pet.html",
categories=Category.query.all(),
error="Please fill out the name field.")
try:
new_pet = Pet(pet_name, photoUrls, status)
from flask import request, Flask
from flask_cors import CORS, cross_origin
from flask_restplus import Resource
from rest_api_demo.api.client.business import create_client_user, update_user, delete_user
from rest_api_demo.api.client.serializers import client_user, page_of_client_users
from rest_api_demo.api.client.parsers import pagination_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import User
log = logging.getLogger(__name__)
app = Flask(__name__)
cors = CORS(app, resources={r"/atr/*": {"origins": "*"}})
ns = api.namespace('client/users', description='Operations related to client users')
@ns.route('/')
class UsersCollection(Resource):
#@api.expect(pagination_arguments)
#@api.marshal_with(page_of_client_users)
def get(self):
user = User.all()
return user, {'Access-Control-Allow-Origin': '*'}
@api.expect(client_user)
def post(self):
print("===============post")
"""
Creates a new client user.
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_category, delete_category, update_category
from rest_api_demo.api.blog.serializers import category, category_with_posts
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Category
log = logging.getLogger(__name__)
ns = api.namespace('blog/categories', description='Operations related to blog categories')
@ns.route('/')
class CategoryCollection(Resource):
@api.marshal_list_with(category)
def get(self):
"""
Returns list of blog categories.
"""
categories = Category.query.all()
return categories
@ns.route('/<int:id>')
@api.response(404, 'Category not found.')
class CategoryItem(Resource):
@api.marshal_with(category_with_posts)
def get(self, id):
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_blog_post, update_post, delete_post
from rest_api_demo.api.blog.serializers import blog_post, page_of_blog_posts
from rest_api_demo.api.blog.parsers import pagination_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Post
log = logging.getLogger(__name__)
ns = api.namespace('PerformanceCalculator/CD4', description='Operations related to Performance of the AIDS patient')
@ns.route('/')
class PostsCollection(Resource):
@api.expect(pagination_arguments)
@api.marshal_with(page_of_blog_posts)
def get(self):
"""
Returns list of CD4 counting.
"""
args = pagination_arguments.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
posts_query = Post.query
posts_page = posts_query.paginate(page, per_page, error_out=False)
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.auction.business import create_bid_post, update_bid, delete_bid
from rest_api_demo.api.auction.serializers import auction_bid, page_of_vehicle_bids
from rest_api_demo.api.auction.parsers import pagination_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Post
ns = api.namespace('auction/bids',
description='Operations related to auction bids')
@ns.route('/')
class BidsCollection(Resource):
@api.expect(pagination_arguments)
@api.marshal_with(page_of_vehicle_bids)
def get(self):
"""
Returns list of vehicle bids.
"""
args = pagination_arguments.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
bids_query = Bids.query
bids_page = bids_query.paginate(page, per_page, error_out=False)
return bids_page
@api.expect(auction_bid)
def post(self):
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_category, delete_category, update_category
from rest_api_demo.api.blog.serializers import person, person_with_findings, category, category_with_posts
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Category
log = logging.getLogger(__name__)
ns = api.namespace('people',
description='Operations related to person Objects')
@ns.route('/')
class PersonCollection(Resource):
@api.marshal_list_with(person)
def get(self):
"""
Returns list of people.
"""
categories = Category.query.all()
return categories
@api.response(201, 'Person successfully created.')
@api.expect(person)
def post(self):
"""
Creates a new person object.
"""
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.auction.business import create_vehicle, delete_vehicle, update_vehicle
from rest_api_demo.api.auction.serializers import vehicle, vehicle_with_posts
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Vehicle
ns = api.namespace('auction/vehicles',
description='Operations related to auction vehicles')
#category = vehicles
#posts = bids
@ns.route('/')
class VehicleCollection(Resource):
@api.marshal_list_with(vehicle)
def get(self):
"""
Returns list of blog categories.
"""
categories = Vehicles.query.all()
return categories
@api.response(201, 'Vehicle successfully created.')
@api.expect(vehicle)
def post(self):
"""
Creates a new blog category.
"""
data = request.json
create_vehicle(data)
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_blog_user
from rest_api_demo.api.blog.serializers import blog_user
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import User
log = logging.getLogger(__name__)
ns = api.namespace('blog/users', description='Operations related to blog users')
@ns.route('/')
@api.response(404, 'User not found.')
class Users(Resource):
@api.response(200, 'User found.')
@api.marshal_with(blog_user)
def get(self):
users = User.query.all()
log.info('{}'.format(users))
return users
@api.response(200, 'User created.')
@api.expect(blog_user)
def post(self):
create_blog_user(request.json)
return None, 201
import logging
from flask import request
from flask_restplus import Resource, fields
# from rest_api_demo.api.blog.business import create_category, delete_category, update_category
# from rest_api_demo.api.neural_nets_ocr.serializers import category, category_with_posts
from rest_api_demo.api.restplus import api
# from rest_api_demo.database.models import Category
log = logging.getLogger(__name__)
ns = api.namespace('omr/scanning',
description='Operations related to blog categories')
resource_fields = api.model('Resource', {
'url': fields.String,
})
@ns.route('/')
class CategoryCollection(Resource):
def get(self):
return "Hello"
@api.response(201, 'Excel successfully created.')
@api.expect(resource_fields)
def post(self):
"""
Generate excel file for student.
"""
data = request.json['url']
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.authn.serializers import authn_account_request
from rest_api_demo.api.authn.parsers import pagination_arguments, account_request_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import AuthnAccount
log = logging.getLogger(__name__)
ns = api.namespace('authn/accounts',
description='Operations related to defining accounts.')
@ns.route('/')
class AccountsCollection(Resource):
@api.expect(account_request_arguments)
@api.marshal_with(authn_account_request)
def get(self):
"""
Returns Accounts
"""
args = account_request_arguments.parse_args(request)
user_id = args.get('user-id')
return AuthnAccount.query.filter(AuthnAccount.id == user_id).one()
@ns.route('/<int:id>')
@api.response(404, 'Post not found.')
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.authz.serializers import authz_role
from rest_api_demo.api.authn.parsers import pagination_arguments, role_request_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import AuthzRole
log = logging.getLogger(__name__)
ns = api.namespace('authz/roles',
description='Operations related to blog posts')
@ns.route('/')
class RolesCollection(Resource):
@api.expect(role_request_arguments)
@api.marshal_with(authz_role)
def get(self):
"""
Returns Roles
"""
args = role_request_arguments.parse_args(request)
return AuthzRole.query.filter(AuthzRole.id == user_id).one()
@ns.route('/<int:id>')
@api.response(404, 'Post not found.')
class RoleItem(Resource):
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.authz.business import create_category, delete_category, update_category
from rest_api_demo.api.authz.parsers import features_request_arguments
from rest_api_demo.api.authz.serializers import authz_feature_request, category, category_with_posts
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Category, AuthzFeature, Item
log = logging.getLogger(__name__)
ns = api.namespace('authz/features', description='Features that the user may be authorized to use.')
@ns.route('/')
class FeatureCollection(Resource):
@api.expect(features_request_arguments)
@api.marshal_list_with(authz_feature_request)
def get(self):
"""
Returns list of features available to the user
"""
args = features_request_arguments.parse_args(request)
user_id = args.get('user-id')
practice_name = args.get('practice-name')
location_name = args.get('location-name')
role_name = args.get('role-name')
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Category, PetSchema
from flask import Flask, request, jsonify, flash, url_for, redirect, render_template
ns = api.namespace('/category', description='Operations related to categories')
pets_schema = PetSchema(many=True)
@app.route('/', methods=['GET','POST'])
def add_category():
error=None
if request.method == 'POST':
category_name=request.form.get('category_name')
try:
if category_name is not None:
new_category = Category(category_name)
db.session.add(new_category)
db.session.commit()
return redirect(url_for('home_page', pets = Pet.query.all(),
categories = Category.query.all()))
else:
error = "invalid category_name"
return render_template('category.html', categories = Category.query.all(), error=error)
except InvalidRequestError as e:
return render_template('category.html', categories = Category.query.all(),
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_category, delete_category, update_category
from rest_api_demo.api.blog.serializers import finding, finding_with_person_and_source, category, category_with_posts
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Category
log = logging.getLogger(__name__)
ns = api.namespace('finding', description='Operations related to finding objects')
@ns.route('/')
class FindingCollection(Resource):
@api.response(201, 'finding successfully created.')
@api.expect(finding)
def post(self):
"""
Creates a new finding object.
"""
data = request.json
create_category(data)
return None, 201
@ns.route('/<int:id>')
@api.response(404, 'Finding not found.')
class FindingItem(Resource):
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.authn.serializers import authn_user_request
from rest_api_demo.api.authn.parsers import pagination_arguments, user_request_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Post, AuthnUser
log = logging.getLogger(__name__)
ns = api.namespace('authn/users',
description='Operations related to blog posts')
@ns.route('/')
class UsersCollection(Resource):
@api.expect(user_request_arguments)
@api.marshal_with(authn_user_request)
def get(self):
"""
Returns Users
"""
args = user_request_arguments.parse_args(request)
user_id = args.get('user-id')
practice_name = args.get('practice-name')
location_name = args.get('location-name')
return AuthnUser.query.filter(AuthnUser.id == user_id).one()
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_blog_post, update_post, delete_post
from rest_api_demo.api.blog.serializers import blog_post, page_of_blog_posts
from rest_api_demo.api.blog.parsers import pagination_arguments
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Post
log = logging.getLogger(__name__)
ns = api.namespace('blog/posts', description='Operations related to blog posts')
@ns.route('/')
class PostsCollection(Resource):
@api.expect(pagination_arguments)
@api.marshal_with(page_of_blog_posts)
def get(self):
"""
Returns list of blog posts.
"""
args = pagination_arguments.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
posts_query = Post.query
posts_page = posts_query.paginate(page, per_page, error_out=False)
import logging
from flask import request
from flask_restplus import Resource
from rest_api_demo.api.blog.business import create_category, delete_category, update_category
from rest_api_demo.api.blog.serializers import source, source_with_findings, category, category_with_posts
from rest_api_demo.api.restplus import api
from rest_api_demo.database.models import Category
log = logging.getLogger(__name__)
ns = api.namespace('sources',
description='Operations related to source Objects')
@ns.route('/')
class SourceCollection(Resource):
@api.marshal_list_with(source)
def get(self):
"""
Returns list of sources.
"""
categories = Category.query.all()
return categories
@api.response(201, 'Source successfully created.')
@api.expect(source)
def post(self):
"""
Creates a new source object.
"""
