import pytz
from flask import request, abort
from flask_restplus import Namespace, Resource, reqparse
from .core.database import Database
from .core.marshmallow_models import NodeSchema, NewNodeSchema, EditNodeSchema, DatumSchema, NodeTypeSchema, EditNodeTypeSchema, NewNodeTypeSchema
from .core.swagger_models import node, data, datum, node_type, sensor, link, date_array, new_node, new_datum
from .core.utils import token_required
from dateutil import parser as date_parser
from datetime import datetime
from marshmallow import Schema
from functools import reduce
api = Namespace('nodes', description='Node related operations')
# Swagger schemas
node = api.schema_model('Node', node)
new_node = api.schema_model('InputNode', new_node)
data = api.schema_model('Data', data)
datum = api.schema_model('Datum', datum)
new_datum = api.schema_model('InputDatum', new_datum)
node_type = api.schema_model('Node-Type', node_type)
sensor = api.schema_model('Sensor', sensor)
link = api.schema_model('Link', link)
date_array = api.schema_model('DateArray', date_array)
@api.route('/types/add')
class AddNodeType(Resource):
@api.doc(summary='Add new node types',
description='Add new node types',
responses={201: 'Node type added successfully'},
def get_public_account(msg: bytes):
return get_account_id(public_key=hashlib.sha256(msg).hexdigest())
# Namespaces
ns_stamp = Namespace(
'timestamp',
description=
'Timestamp on the nano network! Input is utf-8 encoded and sha256 hashed, then sent to that nano address'
)
string_stamp_model = ns_stamp.schema_model(
'string_timestamp', {
"$schema": "http://json-schema.org/schema#",
"type": "object",
"properties": {
"target_string": {
"type": "string"
}
},
"required": ["target_string"],
"additionalProperties": False
})
@ns_stamp.route('/string/')
class TimeStampJson(Resource):
@ns_stamp.doc('timestamp')
@ns_stamp.expect(string_stamp_model)
def post(self):
target_string = request.get_json()['target_string']
try:
target_account = get_public_account(target_string.encode('utf-8'))
https://marshmallow.readthedocs.io/en/latest/
"""
import jwt
import os
import bcrypt
from flask import request, abort
from flask_restplus import Namespace, Resource, reqparse
from .core.swagger_models import user
from .core.marshmallow_models import UserSchema
from .core.database import Database
from .core.utils import token_required
from datetime import datetime, timedelta
api = Namespace('login', description='login operations')
user = api.schema_model('User', user)
# Receives a valid user and password and then provide a token to access the
# protected routes across the application.
@api.route('/')
class Login(Resource):
@api.doc(summary='Login to the API', responses={200: 'Login successful'})
@api.expect(user)
def post(self):
user, errors = UserSchema().load(request.get_json(force=True) or {})
if not errors:
u = Database().get_user(user['username'])
if u and bcrypt.checkpw(user['password'].encode('utf-8'),
u['password']):
# The token expires in one day
from flask import Blueprint, jsonify
from flask_restplus import Resource, Namespace, reqparse
from app.meep_api.models.waveguide import Waveguide
from app.meep_api.models.json.waveguide import waveguide_json_model
from app.meep_api.models.folder_manager import FolderManager
waveguides = Blueprint('waveguides', __name__)
waveguide_api = Namespace('waveguides',
description='Simple waveguides endpoints')
waveguide_model = waveguide_api.schema_model('Waveguide Model',
waveguide_json_model)
@waveguide_api.route('/straight-waveguide')
class StraightWaveguide(Resource):
@waveguide_api.doc(
'Returns test text and computes of e/m wave propagation in straight waveguide'
)
@waveguide_api.expect(waveguide_model)
@waveguide_api.param('waveguide_type',
'Describing waveguide type selected at the beginning')
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('data', type=dict)
parser.add_argument('waveguide_type', type=str)
args = parser.parse_args()
waveguide_type = 'straight' #args['waveguide_type']
del args['waveguide_type']
def test_schema_model(self):
api = Namespace('test')
api.schema_model('Person', {})
self.assertIn('Person', api.models)
from flask_restplus import Resource, Namespace, reqparse
from flask import jsonify
from app.meep_api.models.json.cell import cell_json_model
cell_api = Namespace("cell", description="Cell actions")
cell_model = cell_api.schema_model('Cell Model', cell_json_model)
@cell_api.route('/set', methods=["post"])
class Set(Resource):
@cell_api.doc('Sets cell')
@cell_api.expect(cell_model)
@cell_api.param('waveguide_type',
'Describing waveguide type selected at the beginning')
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('x', type=int)
parser.add_argument('y', type=int)
parser.add_argument('z', type=int)
parser.add_argument('waveguide_type', type=str)
args = parser.parse_args()
waveguide_type = args['waveguide_type']
del args['waveguide_type']
return jsonify(cell=args, waveguide_type=waveguide_type)
from flask_restplus import Resource, Namespace, reqparse
from flask import jsonify
from app.meep_api.models.waveguide import Waveguide
from app.meep_api.models.json.geometry import geometry_json_model
from app.meep_api.models.preview import Preview as GeometryPreview
geometry_api = Namespace("geometry", description="Geometry actions")
geometry_model = geometry_api.schema_model('Geometry Model',
geometry_json_model)
@geometry_api.route('/set')
class Set(Resource):
@geometry_api.doc('Sets geometry for straight waveguide')
@geometry_api.expect(geometry_model)
@geometry_api.param('waveguide_type',
'Describing waveguide type selected at the beginning')
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('coordinates', type=dict)
parser.add_argument('center', type=dict)
parser.add_argument('material', type=int)
parser.add_argument('waveguide_type', type=str)
args = parser.parse_args()
waveguide_type = args['waveguide_type']
del args['waveguide_type']
return jsonify(geometry=args, waveguide_type=waveguide_type)
from core.models import puntos as TablaPuntajes
from core.models import Usuarios as TablaUsuarios
from datetime import datetime
from core.database import db
api = Namespace('puntajes', description='Operaciones sobre los puntajes')
puntaje = usuario = api.schema_model(
'Puntaje', {
'type': 'object',
'properties': {
'usuario': {
'$ref': '#/definitions/usuario'
},
'Puntaje': {
'type': 'number',
'description': 'La puntuación de un usuario',
'example': 9999999
},
},
'Fecha': {
'type': 'string',
'description': 'Fecha en el que se registró el puntaje'
}
})
@api.route('/')
class Puntajes(Resource):
@api.doc(summary='Obtener todos los puntajes',
responses={200: ('Lista de puntajes', [puntaje])})
def get(self):
# Environmental variables
# Init app
app = Flask(__name__)
CORS(app)
api = Api(app,
version='1.0',
title='Bionet Index',
description='Bionet Index 1 try')
ns_blast = Namespace('blast', description='Blast on the Bionet')
blast_model = ns_blast.schema_model(
'blast_seq', {
"type": "object",
"properties": {
"search_sequence": {
"type": "string"
}
},
"required": ["search_sequence"],
"additionalProperties": False
})
@ns_blast.route('/')
class BlastRoute(Resource):
@ns_blast.doc('blast')
@ns_blast.expect(blast_model)
def post(self):
f = open("files/test_query.fa", "w")
f.write("> Query Sequence")
f.write("\n")
########################
# The different models #
########################
GENES_NS = Namespace('genes', 'Comorbidities related genes')
simple_gene_model = GENES_NS.model(
'SimpleGene', {
'symbol': fields.String(required=True, description='The gene symbol'),
})
simple_gene_model_schema = GENES_NS.schema_model(
'SimpleGene', {
'properties': {
'symbol': {
'type': 'string',
'description': 'The gene symbol'
}
},
'type': 'object',
'required': ['symbol']
})
gene_model = GENES_NS.model(
'Gene', {
'symbol': fields.String(required=True, description='The gene symbol'),
'ensembl_id': fields.String(description='The EnsEMBL gene id'),
'uniprot_acc':
fields.String(description='The UniProt Accession Number')
})
gene_model_schema = GENES_NS.schema_model(
logger = logging.getLogger(__name__)
api = Namespace('projects', decorators=[jwt_decoder])
default_response = api.model('DefaultAgaveResponse', {
"message": fields.String(),
"version": fields.String(),
"status": fields.String(default="success")
})
ok_response = api.model('OkResponse', {
"message": fields.String(default="accepted")
})
feature_schema = api.schema_model('Feature', FeatureSchema)
asset = api.model('Asset', {
"id": fields.Integer(),
"path": fields.String(),
"uuid": fields.String(),
"asset_type": fields.String(),
"original_path": fields.String(),
"original_name": fields.String(),
"display_path": fields.String()
})
api_feature = api.model('Feature', {
"id": fields.Integer(),
"project_id": fields.Integer(),
"type": fields.String(required=True, default="Feature"),
from flask import request, abort
from flask_restplus import Namespace, Resource, fields, reqparse
from database.database import Database
from database.swagger_models import client
from database.marshmallow_models import NewClientSchema, ClientSchema, ObjectIdField, Address
from marshmallow import Schema
import requests
api = Namespace('Client',
description="Api endpoints for client related operations")
#importing swagger schemas
client = api.schema_model('Client', client)
#get all clients
@api.route('/')
class clientList(Resource):
@api.doc(description='Get all clients',
responses={200: ('client collection', [client])})
def get(self):
return [{
**cl, '_id': str(cl['_id'])
} for cl in Database().Get_Clients()]
#get a client by its id
@api.route('/<string:client_id>')
@api.param('client_id', 'Client identifier')
class clientById(Resource):
from flask import request, abort
from flask_restplus import Namespace, Resource, fields, reqparse
from database.database import Database
from database.swagger_models import food
from database.marshmallow_models import NewFoodSchema, FoodSchema, ObjectIdField, Ingredients
from marshmallow import Schema
import requests
api = Namespace('food',description='Operations related to the food components')
#swagger schemas
food = api.schema_model('Food', food)
#get all foods
@api.route('/')
class foodList(Resource):
@api.doc(description='Get all food', responses={200: ('food collection', [food])})
def get(self):
return [{**fl, '_id': str(fl['_id'])}
for fl in Database().Get_Foods()]
#get food by id
@api.route('/<string:food_id>')
@api.param('food_id','food identifier')
class FoodById(Resource):
@api.doc(description='Returns a food item',
responses={200: ('Returned food item', food),
404: 'Food item not found'})
def get(self, food_id):
palabra = api.schema_model(
'Palabra', {
'type': 'object',
'properties': {
'Palabra': {
'type': 'string',
'description': 'Una palabra',
'example': 'megidolaon'
},
'Categoria': {
'type': 'integer',
'description':
'La categoria de una palabra, 1 ataque, 0 curacion',
'example': 1
},
'Exitos': {
'type': 'integer',
'description':
'Número de veces que se ha escrito la palabra correctamente',
'example': 12
},
'Ocurrencias': {
'type': 'integer',
'description':
'Número de veces que se ha escrito la palabra en total',
'example': 120
}
}
})
from flask import request
from flask_restplus import Namespace, Resource
from core.models import Usuarios as TablaUsuarios
from core.database import db
api = Namespace('usuarios', description='Operaciones sobre los usuarios')
usuario = api.schema_model(
'Usuario', {
'type': 'object',
'properties': {
'IDusuarios': {
'type': 'integer',
'description': 'El ID del usuario',
'ejemplo': 1
},
'NombreUsuarios': {
'type': 'string',
'description': 'El nombre del usuario',
'ejemplo': 'Arashi'
}
}
})
# Puesto a modo de ejemplo, no es buena idea dejar al alcance de todos el acceso a la lista de todos los usuarios y menos con las contraseñas
@api.route('/')
class Usuario(Resource):
@api.doc(summary='Obtener todos los usuarios',
responses={200: ('Lista de usuarios', [usuario])})
def get(self):
def test_schema_model(self):
api = Namespace('test')
api.schema_model('Person', {})
assert 'Person' in api.models
import pytz
import requests # Python 3 requests module: http://docs.python-requests.org/en/master/
from flask import request, abort
from flask_restplus import Namespace, Resource, reqparse
from .core.database import Database
from .core.swagger_models import water_body, node, string_array
from .core.marshmallow_models import NewWaterBodySchema
from .core.utils import token_required
from dateutil import parser as date_parser, tz # python-dateutil module: https://dateutil.readthedocs.io/en/stable/
from functools import reduce
from datetime import datetime
api = Namespace('water-bodies', description='Water bodies related operations')
# API schemas
water_body = api.schema_model('WaterBody', water_body)
node = api.schema_model('Node', node)
string_array = api.schema_model('StringArray', string_array)
@api.route('/add')
class AddWaterBody(Resource):
@api.doc(summary='Add water bodies to the water bodies collection',
security="apikey")
@api.expect([water_body])
@token_required
def post(self):
new_water_bodies, errors = NewWaterBodySchema(many=True).load(
request.get_json() or {})
if errors:
new_water_bodies = [
def test_schema_model(self):
api = Namespace('test')
api.schema_model('Person', {})
assert 'Person' in api.models
@self.ns.doc('{}_validator'.format(self.name))
def get(self):
if validate_json == True:
return make_response(jsonify(cls.validator), 200)
return make_response(
jsonify({'message': 'No validator for object'}), 404)
#========#
# Routes #
#========#
###
###
###
ns_protocol = Namespace('protocols', description='Protocols')
protocol_model = ns_protocol.schema_model('protocol', Protocol.validator)
CRUD(ns_protocol, Protocol, protocol_model, 'protocol', validate_json=True)
###
ns_protocolschema = Namespace('protocolschema', description='ProtocolSchema')
protocolschema_model = ns_protocolschema.schema_model('protocolschema',
ProtocolSchema.validator)
CRUD(ns_protocolschema,
ProtocolSchema,
protocolschema_model,
'protocolschema',
validate_json=True)
