import logging
from flask import request
from flask_restplus import Resource
from app.api.bigquery.business_interactions import get_request_status, run_query, ndex
from app.api.bigquery.serializers import query_request, query_status_response, query_response, ndex_request, ndex_response
from app.api.bigquery.parsers import query_url_parser
from app.api.restplus import api
from app.database.models import TestModel
from app import settings
log = logging.getLogger(__name__)
ns = api.namespace('interactions',
description="""Mine the interaction profiles of various
entities
""")
@ns.route('/ndex')
class NDExSubmit(Resource):
@ns.doc(model=ndex_response)
@ns.expect(ndex_request)
def post(self):
log.info("%s" % (str(request.json), ))
response = ndex(request.json)
code = 200 if response['status'] == 'complete' else 404
return response, code
@ns.doc(params={'request_id': 'The request id for a query'})
import logging
#from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from werkzeug.exceptions import BadRequest
from quart import Response
from app.api.restplus import api
from app.models import User
log = logging.getLogger(__name__)
ns = api.namespace('users', description='Users')
user = api.model('user', {
'id': fields.Integer(readOnly=True, description='The internal id of of a user'),
'user_id': fields.String(required=True, description='The user unique identifier')}
)
@ns.route('/')
@api.response(404, 'Users not found.')
class UsersList(Resource):
@api.marshal_list_with(user)
def get(self):
"""
Returns a list of all users
:return: list_of_users
"""
try:
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from neomodel import MultipleNodesReturned
from app.api.restplus import api
from app.models import Browser
log = logging.getLogger(__name__)
ns = api.namespace('browsers', description='Browsers')
browser = api.model('browser', {
'id': fields.Integer(readOnly=True, description='The internal id of the browser.'),
'type': fields.String(required=True, description='The type of the browser.'),
'version': fields.String(required=True, description='The version of the browser.')
})
@ns.route('/')
class BrowserList(Resource):
@api.marshal_list_with(browser)
def get(self):
"""
Returns a list with all browsers
:return: list_of_browsers
"""
try:
from flask import request
from flask_restplus import Resource
from sqlalchemy.exc import IntegrityError
from werkzeug.exceptions import BadRequest
from app.api.restplus import api
from app.api.serializers import user
from app.extensions import db
from app.models.User import User
ns = api.namespace('users', description='Operations related to users')
@ns.route('')
class UsersCollection(Resource):
@api.marshal_list_with(user)
def get(self):
"""
Returns list of users
"""
return User.query.filter(User.delete_flag == 0).all(), 200
@api.response(201, 'User successfully created.')
@api.expect(user)
def post(self):
"""
Register a new user
"""
try:
user = User(email=request.json.get('email'))
db.session.add(user)
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from app.api.restplus import api
from app.models import Device
log = logging.getLogger(__name__)
ns = api.namespace('devices', description='Device')
device = api.model('device', {
'id': fields.Integer(readOnly=True, description='The internal id of the application.'),
'family': fields.String(required=True, description='The family (e.g.: iOS, Android, Windowss, etc...) of the device.'),
'brand': fields.String(required=True, description='The brand of the device.'),
'model': fields.String(required=True, description='The model of the device.'),
'type': fields.String(required=True, description='The type of the device.'),
'is_touch_capable': fields.Boolean(required=True, description='Indicates if the device is touch capable.')
})
@ns.route('/')
class DevicesList(Resource):
@api.marshal_list_with(device)
def get(self):
"""
Return a list with all devices.
:return: list_of_devices
"""
import logging
from flask import request
from flask_restplus import Resource
from app.api.blog.business import create_blog_post, update_post, delete_post
from app.api.blog.serializers import blog_post, page_of_blog_posts
from app.api.blog.parsers import pagination_arguments
from app.api.restplus import api
from app.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 app.api.test.business import create_new_entry
from app.api.test.serializers import entry
from app.api.test.parsers import pagination_arguments
from app.api.restplus import api
log = logging.getLogger(__name__)
ns = api.namespace('tests', description='Operations related to health tests')
@ns.route('/')
class TestsCollection(Resource):
def get(self):
"""
Returns list of health tests
"""
tests = ['database is ok', 'api-1 is ok', 'api-2 is ok']
return tests
@api.expect(entry)
def post(self):
"""
Creates a new entry
"""
create_new_entry(request.json)
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from app.api.restplus import api, base_reponse
from app.models import Session
log = logging.getLogger(__name__)
ns = api.namespace('sessions', description='Sessions')
session = api.model('session', {
'id': fields.Integer(readOnly=True, description='The internal id of of a session.'),
'session_id': fields.String(required=True, description='The session id.'),
'ip_address': fields.String(required=True, description='A list of IP addresses '
'used during the session.'),
'start': fields.DateTime(required=True, description='The date and time when the session '
'started.'),
'end': fields.DateTime(required=True, description='The date and time when the session ended.'),
'timeout': fields.DateTime(required=True, description='The date and time when the session timedout.')
})
# TODO - Define endpoints that return sessions that started, ended and timedout in a date/time range, used a given ip address
@ns.route('/')
class SessionsList(Resource):
@api.marshal_list_with(session)
def get(self):
"""
import logging
from flask import request
from flask_restplus import Resource
from app.api.blog.business import create_category, delete_category, update_category
from app.api.blog.serializers import category, category_with_posts
from app.api.restplus import api
from app.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
@api.response(201, 'Category successfully created.')
@api.expect(category)
def post(self):
"""
Creates a new blog category.
"""
import logging
from flask import request, abort
from flask_restplus import Resource
from app.api.visitor.serializers import logvisit_location
from app.api.restplus import api
from app import User
from app.api.visitor.business import getLastLocation
log = logging.getLogger(__name__)
ns = api.namespace('tracking',
path='/visitor',
description='Operations related to visits')
parser = api.parser()
auth_token_help = 'API Authentication token <token_auth>'
parser.add_argument('token_auth',
required=True,
help=auth_token_help,
type=str,
location='headers')
# create copy of parser and add payload, for POST and PUT methods
parser_payload = parser.copy()
parser_payload.add_argument('Payload',
required=True,
help='JSON Payload',
type='list',
location='json')
from flask_restplus import Resource
from app.api.bigquery.business_interactions import get_request_status, run_query, ndex
from app.api.bigquery.serializers import query_request, query_status_response, query_response, ndex_request, ndex_response
from app.api.bigquery.parsers import query_url_parser
from app.api.restplus import api
from app.database.models import TestModel
from app import settings
from app.api.bigquery.endpoints.bglite import ns as lilgim
from app.api.bigquery.endpoints.biggim import ns as biggim
from app.api.bigquery.endpoints.bigclam import ns as bigclam
log = logging.getLogger(__name__)
ns = api.namespace(
'results',
description="""Retrieve (or send to NDEX) the results of queries """)
@ns.route('/ndex')
class NDExSubmit(Resource):
@ns.doc(model=ndex_response)
@ns.expect(ndex_request)
def post(self):
"""Push a query result to NDEX"""
log.info("%s" % (str(request.json), ))
response = ndex(request.json)
code = 200 if response['status'] == 'complete' else 404
return response, code
from flask import request
from flask_restplus import Resource
from app.api.bigquery.business_interactions import get_request_status, run_bigclam_g2g_query, run_bigclam_g2d_query, ndex
from app.api.bigquery.serializers import bigclam_query_request, query_status_response, query_response, ndex_request, ndex_response
from app.api.bigquery.parsers import bigclam_query_url_parser
from app.api.restplus import api
from app.database.models import TestModel
from app import settings
log = logging.getLogger(__name__)
ns = api.namespace(
'bigclam',
description=
"""Associations between genomic aberrations, gene knockdowns and drug response in cell lines."""
)
@ns.route('/g2d/query')
class BigclamQuery(Resource):
@ns.response(400, "Bad query request.")
@ns.response(200, "OK")
@ns.doc(model=query_response)
@ns.expect(bigclam_query_url_parser, validate=False)
def get(self):
"""Genomic aberrations in INPUT genes lead to sensitivity to OUTPUT drugs."""
log.info("Initiating query")
results = run_bigclam_g2d_query(request.values.to_dict())
log.info("Query submission finished")
import logging
from flask import request
from flask_restplus import Resource
from app.api.helpers.business import create_product, update_product, delete_product
from app.api.helpers.serializers import products, page_of_products
from app.api.restplus import api
from app.database.models import Products
from app.api.orders.parser import pagination_arguments
import simplejson
log = logging.getLogger(__name__)
ns = api.namespace('products/prod1', description='Operations related to prod1')
@ns.route('/')
class ProductCollection(Resource):
# @api.expect(pagination_arguments)
# @api.marshal_with(page_of_orders)
@api.marshal_list_with(products)
def get(self):
"""
Returns list of orders.
* test with markdown
"""
# product = Products.query.filter_by(product='prod1').all()
return Products.query.all()
# args = pagination_arguments.parse_args(request)
from flask_restplus import Resource
from app.api.restplus import api
from app.api.serializers import message
from flask_pymongo import PyMongo
ns = api.namespace('Message', description='Message operations')
mongo = PyMongo()
@ns.route('/')
class Message_list(Resource):
@ns.doc('list all messages')
def get(self):
"""
Displays all available messages
"""
documents = [doc for doc in mongo.db.messages.find({}, {'_id': False})]
return documents, 200
@ns.doc('create_message')
@ns.expect(message)
@ns.response(201, '')
def post(self):
"""
Create a new message
"""
mongo.db.messages.insert({'Message': api.payload})
return "", 201
@ns.doc('delete_message')
from flask_restplus import Resource, reqparse
import logging
from datetime import datetime
from app.api.restplus import api
from app.define import status
from app.db.database import get_session
from app.decorators.auth import jwt_authenticate
from app.models.auth import AuthUser
from app.encrypt.encrypt import encrypt_jwt, encrypt_sha
from app.response import response as resp
logger = logging.getLogger(__name__)
ns = api.namespace("auth", description="Endpoints for user auth")
parser = reqparse.RequestParser()
parser.add_argument("username", required=True)
parser.add_argument("password", required=True)
@ns.route("/login")
class Login(Resource):
def post(self):
try:
parsed = parser.parse_args()
except:
return resp.error("username, password must be specified")
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from app.api.restplus import api
from app.models import OS
log = logging.getLogger(__name__)
ns = api.namespace('os', description='OS')
os = api.model(
'os', {
'id':
fields.Integer(readOnly=True,
description='The internal id of of an OS.'),
'family':
fields.String(required=True, description='The family of the OS.'),
'version':
fields.String(required=True, description='The version of the OS.')
})
# TODO - Define endpoints that return sessions that started, ended and timedout in a date/time range, used a given ip address
@ns.route('/')
class SessionsList(Resource):
@api.marshal_list_with(os)
def get(self):
"""
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from app.api.restplus import api
from app.models import Tenant
log = logging.getLogger(__name__)
ns = api.namespace('tenants', description='Tenant')
tenant = api.model(
'tenant', {
'id':
fields.Integer(readOnly=True,
description='The internal id of the tenant.'),
'tenant_id':
fields.String(required=True, description='The tenant id.'),
})
@ns.route('/')
class TenantsList(Resource):
@api.marshal_list_with(tenant)
def get(self):
"""
Return a list with all tenants.
:return: list_of_tenants
"""
import logging
from flask import request
from flask_restplus import Resource
from app.api.bigquery.business_interactions import run_bglite_gt2g_query
from app.api.bigquery.serializers import bglite_query_request, query_status_response, query_response, ndex_request, ndex_response
from app.api.bigquery.parsers import bglite_query_url_parser
from app.api.restplus import api
from app.database.models import TestModel
from app import settings
ns = api.namespace('lilgim', description="""Simplified interface to BigGIM""")
log = logging.getLogger(__name__)
@ns.route('/query')
class BGLiteQuery(Resource):
@ns.response(400, "Bad query request.")
@ns.response(200, "OK")
@ns.doc(model=query_response)
@ns.expect(bglite_query_url_parser, validate=False)
def get(self):
"""Find tissue-specific correlated genes"""
log.info("Initiating query")
results = run_bglite_gt2g_query(request.values.to_dict())
log.info("Query submission finished")
if results['status'] == 'error':
log.debug("Error in query %s" % (results))
return results, 400
else:
from flask_restplus import Resource, marshal
from app.api.bigquery.serializers import table_response, column_response, substudy_response, study_response, study_response_test, table_response_short, unique_tissue_list, tissue_substudy
from app.api.bigquery.parsers import query_url_parser
from app.api.bigquery.business_metadata import *
from app.api.restplus import api
from app.database.helpers import populate_database
from app.database.models import *
from app import settings
from app.database import db
import requests
import json
log = logging.getLogger(__name__)
ns = api.namespace('metadata',
description="""Access the metadata for available datasets.
""")
@ns.route('/table')
class MetadataTableResources(Resource):
@ns.marshal_with(table_response_short)
def get(self):
"""Retrieve list of available tables"""
tables = get_table()
return tables, 200
@ns.response(404, "Table not found")
@ns.response(200, "OK")
@ns.doc(params={'table_name': 'the name of a biqquery table'})
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from app.api.restplus import api
from app.models import ApplicationInstance
log = logging.getLogger(__name__)
ns = api.namespace('applications_instances',
description='Applications Instances')
application_instance = api.model(
'applications_instances', {
'id':
fields.Integer(readOnly=True,
description='The internal id of the application.'),
'application_id':
fields.String(
required=True,
description=
'The id of the appication instance represented by the logical id (LID).'
)
})
@ns.route('/')
class ApplicationsInstanceList(Resource):
@api.marshal_list_with(application_instance)
from flask import request
from flask_restplus import Resource
from werkzeug.exceptions import BadRequest, NotFound
from app.api.events import EventResource
from app.api.restplus import api
from app.api.serializers import signup, signup_detail
from app.api.users import UserAccount
from app.extensions import db
from app.models.Signup import Signup
from app.tasks.email import send_async_email
ns = api.namespace('signups', description='Operations related to events')
@ns.route('')
class SignupsCollection(Resource):
@api.marshal_list_with(signup_detail)
def get(self):
"""
Returns all events
Returns all registered events for a specific user
"""
user_email = request.args.get('email')
if user_email:
user = UserAccount.get_user(user_email)
if user:
return self.setInfo(
Signup.query.filter(Signup.user_id == user.id).all()), 200
else:
raise BadRequest("user is not existing.")
from sqlalchemy.orm import load_only
import logging
from datetime import datetime
from app.define import status
from app.api.restplus import api
from app.decorators.auth import jwt_authenticate
from app.models.auth import AuthUser
from app.db.database import get_session
from app.encrypt.encrypt import encrypt_sha
from app.response import response as resp
from app.utils.validate import check_username, check_password, check_email
logger = logging.getLogger(__name__)
ns = api.namespace("users", description="Endpoints for user")
parser_create = reqparse.RequestParser()
parser_create.add_argument("username", type=str, required=True)
parser_create.add_argument("password", type=str, required=True)
parser_create.add_argument("first_name", type=str, required=True)
parser_create.add_argument("last_name", type=str, required=True)
parser_create.add_argument("email", type=str, required=True)
parser_update = reqparse.RequestParser()
parser_update.add_argument("password", type=str, required=True)
parser_update.add_argument("new_password", type=str)
parser_update.add_argument("first_name", type=str)
parser_update.add_argument("last_name", type=str)
parser_update.add_argument("email", type=str)
import os
import logging
import h5py
import numpy as np
from flask import jsonify, current_app as app
from flask_restplus import Resource, reqparse
from app.api.restplus import api
from app.utils import response as resp
ns = api.namespace("timeseries", description="Endpoint for time seies data")
parser = reqparse.RequestParser()
parser.add_argument("model_name", type=str, required=True)
parser.add_argument("start_date", type=int, required=True)
parser.add_argument("end_date", type=int, required=True)
@ns.route("/portfolio-performance/<item>")
class PortfolioPerformance(Resource):
__available_item_list = ["return", "tvr", "cum_return"]
def post(self, item):
try:
parsed = parser.parse_args()
except:
return resp.error("model_name, start_date, end_date must be specified")
print parsed
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from app.api.restplus import api
from app.models import Application
log = logging.getLogger(__name__)
ns = api.namespace('applications', description='Application')
application = api.model(
'application', {
'id':
fields.Integer(readOnly=True,
description='The internal id of the application.'),
'name':
fields.String(
required=True,
description=
'The name of the appication represented by the logical id (LID) prefix.'
)
})
@ns.route('/')
class ApplicationsList(Resource):
@api.marshal_list_with(application)
@api.doc(model=application)
import logging
from flask import Response
from flask_restplus import Resource, fields
from neomodel.core import DoesNotExist
from app.api.restplus import api
from app.models import Environment
log = logging.getLogger(__name__)
ns = api.namespace('environments', description='Environment')
environment = api.model(
'environment', {
'id':
fields.Integer(readOnly=True,
description='The internal id of the application.'),
'server':
fields.String(
required=True,
description='The server where the environment is deployed.'),
'type':
fields.String(
required=True,
description=
'The type of the environment (e.g.: OP, ST, MT, or DEMO).')
})
@ns.route('/')
"""
Contains endpoints for API
"""
import time
import datetime
import requests
from flask import request
from flask_restplus import Resource, fields
from werkzeug.exceptions import BadRequest
from app.api.restplus import api
from app.api.io_logic import get_sites_from_io, update_sites_in_io
ns_sites = api.namespace('sites', description='Operations with sites')
ns_monitoring = api.namespace('monitoring',
description='Monitoring operations')
site = api.model('Site',
{'url': fields.String(required=True, description='URL')})
site_update = api.model(
'Site to update', {
'url': fields.String(required=True, description='URL'),
'new_url': fields.String(required=True, description='URL'),
})
site_status = api.model(
'Site to monitor', {
'url': fields.String(required=True, description='URL'),
'last_status': fields.String(description='Last known status'),
'last_checked': fields.DateTime(description='Last update'),
})
import logging
from flask import request
from flask_restplus import Resource
from app.api.bigquery.business_interactions import get_request_status, run_query, ndex
from app.api.bigquery.serializers import query_request, query_status_response, query_response, ndex_request, ndex_response
from app.api.bigquery.parsers import query_url_parser
from app.api.restplus import api
from app.database.models import TestModel
from app import settings
log = logging.getLogger(__name__)
ns = api.namespace('biggim',
description="""Comprehensive querying of gene to gene interactions under different tissue types.""")
@ns.route('/query')
class InteractionsQuery(Resource):
@ns.response(400, "Bad query request.")
@ns.response(200, "OK")
@ns.doc(model=query_response)
@ns.expect(query_url_parser, validate=False)
def get(self):
"""Submit a new query request."""
log.info("Initiating query")
results = run_query(request.values.to_dict())
log.info("Query submission finished")
if results['status'] == 'error':
log.debug("Error in query %s" % (results))
return results, 400
