from flask_restplus import Namespace, Resource, fields from datalaunch_server.backend import WorkspaceBackend, RunBackend from .helpers import serialize_datetime api = Namespace("run", description="run management and status") environment_model = api.model("environment variable specification", {}) conda_spec_model = api.model("conda specification", {}) docker_spec_model = api.model("docker specification", {}) run_model = api.model( "run specification", { "name": fields.String(required=True), "environment": fields.Nested(environment_model), "conda_spec": fields.Nested(conda_spec_model), "docker_spec": fields.Nested(docker_spec_model), }, ) run_backend = RunBackend(WorkspaceBackend()) @api.route("/", strict_slashes=False) class RunList(Resource): def get(self): """ Get a list of all run IDs """ return run_backend.get_run_ids() @api.expect(run_model, validate=True) def post(self):
"""Problem feedback related endpoints.""" from flask import jsonify from flask_restplus import Namespace, Resource import api from api import (block_before_competition, check_csrf, PicoException, require_login) from .schemas import feedback_list_req, feedback_submission_req ns = Namespace('feedback', description='List and submit problem feedback') @ns.route('') class FeedbackList(Resource): """Get the list of problem feedback, or submit new feedback.""" @block_before_competition @require_login @ns.response(200, 'Success') @ns.response(400, 'Error parsing request') @ns.response(401, 'Not logged in') @ns.response(403, 'Not authorized') @ns.response(422, 'Competition has not started') @ns.expect(feedback_list_req) def get(self): """ Get the list of your submitted problem feedback. If called as an admin, returns all submitted feedback, with optional filtering using the ?pid, ?uid, and ?tid querystring arguments. """
from flask_restplus import Namespace, Resource, reqparse from werkzeug.datastructures import FileStorage from imantics import Image as ImanticsImage from flask_login import login_required from ..config import Config from PIL import Image if len(Config.MASK_RCNN_FILE) != 0: from ..util.mask_rcnn import model as maskrcnn api = Namespace('model', description='Model related operations') image_upload = reqparse.RequestParser() image_upload.add_argument('image', location='files', type=FileStorage, required=True, help='Image') @api.route('/maskrcnn') class MaskRCNN(Resource): @login_required @api.expect(image_upload) def post(self): """ COCO data test """ if len(Config.MASK_RCNN_FILE) == 0: return {"coco": {}} args = image_upload.parse_args() im = Image.open(args.get('image'))
from flask_restplus import Namespace api = Namespace('app', description='应用后端接口')
from flask_restplus import Resource, Namespace, fields from flask import request from repositories.unitOfWork import UnitOfWork import json from flask import jsonify from flask import Response from tasks.resultTask import ResultTask from tasks.handlers.getAllPersonsHandler import GetAllPersonsHandler from tasks.handlers.addPersonHandler import AddPersonHandler from tasks.addPersonCommand import AddPersonCommand from app.appResponse import AppResponse from services.configurationService import ConfigurationService personController = Namespace('person', description='person') addPersonRequest = personController.model( 'addPersonRequest', { 'id': fields.String(required=True, description='The task unique identifier'), 'name': fields.String(required=True, description='Name') }) @personController.route('/') class PessoaController(Resource): def get(self): resultTask = GetAllPersonsHandler().execute() return AppResponse().Send(resultTask) @personController.expect(addPersonRequest)
from flask_restplus import Resource, Api, reqparse, fields, Namespace from bson import ObjectId from app import celerytask from app.utils import get_logger, auth from . import base_query_fields, ARLResource, get_arl_parser, conn from app import utils from app.modules import TaskStatus ns = Namespace('task') logger = get_logger() base_search_task_fields = { 'name': fields.String(required=False, description="任务名"), 'target': fields.String(description="任务目标"), 'status': fields.String(description="任务状态"), '_id': fields.String(description="任务ID"), 'options.domain_brute': fields.Boolean(description="是否开启域名爆破"), 'options.domain_brute_type': fields.String(description="域名爆破类型"), 'options.port_scan_type': fields.Boolean(description="端口扫描类型"), 'options.port_scan': fields.Boolean(description="是否的端口扫描"), 'options.service_detection': fields.Boolean(description="是否开启服务识别"), 'options.service_brute': fields.Boolean(description="是否开启服务弱口令爆破"), 'options.os_detection': fields.Boolean(description="是否开启操作系统识别"), 'options.site_identify': fields.Boolean(description="是否开启站点识别"), 'options.file_leak': fields.Boolean(description="是否开启文件泄露扫描"), 'options.alt_dns': fields.Boolean(description="是否开启DNS字典智能生成"), 'options.github_search_domain': fields.Boolean(description="是否开启GitHub搜索"), 'options.fetch_api_path': fields.Boolean(description="是否开启JS PATH收集"), 'options.fofa_search': fields.Boolean(description="是否开启Fofa IP 查询"), 'options.sub_takeover': fields.Boolean(description="是否开启子域名劫持扫描"),
from flask_restplus import Namespace, Resource, fields api = Namespace('S3', description='Api\'s to interact with AWS S3') import boto3 import json import logging s3 = boto3.client('s3') @api.route('/buckets') class Buckets(Resource): def get(self): """ Get all the buckets """ buckets = s3.list_buckets() bucketlist = [] for i in buckets['Buckets']: bucket = i['Name'] bucketlist.append(bucket) print(bucketlist) return {"buckets": bucketlist} @api.route('/objects') class Objects(Resource): def get(self): """ Get all the objects in all buckets """
from flask_restplus import Namespace, Resource from mec_data import service from flask import Response api = Namespace( "Data Source", description="Gather data from sources", ) @api.route("/scholar_census/<year>/") class DownloadScholar(Resource): def post(self, year): """Make request to download data from source""" res, status = service.data_source.download("SCHOLAR_CENSUS", year) return Response(str(res), status=status) @api.route("/university_census/<year>/") class DownloadUniversity(Resource): def post(self, year): """Make request to download data from source""" res, status = service.data_source.download("UNIVERSITY_CENSUS", year) return Response(str(res), status=status)
from db_operations import new_game, get_game, get_guesses, make_guess, is_valid, get_all_games from flask_restplus import Namespace, Resource, fields api = Namespace('games') game = api.model( 'Game', { 'game_id': fields.Integer(), 'guesses': fields.List(fields.String), 'correct_guesses': fields.List(fields.String), 'max_guesses': fields.Integer(), 'message': fields.String(), 'game_over': fields.Boolean(), }) @api.response(400, 'Validation Error') @api.route('/start') class Start(Resource): @api.response(200, 'Success') def get(self): """ Landing for a new game. :return: """ return "Welcome to Hangman", 200 @api.response(201, 'Created New Game.') @api.marshal_with(game, code=201) def post(self): """
from flask_restplus import Namespace api = Namespace( "meals", description="Meal definitions, containing one or more recipes and servings" )
from flask_restplus import Namespace, Resource, fields, reqparse from repository.translation import Translation from fireo.utils.utils import generateKeyFromId api = Namespace('translation', description='Quranic Ayahs translation') translationModel = api.model( 'Translation', { 'id': fields.String(), 'ayah_id': fields.String(), 'edition_id': fields.String(), 'ayah_number': fields.Integer(), 'text': fields.String(), }) translationModelList = api.model( 'TranslationList', { 'items': fields.List(fields.Nested(translationModel)), 'result_count': fields.Integer(), 'cursor': fields.String(), }) @api.param( 'id', 'Translation id is combination of editionId_surahId-ayahId (e.g en.sahih_1-0)' ) @api.route('/<string:id>') class GetTranslationById(Resource): @api.marshal_with(translationModel) @api.response(404, 'No translation related to this id please check you ID')
from flask import Flask, Blueprint, request, jsonify from flask_httpauth import HTTPBasicAuth from flask_restplus import Api, Resource, fields, Namespace from .api_decorators import token_required from ..models.player import Player from .validation.player_validation import validate_player from ..models.user import User api = Namespace('users', description='User related operations') @api.route('/all') class get_users(Resource): def get(self): users = User.query.all() if users is None: return bad_request('Unable to retrieve users', 500) users_dict = [] for player in users: users_dict.append(user.as_dict()) return good_request(users_dict, 200) @api.route('/<int:id>') class get_user(Resource): def get(self): user = User.fetch(id=id) if user is None: return bad_request('Unable to retrieve user', 400) return good_request(user.as_dict(), 200)
# -*- coding: utf-8 -*- from flask import request, g from flask_restplus import Namespace, Resource, abort from ..serializers.offers import offer_post_model, offer_put_model, offer_model from .. import auth from app.models import Book, BookOffer ns = Namespace('offers', description='Offers related operations.') # ================================================================================================ # ENDPOINTS # ================================================================================================ # # API Offers endpoints # # ================================================================================================ @ns.route('/') class OffersResource(Resource): decorators = [auth.login_required] @ns.expect(offer_post_model) @ns.marshal_with(offer_model) def post(self): """ Add offer """ data = request.json
from flask import Blueprint, request, current_app from Response import Response from mongoengine.queryset.visitor import Q from Models.Dataset import Dataset from Services.DatasetService import DatasetService from Services.AuthenticationService import AuthenticationService import botocore import pandas as pd from uuid import uuid4 from flask_restplus import Api, Resource, Namespace import json DatasetService = DatasetService() AuthenticationService = AuthenticationService() dataset_ns = Namespace('dataset', 'Get, manipulate, filter, and edit Datasets') s3 = current_app.awsSession.client('s3') DatasetCache = {} @dataset_ns.route("/list/<pageNumber>") class Get(Resource): @dataset_ns.doc( responses={400: "No datasets matching the query were found"}, params={ 'SID': { 'in': 'cookies', 'required': True }, }) def get(self, pageNumber):
import datetime from flask import g, request from flask_restplus import Namespace, Resource from app.ext import db from app.models import SensorAlarm, Home, Community, HomeUser, UserRole, Role, Sensor, AlarmHandle from app.utils.auth.auth import role_require from app.utils.tools.page_range import page_range, page_format from app.views.api_v1.sensoralarms.parser import sensoralarms_parser, sensoralarms_parser1 api = Namespace('Sensoralarms', description='传感器报警相关操作') from .models import * @api.route('/') class SensorAlarmsView(Resource): @api.header('jwt', 'JSON Web Token') @role_require( ['homeuser', 'propertyuser', 'stationuser', 'admin', 'superadmin']) @api.doc('查询传感器报警记录列表') @api.response(200, 'ok') @api.doc( params={ 'page': '页数', 'limit': '数量', 'start': '开始时间见', 'end': '结束时间', 'type': '传感器类型' }) def get(self):
import logging from flask import request, jsonify from flask_restplus import Namespace, Resource from app.api.dto import UserDto from app.api import api from app.api.services import use_list_get, create_user, delete_user ns = Namespace("user", description="User Restful API") log = logging.getLogger(__name__) @ns.route("/") class UserApi(Resource): @api.marshal_list_with(UserDto.post_model) def get(self): """ Returns list of user :return: """ return use_list_get() @api.response(201, "User Successfully Created.") @api.expect(UserDto.post_model) def post(self): """ Create User :return:
from flask_login import login_required, current_user from flask_restplus import Namespace, Resource, reqparse from werkzeug.security import generate_password_hash from ..models import UserModel from ..util.query_util import fix_ids api = Namespace('admin', description='Admin related operations') users = reqparse.RequestParser() users.add_argument('limit', type=int, default=50) users.add_argument('page', type=int, default=1) create_user = reqparse.RequestParser() create_user.add_argument('name', default="", location='json') create_user.add_argument('password', default="", location='json') register = reqparse.RequestParser() register.add_argument('username', required=True, location='json') register.add_argument('password', required=True, location='json') register.add_argument('email', location='json') register.add_argument('name', location='json') register.add_argument('isAdmin', type=bool, default=False, location='json') @api.route('/users') class Users(Resource): @api.expect(users) @login_required def get(self): """ Get list of all users """
from flask_restplus import Namespace, Resource from flask import Response, abort from gsrest.apis.common import page_parser, block_response, \ block_list_response, block_txs_response import gsrest.service.blocks_service as blocksDAO from gsrest.util.checks import check_inputs from gsrest.util.csvify import create_download_header, to_csv from gsrest.util.decorator import token_required api = Namespace('blocks', path='/<currency>/blocks', description='Operations related to blocks') @api.route("/<int:height>") @api.param('currency', 'The cryptocurrency (e.g., btc)') @api.param('height', 'The block height') class Block(Resource): @token_required @api.marshal_with(block_response) def get(self, currency, height): """ Returns details of a specific block identified by its height """ check_inputs(currency=currency, height=height) block = blocksDAO.get_block(currency, height) if block: return block abort(404, "Block {} not found in currency {}".format(height, currency))
import datetime from flask_restplus import Namespace, Resource from flask_login import login_required, current_user from flask import request from ..util import query_util, coco_util, profile from config import Config from database import (ImageModel, CategoryModel, AnnotationModel, SessionEvent) api = Namespace('annotator', description='Annotator related operations') @api.route('/data') class AnnotatorData(Resource): @profile @login_required def post(self): """ Called when saving data from the annotator client """ data = request.get_json(force=True) image = data.get('image') dataset = data.get('dataset') image_id = image.get('id') image_model = ImageModel.objects(id=image_id).first() if image_model is None: return {'success': False, 'message': 'Image does not exist'}, 400
from flask_restplus import Namespace, Resource, fields from apis.auth.services import create_tokens from apis.auth.services import refresh_access_token from flask_jwt_extended import jwt_refresh_token_required auth_endpoints = Namespace('authorization', description='Endpoint operations related to Authorization Tokens.') create_tokens_request = auth_endpoints.model('Create Tokens Request', { 'username': fields.String(required=True, description='Username to be identified in authentication process'), 'password': fields.String(required=True, description='Password related to the username') }) create_tokens_response = auth_endpoints.model('Create Tokens Response', { 'access_token': fields.String(required=True, description='Access token to be used for all requests'), 'refresh_token': fields.String(required=True, description='Refresh token to be used to get a new access token'), 'expires': fields.Integer(required=True, description='Token time in seconds') }) refresh_access_token_response = auth_endpoints.model('Refresh Access Token Response', { 'access_token': fields.String(required=True, description='Access token to be used for all requests'), 'expires': fields.Integer(required=True, description='Token time in seconds') }) headers = auth_endpoints.parser() headers.add_argument('Authorization', location='headers', required=True, help="Refresh token. E.g.: Bearer [JWT]") docs = { 'get_tokens': '<p>Gets a new access token to be used as an authorization header value for all ' 'other endpoints and a refresh token to be used to get a new access token.</p>',
import re import jwt from flask import request from flask_restplus import Namespace, Resource, fields from project import bcrypt from project.apis.users.models import User from project.apis.users.services import ( create_user, get_user_by_email, get_user_by_id, ) api = Namespace("auth", description="Authorisation resource") EMAIL_REGEX = re.compile(r"\S+@\S+\.\S+") REGISTER = api.model( "REGISTER", { "id": fields.String( readOnly=True, description="The user identifier", example="1"), "email": fields.String( required=True, description="A valid email address", example="*****@*****.**", ), },
from api import api, db, mail from flask import request from resources import download from models.ticket import TicketModel from models.meeting import MeetingModel from models.seat import SeatModel from models.room import RoomModel from models.price import PriceModel from models.customer import CustomerModel from models.setting import SettingModel from session import require_session from config import config from flask_mail import Mail, Message, Attachment from datetime import datetime ticket_api = Namespace('ticket') requestSchema = { "CreateTicketModel": api.model( "create ticket", { "price": fields.String(required=True, example="12abc34d5efg67hi89j1klm2nop3pqrs", description="uuid of price"), "seat": fields.String(required=True, example="12abc34d5efg67hi89j1klm2nop3pqrs", description="uuid of seat"), "meeting": fields.String(required=True,
import mx.DateTime from Cerebrum.rest.api import db, auth, fields, utils, validator from Cerebrum.rest.api.v1 import group from Cerebrum.rest.api.v1 import models from Cerebrum.rest.api.v1 import emailaddress from Cerebrum import Errors from Cerebrum.Utils import Factory from Cerebrum.utils import date from Cerebrum.QuarantineHandler import QuarantineHandler from Cerebrum.modules.gpg.data import GpgData from Cerebrum.modules.pwcheck.checker import (check_password, PasswordNotGoodEnough) api = Namespace('accounts', description='Account operations') def find_account(identifier): idtype = 'entity_id' if identifier.isdigit() else 'name' try: try: account = utils.get_account(identifier=identifier, idtype=idtype, actype='PosixUser') except utils.EntityLookupError: account = utils.get_account(identifier=identifier, idtype=idtype) except utils.EntityLookupError as e: abort(404, message=e) return account
from flask_restplus import Namespace, Resource, reqparse from werkzeug.datastructures import FileStorage from config import Config from flask import send_file from ..util import query_util, coco_util from ..models import * import datetime import os import io api = Namespace('image', description='Image related operations') image_upload = reqparse.RequestParser() image_upload.add_argument('image', location='files', type=FileStorage, required=True, help='PNG or JPG file') image_upload.add_argument('folder', required=False, default='', help='Folder to insert photo into') image_download = reqparse.RequestParser() image_download.add_argument('asAttachment', type=bool, required=False, default=False)
description: IGSN namespace """ # pylint: disable=C0103 from pathlib import Path import logging from flask import current_app from flask_restplus import Resource, Namespace, reqparse from . import validate LOGGER = logging.getLogger('explore-australia-lambda') api = Namespace('scoring', description='Scoring', path='/') POST_PARSER = reqparse.RequestParser(bundle_errors=True) POST_PARSER.add_argument( 'sampleNumber', required=True, location=('values', 'json', 'form'), type=validate.string_to_igsn ) POST_PARSER.add_argument( 'url', required=True, location=('values', 'json', 'form') ) POST_PARSER.add_argument( 'registrant',
# limitations under the License. """Resource for Payment endpoints.""" from http import HTTPStatus from flask import current_app, g, jsonify, request from flask_restplus import Namespace, Resource, cors from pay_api import jwt as _jwt from pay_api.exceptions import BusinessException from pay_api.schemas import utils as schema_utils from pay_api.services import PaymentService from pay_api.utils.enums import Role from pay_api.utils.util import cors_preflight API = Namespace('payments', description='Payment System - Payments') @cors_preflight('POST') @API.route('', methods=['POST', 'OPTIONS']) class Payment(Resource): """Endpoint resource to create payment.""" @staticmethod @cors.crossdomain(origin='*') @_jwt.has_one_of_roles([Role.BASIC.value, Role.PREMIUM.value]) def post(): """Create the payment records.""" current_app.logger.info('<Payment.post') request_json = request.get_json() # Validate the input request
"""Endpoints related to authorization and the current user.""" from flask import jsonify, redirect from flask_restplus import Namespace, Resource import api from api import check_csrf, PicoException, rate_limit, require_login from .schemas import (disable_account_req, email_verification_req, login_req, reset_password_confirmation_req, reset_password_req, update_password_req, user_extdata_req) ns = Namespace('user', description='Authentication and information about ' + 'current user') USERDATA_FILTER = [ 'admin', 'extdata', 'completed_minigames', 'logged_in', 'teacher', 'tid', 'tokens', 'unlocked_walkthroughs', 'username', 'verified' ] @ns.route('') class User(Resource): """Get the current user or update their extdata.""" @ns.response(200, 'Success') def get(self): """Get information about the current user.""" res = {'logged_in': False} if api.user.is_logged_in(): res['logged_in'] = True res['score'] = api.stats.get_score(tid=api.user.get_user()['tid'],
from flask_restplus import Namespace, Resource, fields from flask import abort, request from app.models import Tweet from app import db import json from app.schema import tweets_schema api = Namespace('tweets') json_tweet = api.model('Tweet', { 'id': fields.Integer, 'text': fields.String, 'created_at': fields.DateTime }) json_new_tweet = api.model('New tweet', {'text': fields.String(required=True)}) @api.route('/<int:id>') @api.response(404, 'Tweet not found') @api.param('id', 'The tweet unique identifier') class TweetResource(Resource): @api.marshal_with(json_tweet) def get(self, id): tweet = db.session.query(Tweet).get(id) #return jsonify(tweet) if tweet is None: api.abort(404, "Tweet {} doesn't exist".format(id)) else: return tweet
from flask import request from flask_restplus import Resource, Namespace from app.main import db from app.main.model.todo import Todo from app.main.util.decorator import admin_token_required from app.main.service.auth_helper import Auth import datetime api = Namespace('todo', description='authentication related operations') @api.route('/v1') class TodoList(Resource): """ Todo Resource """ @api.doc('Get All Todo\'s') @admin_token_required def get(self): """List all Todo's""" user_details = Auth.login_info(request) todos = Todo.query.filter_by(author=user_details["user_id"]).all() output = [] for todo in todos: todo_data = {} todo_data['id'] = todo.id todo_data['text'] = todo.text todo_data['complete'] = todo.complete output.append(todo_data)
from flask_restplus import Namespace, Resource, fields, reqparse from danke.core.checker import Checker from danke.core.render import Render from danke.core.mailer import Mailer from danke.core.tool import * from danke.database.user import User from danke.database.session import Session api = Namespace('auth', description='用户注册、认证、登录与登出') def send_verify_code(code, receiver): try: Mailer.send_email_sync(title='旦课邮箱验证码', receivers=[receiver], content='验证码:' + code) return 0, '发送成功' except Exception as e: print(e) # need a logger return 1, '发送失败' @api.route('/register') class Register(Resource): # post RegisterReq = api.model( 'RegisterReq', { 'username': fields.String(required=True,