import logging
from flask import request, abort, jsonify, g
from flask_restplus import Resource
from api.languages.serializers import (language as api_language,
language_creation)
from api.restplus import api
from models import db, Language
from authorization import auth_required
log = logging.getLogger(__name__)
ns = api.namespace('languages', description='Operations related to languages')
@ns.route('/')
@api.header('Authorization', 'Auth token', required=True)
class LanguageCollection(Resource):
@api.marshal_list_with(api_language)
@auth_required('student')
def get(self):
"""
Returns list of languages.
"""
languages = Language.query.order_by(Language.id).all()
return languages
@ns.route('/create')
@api.header('Authorization', 'Auth token', required=True)
class LanguageCreation(Resource):
from flask import request
from flask_restplus import Resource
from api.xen.business import create_host, delete_host, update_host, test_host
from api.xen.serializers import host, host_rw, host_test
from api.restplus import api
from database.models import Host
from database import db
import logging.config
log = logging.getLogger(__name__)
ns = api.namespace('xen/host', description='Operations related to hosts')
@ns.route('/test/')
class HostTest(Resource):
@api.response(200, 'Host connection established.')
@api.response(204, 'Host connection failed.')
@api.expect(host_test)
def post(self):
"""
Tests a connection to a new host.
* Send a JSON object with the properties in the request body.
```
{
"username": "******",
"password": "******",
"address": "Host address",
}
import logging
from flask import request, jsonify
from flask_restx import Resource, fields
from database.models import UserProfile
from api.recommender.serializers import user_profile
from api.restplus import api
from database import db
from api.recommender.business import create_user_profile, update_user_profile, delete_user_profile
log = logging.getLogger(__name__)
ns = api.namespace('user_profiles',
description='User Profile related operations')
@ns.route('/')
class UserList(Resource):
@api.doc('list user profiles')
@api.marshal_list_with(user_profile)
def get(self):
'''
List all user profiles.
Use this method to list all the existing user profiles
'''
user_profiles = UserProfile.query.all()
return user_profiles
@api.response(201, 'User Profile successfully created.')
import logging
from flask import request
from flask_restplus import Resource
from api.blog.business import create_blog_post, update_post, delete_post
from api.blog.serializers import blog_post, page_of_blog_posts
from api.blog.parsers import pagination_arguments
from api.restplus import api
from model.blogs 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)
from system.logger import Logger
from system import variables
from flask import request
from flask_restplus import Resource
from api.restplus import api
from api.response import Response
from api.v1 import serializers
ns = api.namespace(variables.V1_NAMESPACE,
description=f"API Version {variables.V1_VERSION}")
@ns.route("/")
class Index(Resource):
def get(self):
return Response.success({
"description": f"{variables.SERVICE_LABEL} API "
f"{variables.V1_NAMESPACE}",
"status": "online",
"version": variables.V1_VERSION
})
@ns.route("/auth/register/")
class Index(Resource):
@api.expect(serializers.register, validate=True)
def post(self):
body = request.json
# REST services for OGRDB
from flask import request
from flask_restx import Resource, reqparse, fields, marshal, inputs
from api.restplus import api
from db.gene_description_db import make_GeneDescription_view
from werkzeug.exceptions import BadRequest
from imgt.imgt_ref import get_imgt_reference_genes, get_igpdb_ref, get_reference_v_codon_usage, find_family, get_imgt_gapped_reference_genes, find_gapped_index, gap_sequence
from db.vdjbase import get_vdjbase_ref
from head import db
from db.misc_db import Committee
from db.gene_description_db import GeneDescription
from datetime import datetime
ns = api.namespace(
'sequence',
description='Sequences corresponding to IMGT- or IARC- issued names')
@ns.route('/species')
@api.response(404, 'Not found')
class speciesApi(Resource):
def get(self):
""" Returns the species for which sequences are available """
imgt_ref = get_imgt_reference_genes()
return {'species': list(imgt_ref.keys())}
@ns.route('/imgt_name/<string:species>/<string:name>')
@api.response(404, 'Not found')
import requests
from flask import request, json, jsonify
from flask_restplus import Resource
from flask_cors import CORS
from api.restplus import api
from api.test_api.args_data import args_data
# from api.test_api.get_data import test_get_arg
# from api.test_api.parser import test_add_post_arg
from api.test_api.json_data import json_data
ns = api.namespace('user', description='user api')
@ns.route('/get_info', methods=['GET'])
class Testget(Resource):
@api.expect(args_data)
def get(self):
user_name = request.args.get('user_name')
user_phone = request.args.get('user_phone')
return jsonify({'user_name':user_name, 'user_phone':user_phone})
@ns.route('/post_info', methods=['POST'])
class Testpost(Resource):
@api.expect(json_data)
from datetime import datetime
from flask import request
from flask_restplus import Resource
from api.events.logic import add_event, delete_event, update_event, watch_event, fund_event, vote_event, get_info_events
from api.events.serializers import create_event, event, edit_event, watch, fund, vote, money, stars
from api.utils import get_id_form_token
from api.restplus import api
from database.models import Event, Tag, tags
ns = api.namespace('events', description='Operations related to events')
@ns.route('/')
class EventCollection(Resource):
@api.marshal_list_with(event)
def get(self):
"""
Returns list of all the events.
"""
name = request.args.get('name')
stars = request.args.get('stars')
if stars is not None:
stars = float(stars)
fromDate = request.args.get('fromDate')
if fromDate is not None:
fromDate = datetime.strptime(fromDate, "%Y-%m-%dT%H:%M:%S.%f%z")
toDate = request.args.get('toDate')
if toDate is not None:
toDate = datetime.strptime(toDate, "%Y-%m-%dT%H:%M:%S.%f%z")
import logging
from flask import request
from flask_restplus import Resource
from api.restplus import api
from api.model.speech import speech as speech_model
from chatter import chatter
log = logging.getLogger(__name__)
ns = api.namespace('speech', description='get speech response')
@api.route('/speech') # Create a URL route to this resource
class Speech(Resource): # Create a RESTful resource
@api.expect(speech_model)
def post(self):
"""
Creates a new blog category.
"""
data = request.json
text = data.get('text')
response = chatter.chatbot.get_response(text)
return {'output': response.text}
import logging
from flask import request, jsonify
from flask_restx import Resource, fields
from database.models import GBUs
from api.recommender.serializers import gbu, gbu_with_services
from api.restplus import api
from database import db
from api.recommender.business import update_gbu, delete_gbu, create_gbu
log = logging.getLogger(__name__)
ns = api.namespace('gbus', description='GBU related operations')
@ns.route('/')
class GbuList(Resource):
@api.doc('list gbus')
@api.marshal_list_with(gbu)
def get(self):
'''
List all gbus.
Use this method to list all the existing gbus.
'''
gbus = GBUs.query.all()
return gbus
@api.response(201, 'GBU successfully created.')
from api import settings
from flask import request
from flask_restplus import Resource
from api.restplus import api
from werkzeug.wrappers import Response
from typing import Optional
import json
try:
import urllib.parse as urlparse
except ImportError:
import urlparse as urlparse
log = logging.getLogger(__name__)
ns = api.namespace("features",
description="Operations related to OGC API - Features")
@ns.route("/", defaults={"path": ""})
@ns.route("/<path:path>")
class OgcapiFeatures(Resource):
def get(self, path: str):
"""
OGC API Features proxy
Examples:
"""
return respond(
r=req(path, request.query_string, request.headers.get("accept")),
import io
#import json
from flask import request, Response, json
from flask_restplus import Resource, fields
from api.restplus import api
from api.ende.logic.tf_client import make_prediction
from werkzeug.datastructures import FileStorage
from nltk import sent_tokenize
# create dedicated namespace for ENDE client
ns = api.namespace(
'ende_client',
description=
'Operations for Translating the ende model using the sentence piece model')
# Flask-RestPlus specific parser for file uploading
UPLOAD_KEY = 'file'
UPLOAD_LOCATION = 'files'
upload_parser = api.parser()
upload_parser.add_argument(UPLOAD_KEY,
location=UPLOAD_LOCATION,
type=FileStorage,
required=True)
text_parser = api.parser()
text_parser.add_argument('text', required=True, help='enter sentences')
@ns.route('/prediction/file')
class EndePredictionFile(Resource):
@ns.doc(description='input is text file, output json',
import logging
from flask import request, abort, jsonify, g
from flask_restplus import Resource
from api.submissions.serializers import submission as api_submission
from api.submissions.serializers import last_submission, choosing_create
from api.submissions.serializers import submission_to_a_problem, choosing
from api.users.serializers import user
from api.restplus import api
from models import db, Submission, Problem, Taken, User
from sqlalchemy import and_
from authorization import auth_required
log = logging.getLogger(__name__)
ns = api.namespace('submissions',
description='Operations related to submissions')
@ns.route('/')
@api.header('Authorization', 'Auth token', required=True)
class SubmissionCollection(Resource):
@api.marshal_list_with(api_submission)
@auth_required('student')
def get(self):
"""
Returns list of submissions.
"""
submissions = Submission.query.order_by(Submission.id).all()
return submissions
from flask import request
from flask_restplus import Resource
from api.xen.business import create_schedule, delete_schedule, update_schedule
from api.xen.serializers import schedule, schedule_ro, schedule_rw
from api.restplus import api
from database.models import Schedule
from database import db
import logging.config
log = logging.getLogger(__name__)
ns = api.namespace('xen/schedule',
description='Operations related to schedules')
@ns.route('/')
class ScheduleCollection(Resource):
@api.marshal_list_with(schedule_ro)
def get(self):
"""
Returns list of schedules.
"""
schedules = db.session.query(Schedule).all()
return schedules
@api.response(201, 'Schedule successfully created.')
@api.expect(schedule_rw)
def post(self):
"""
import io
import json
from flask import request
from flask_restplus import Resource
from api.restplus import api
from api.gan.logic.tf_serving_client import make_prediction
from werkzeug.datastructures import FileStorage
# create dedicated namespace for GAN client
ns = api.namespace('gan_client', description='Operations for GAN client')
# Flask-RestPlus specific parser for image uploading
UPLOAD_KEY = 'image'
UPLOAD_LOCATION = 'files'
upload_parser = api.parser()
upload_parser.add_argument(UPLOAD_KEY,
location=UPLOAD_LOCATION,
type=FileStorage,
required=True)
@ns.route('/prediction')
class GanPrediction(Resource):
@ns.doc(description='Predict the house number on the image using GAN model. ' +
'Return 3 most probable digits with their probabilities',
responses={
200: "Success",
400: "Bad request",
500: "Internal server error"
from flask_restplus import Resource
from api.problems.serializers import problem as api_problem
from api.problems.serializers import problem_table, problem_description, problem_edition
from api.forums.serializer import (forum as api_forum, forum_creation,
forum_edition)
from api.restplus import api
from sqlalchemy import join, and_
from sqlalchemy.orm import Load
from authorization import auth_required
from models import db, User, Problem, Group, Statistic, Student, Submission, Admin, Professor, Topic, ProblemTopic, Forum, Comment, Message
from api.evaluators.services import update_test_cases_in_filesystem
from api.messages.serializer import message as api_message
log = logging.getLogger(__name__)
ns = api.namespace('message', description='Operation related to messages')
@ns.route('/<int:id>')
@api.header('Authorization', 'Auth token', required=True)
class MessagesCollection(Resource):
@api.marshal_list_with(api_message)
@auth_required('professor')
def get(self, id):
"""
Return list of messages by team id
"""
try:
id = int(id)
except ValueError:
return None, 404
from flask import request, abort, jsonify, g
from flask_restplus import Resource
from api.problems.serializers import problem as api_problem
from api.problems.serializers import problem_table, problem_description, problem_edition
from api.forums.serializer import (forum as api_forum, forum_creation,forum_edition)
from api.comments.serializer import (comment as api_comment, comment_creation,comment_edition)
from api.restplus import api
from sqlalchemy import join, and_
from sqlalchemy.orm import Load
from authorization import auth_required
from models import db, User, Problem, Group, Statistic, Student, Submission, Admin, Professor, Topic, ProblemTopic, Forum, Comment
from api.evaluators.services import update_test_cases_in_filesystem
log = logging.getLogger(__name__)
ns = api.namespace('comment', description='Operations related to comments')
@ns.route('/create/<int:forum_id>')
@api.header('Authorization', 'Auth token', required=True)
class CommentCreation(Resource):
@api.response(201, 'Comment successfully created')
@api.expect(comment_creation)
@auth_required('student')
def post(self, forum_id):
"""
Creates comment
"""
data = request.json
text = data.get('text')
author = data.get('author_id')
visible = data.get('isVisible')
import time
import models.User
from sqlalchemy import exc
from flask import request
from api.restplus import api, token_auth, FLASK_APP
from collections import namedtuple
from repository.UserRepository import UserRepository
from api.gyresources.endpoints.BaseController import BaseController
from api.gyresources.serializers import user as userSerializer
from api.gyresources.parsers import user_search_args
from tools.Cryptography import Crypto
from tools import Logger
ns = api.namespace('gyresources/users',
description='Operations related to users')
@ns.route('/')
class UserController(BaseController):
"""
This class was created with the objective to control functions
from UserRepository, here, you can insert, update and delete
data. Searchs are realized in UserSearch.
"""
@api.expect(user_search_args)
@api.response(200, 'User searched.')
def get(self):
"""
Return a list of users based on action.
If action=searchByID:
import logging
from flask import request, abort, jsonify, g
from flask_restplus import Resource
from api.assignments.serializers import (assignment as api_assignment,
assignment_creation, simple_submission,
assignment_submission_summary,
student_submission, student_assignment)
from api.restplus import api
from models import db, Assignment, Submission, Enrollment, User
from sqlalchemy import and_
from authorization import auth_required
log = logging.getLogger(__name__)
ns = api.namespace('assignments',
description='Operations related to assignments')
@ns.route('/')
@api.header('Authorization', 'Auth token', required=True)
class AssignmentCollection(Resource):
@api.marshal_list_with(api_assignment)
@auth_required('admin')
def get(self):
"""
Returns list of assignments.
"""
assignments = Assignment.query.order_by(Assignment.id).all()
return assignments
import logging
import os
from flask import request, send_file
from flask_restplus import Resource
from api.some_service.business import create_third_entity, update_third_entity, delete_third_entity
from api.some_service.serializers import third_entity
from api.some_service.parsers import file_upload_parser, file_path_parser
from api.restplus import api
from database.models import ThirdEntity
log = logging.getLogger(__name__)
ns = api.namespace('some_service/third_entity',
description='Operations related to third entity')
@ns.route('/')
class ThirdEntityCollection(Resource):
@api.marshal_list_with(third_entity)
def get(self):
"""
Returns list of third entities.
"""
third_entities = ThirdEntity.query.all()
return third_entities
@api.response(201, 'Third entity successfully created.')
@api.expect(third_entity)
def post(self):
"""
from flask_restplus import Resource
from werkzeug.datastructures import FileStorage
from flask import current_app as app
from ..models import timeplan_item
from api.restplus import api
ns = api.namespace(
'timeplan',
description='Operations related to the injection timeplan of the host')
timeplan_parser = api.parser()
timeplan_parser.add_argument('timeplan',
location='files',
type=FileStorage,
required=True)
@ns.route('/')
class HostTimePlan(Resource):
@api.doc(responses={
200: 'Timeplan has been returned.',
400: 'No Timeplan exists.'
})
@api.marshal_with(timeplan_item)
def get(self):
"""
Returns the currently injected timeplan as JSON Object.
"""
AnomalyEngine = app.config['AnomalyEngine']
timeplan = AnomalyEngine.timeplan
from flask_restplus import Resource
from api.restplus import api
from flask import current_app as app
ns = api.namespace(
'mode', description='Operations related to the injection mode of the host')
@ns.route('/')
@api.doc(responses={200: 'Success'})
class InectionModus(Resource):
def get(self):
"""
Returns current injection mode of the host.
"""
AnomalyEngine = app.config['AnomalyEngine']
res = {"Injection mode": AnomalyEngine.current_mode}
return res, 200
@ns.route('/<string:mode>/')
@api.doc(
responses={
200: 'Injector Agent is already running in given mode',
201: 'Mode has been changed',
400: 'Error',
409: 'Anomalies are running'
})
class ChangeModus(Resource):
def post(self, mode):
import logging
from flask import request
from flask_restplus import Resource
from api.model.serializers import model
from api.directory.operations import create_model
from api.restplus import api
from database.models import User
log = logging.getLogger(__name__)
ns = api.namespace('models', description='Reclass template related operations')
@ns.route('/')
class ModelCollection(Resource):
# @api.marshal_list_with(model)
def get(self):
"""
Returns list of all created models.
"""
pass
@api.response(200, 'Model successfully created.')
@api.expect(model)
def post(self):
"""
Creates a model.
"""
data = request.json
import logging
import json
import os
import sys, traceback
import requests
from flask import Response, request, render_template_string
from flask_restplus import Resource
from api.restplus import api
from api.utils.mapproxy_snap import create_config_wmts, mapit
from api.endpoints.wmts import GetCapabilities
from api import settings
log = logging.getLogger(__name__)
ns = api.namespace('wms', description='WMS GetMap')
@ns.route('/GetMap')
class GetMap(Resource):
def get(self):
"""
This will return OGC WMS GetMap response (image file)
:return:
"""
try:
# Pass param which can be used to generate GetCapabilities dynamically
cmr_search_params = {'granule_ur': request.args['LAYERS']}
# Review(Aimee): This generates a local copy of WMTS GetCapabilities
# XML, which `create_config_wmts` requires. `create_config_wmts`
# could also call the /wmts/GetCapabilities endpoint but it would
import logging
from flask import request
from flask_restplus import Resource
from api.business.registration import create_registration, delete_registration
from api.serializers import registration
from api.restplus import api
from database.models import Registration
log = logging.getLogger(__name__)
ns = api.namespace('registrations',
description='Operations related to event registrations')
@ns.route('/')
class RegistrationCollection(Resource):
@api.marshal_list_with(registration)
def get(self):
"""
Returns list of blog registrations.
"""
registrations = Registration.query.all()
return registrations
@api.response(201, 'Registration successfully created.')
@api.expect(registration)
def post(self):
"""
Creates a new blog registration.
"""
from flask import request, abort, jsonify, g
from flask_restplus import Resource
from api.problems.serializers import problem as api_problem
from api.problems.serializers import problem_table, problem_description, problem_edition, main_problem
from api.restplus import api
from models import db, Problem, Topic, ProblemTopic, \
Case, Language, User, Taken, Statistic, Team, Teamenroll, Submission
from sqlalchemy import join, and_
from sqlalchemy.orm import Load
from authorization import auth_required
from api.evaluators.services import update_test_cases_in_filesystem
log = logging.getLogger(__name__)
ns = api.namespace('problems', description='Operations related to problems')
@ns.route('/')
@api.header('Authorization', 'Auth token', required=True)
class ProblemCollection(Resource):
@api.marshal_list_with(api_problem)
@auth_required('professor')
def get(self):
"""
Returns list of problems.
"""
problems = db.session.query(Problem).filter(
Problem.is_subproblem == False).order_by(Problem.id).all()
# Get user
import logging
from flask import request, jsonify
from flask_restx import Resource, fields
from database.models import DomainProfile
from api.recommender.serializers import domain_profile
from api.restplus import api
from database import db
from api.recommender.business import create_domain_profile, update_domain_profile, delete_domain_profile
log = logging.getLogger(__name__)
ns = api.namespace('domain_profiles',
description='Domain Profile related operations')
@ns.route('/')
class DomainList(Resource):
@api.doc('list_domain_profiles')
@api.marshal_list_with(domain_profile)
def get(self):
'''
List all domain profiles.
Use this method to list all the existing domain profiles
'''
domain_profiles = DomainProfile.query.all()
return domain_profiles
@api.response(201, 'Domain Profile successfully created.')
import logging
from flask import request
from flask_restx import Resource
from api.controller.categories_controller import *
from api.restplus import api
from api.utilities.serializers import category_input, category_output, location, message, bad_request
log = logging.getLogger(__name__)
categories_namespace = api.namespace(
'categories', description='Operations related to project categories')
@categories_namespace.route('/')
class CategoryCollection(Resource):
@api.marshal_list_with(category_output)
@api.response(200, 'Categories successfully queried.', message)
def get(self):
"""
Returns list of categories.
"""
categories = get_categories()
return categories
@api.response(201, 'Category successfully created.', location)
@api.response(409, 'Category already exists', message)
@api.response(400, 'Bad request', bad_request)
@api.expect(category_input)
from flask import request, abort, jsonify, g
from flask_restplus import Resource
from flask_security import auth_token_required, utils
from flask_httpauth import HTTPBasicAuth
from api.teams.serializer import (team as api_team, team_creation,
team_with_students, team_edition)
from api.restplus import api
from models import db, User, Team, Student, Group, Teamenroll
from authorization import auth_required
log = logging.getLogger(__name__)
auth = HTTPBasicAuth()
ns = api.namespace('teams', description='Operations related to team')
@ns.route('/')
@api.header('Authorization', 'Auth token', required=True)
class TeamCollection(Resource):
@api.marshal_list_with(api_team)
@auth_required('professor')
def get(self):
"""
Returns list of teams.
"""
# Retrieve just groups of professor
token = request.headers.get('Authorization', None)
user = User.verify_auth_token(token)
import logging
from flask import request, jsonify
from flask_restx import Resource, fields
from database.models import Vulnerabilities
from api.recommender.serializers import vulnerabilities
from api.restplus import api
from database import db
from api.recommender.business import create_user_profile, update_user_profile, delete_user_profile
log = logging.getLogger(__name__)
ns = api.namespace('vulnerabilities',
description='Vulnerability database related operations')
"""
@ns.route('/')
class Vul_RecordList(Resource):
@api.doc('list vul record profiles')
@api.marshal_list_with(vul_record)
def get(self):
'''
List all vulnerability record.
Use this method to list all the existing vulnerability records
'''
vul_records = VulRecord.query.all()
return vul_records
from flask import request
from flask_restx import Resource
from api.controller.jobs_controller import *
from api.restplus import api
from api.utilities.parsers import pagination_arguments
from api.utilities.serializers import job_input, job_output, message, bad_request, page_of_jobs, location
jobs_namespace = api.namespace('jobs',
description='Operations related to jobs')
@jobs_namespace.route('/')
class JobCollection(Resource):
@api.expect(pagination_arguments)
@api.marshal_with(page_of_jobs)
@api.response(200, 'Jobs successfully queried.')
def get(self):
"""
Returns list of jobs
"""
args = pagination_arguments.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
category_id = args.get('category_id', None)
user_email = args.get('user_email', None)
freelacer_flag = args.get('freelancer_flag', False)
jobs_page = get_jobs(page, per_page, category_id, user_email,
freelacer_flag)
import logging
from flask import request
from flask_restplus import Resource
from api.restplus import api
from api.status.serializers import text_message
log = logging.getLogger(__name__)
ns = api.namespace('status', description='status Operations')
@ns.route('/echo')
class Echo(Resource):
@api.response(200, 'ok')
@api.expect(text_message)
def post(self):
"""
Echoes a message
* Send a JSON object with the message
```
{
"text": "hello"
}
```
"""
return request.json
