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,
