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