def __init__(self, url_prefix, app=None):
self.app = app
self.url_prefix = url_prefix
self.api_blueprint = Blueprint(self.__class__.__name__, __name__)
self.api = Api(self.api_blueprint, catch_all_404s=True)
from flask import Blueprint, request, session
from flask_restful import Api, Resource
from app.modules.user import (get_user, get_users, create_user, update_user,
delete_user, authentication)
from app.api.schema import USER_SCHEMA, LOGIN_SCHEMA, UPDATE_SCHEMA
from schema import SchemaError
# from app.api.helpers import login_required
api_bp = Blueprint('user_api', __name__)
api = Api(api_bp)
class AuthResourceApi(Resource):
def post(self):
try:
data = LOGIN_SCHEMA.validate(request.json)
except SchemaError as e:
return {'status': 'ERROR', 'message': e.code}
result = authentication(data)
if not result['status']:
return result
else:
user = result['data'][0]
session['user_id'] = user['id']
session['user'] = user['name']
session['role'] = user['role']
return {'status': 'OK', 'data': result['data']}
from flask import Flask, jsonify, request
from flask_restful import Resource, Api
from pymongo import MongoClient
from json import dumps
from bson.json_util import dumps
import datetime
client = MongoClient('localhost', 27017)
db = client.db_blog
app = Flask(__name__)
api = Api(app)
publicacoes = db.col_publicacoes
class Response():
def RetornoConsulta(data, statusCode):
response = jsonify({"data": data})
response.status_code = statusCode
return response
def RetornoInsercao(sucesso):
response = jsonify({"sucesso": sucesso})
if sucesso:
response.status_code = 200
else:
response.status_code = 400
return response
class ConsultarPublicacoes(Resource):
def get(self):
listarTodas = dumps(publicacoes.find())
return Response.RetornoConsulta(listarTodas, 200)
@jwt_required
def get(self):
return {'message': 'ini bagian yang terproteksi'}
class User(UserBase):
def post(self):
args = self.reqparse.parse_args()
username = args.get('username')
password = args.get('password')
try:
hashPass = md5(password.encode('utf-8')).hexdigest()
user = models.User.get((models.User.username == username)
& (models.User.password == hashPass))
except models.User.DoesNotExist:
return {'messages': 'User or Password is wrong!'}
else:
access_token = create_access_token(identity=username)
return {
'messages': 'You have successfully signin ',
'access_token': access_token
}
users_api = Blueprint('resources.users', __name__)
api = Api(users_api)
api.add_resource(UserList, '/user/register', endpoint='user/register')
api.add_resource(User, '/user/signin', endpoint='user/signin')
# _*_ coding: utf-8 _*_
__author__ = 'yaco'
from flask import Blueprint
from flask_restful import Api
from .views import Authorities
# 创建蓝图对象,管理资源
auth_bp = Blueprint('auth', __name__)
# 蓝图遵循 restful 风格
auth_api = Api(auth_bp)
# 配置路由和接口类的对应关系
auth_api.add_resource(Authorities, "/authorities")
# -*- coding: utf-8 -*-
import datetime
import uuid
from flask import Blueprint, g, request, url_for
from flask_restful import Api, abort, fields, marshal_with, Resource
from app.api import pagination_query, restful_api, CustomRequestParser, UrlNormalize, AddResource
from app.api.member import member_login_required
from app.model import db, Datetime2Timestamp, DecimalToString
from app.model.user import LoginInfo, User, g_user_state_type
from app.model.pin_code import CaptchaPinCode, SmsPinCode
from app.model.payment import Payment
from werkzeug.http import dump_cookie
user_bp = Blueprint('member_user_bp', __name__)
user_api = AddResource(Api(user_bp))
def member_user_mobile_exists(mobile):
user = User.query.filter(User.mobile == mobile).first()
return user
member_user_login_fields = {
'id': fields.String,
'uid': fields.String,
'mobile': fields.String,
'token': fields.String,
}
from flask import Flask
from flask_bcrypt import Bcrypt
from flask_jwt_extended import JWTManager
from database.db import initialize_db
from flask_restful import Api
from resources.routes import initialize_routes
from resources.errors import errors
app = Flask(__name__)
app.config.from_envvar('ENV_FILE_LOCATION')
api = Api(app, errors=errors)
bcrypt = Bcrypt(app)
jwt = JWTManager(app)
app.config['MONGODB_SETTINGS'] = {
'host': 'mongodb://192.168.4.58/ddiadmin'
}
initialize_db(app)
initialize_routes(api)
app.run(port=3500)
import appengine_config
import logging
from flask import Flask
from flask_restful import Api
from flask_wtf import CSRFProtect
app = Flask(__name__)
app.config.from_object(__name__)
csrf_protect = CSRFProtect()
api = Api(app, decorators=[csrf_protect.exempt])
if appengine_config.GAE_DEV:
logging.warning('Using a dummy secret key')
app.secret_key = 'MyS3cr3tKey'
app.debug = True
DEBUG = True
else:
import app_secrets
app.secret_key = app_secrets.app_secret_key
from flask import Flask, got_request_exception
import logging
import os
from flask_restful import Api
# app
sourcer_app = Flask(__name__)
sourcer_api = Api(sourcer_app)
# Routes
from routes import routes
def run_server():
sourcer_app.run('0.0.0.0', '5000')
if __name__ == '__main__':
run_server()
import os
from flask import Flask, jsonify, make_response, request
from flask_restful import Api, Resource
from flask_cors import CORS
from flask_prediction import load_model, predict
from counter import addLog
import datetime
app = Flask(__name__)
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
api = Api(app, prefix="/api/to_back_end")
labels = ["Iderodcomedian", "enkhbat"]
model, tokenizer, processor, output_mode, device = load_model()
class Predictor(Resource):
def get(self):
print("request", request)
text = request.args['text']
url = request.base_url
print("text:", text)
index_, score_ = predict(text, model, tokenizer, processor,
output_mode, device)
date_now = str(datetime.datetime.now())
req_count = addLog(date_now, url, text, index_, score_)
# from ConfigParser import SafeConfigParser
# from celery import Celery
from flask import Flask
from flask_restful import Api
from flask_restful_swagger import swagger
from ansible_restful import log
# # 读取配置文件
# config = SafeConfigParser()
# config.read('config.ini')
app = Flask(__name__)
log = log.Log().getlog()
# # 读取celery配置参数
# app.config['broker_url'] = config.get("Default", "CELERY_BROKER_URL")
# app.config['result_backend'] = config.get("Default", "CELERY_RESULT_BACKEND")
# task_timeout = int(config.get("Default", "CELERY_TASK_TIMEOUT"))
api = swagger.docs(Api(app), apiVersion='0.1')
# celery = Celery(app.name, broker=app.config['broker_url'], backend=app.config['result_backend'])
# celery.conf.update(app.config)
import deploy
import runner
import playbook
#from deploy import Deploy
#from playbook import Playbook
from flask_marshmallow import Marshmallow from flask_restful import Api from flask_socketio import SocketIO from flask_login import LoginManager from flask_sqlalchemy import SQLAlchemy logging.basicConfig(level=logging.DEBUG) APP = Flask(__name__) APP.secret_key = 'secret!$#' APP.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' API = Api(APP) MA = Marshmallow(APP) SETTINGS = APP.config DB = SQLAlchemy(APP) login_manager = LoginManager() login_manager.login_view = "signin" login_manager.init_app(APP) socketio = SocketIO(APP) # flask routes from app.handlers.socket import * from app.handlers.room import * from app.handlers.signin import *
from flask_restful import Api
from flask import Blueprint, jsonify, request
from api.resource.place import PlaceFrequency, PlaceScene, PlaceCharacter
from api.resource.movie import QueryMovie, Summary
from api.resource.character import (
CharacterFrequency,
CharacterRelation,
CharacterSentiment,
CharacterWord,
)
from api.resource.time import TimeScene, TimeCharacter, TimeFrequency
from api.errors import *
toyScriptApi = Blueprint("api", __name__)
api = Api(toyScriptApi)
api.add_resource(PlaceFrequency, "/<int:movie_id>/places/frequencys")
api.add_resource(PlaceScene, "/<int:movie_id>/places/scenes")
api.add_resource(PlaceCharacter, "/<int:movie_id>/places/characters")
api.add_resource(CharacterFrequency, "/<int:movie_id>/characters/frequencys")
api.add_resource(CharacterRelation, "/<int:movie_id>/characters/relations")
api.add_resource(CharacterSentiment, "/<int:movie_id>/characters/sentiments")
api.add_resource(CharacterWord, "/<int:movie_id>/characters/words")
api.add_resource(TimeScene, "/<int:movie_id>/times/scenes")
api.add_resource(TimeCharacter, "/<int:movie_id>/times/characters")
api.add_resource(TimeFrequency, "/<int:movie_id>/times/frequencys")
api.add_resource(Summary, "/movies/<int:movie_id>")
# -*- coding: utf-8 -*-
import unittest
from flask import Flask, Blueprint, jsonify
from flask_restful import Api, Resource
from flask import g
from drift.tests import DriftTestCase
from drift.core.extensions.jwt import jwtsetup, verify_token, jwt_not_required, current_user, check_jwt_authorization
app = Flask(__name__)
app.testing = True
bp = Blueprint("jwt_api", __name__)
api = Api(bp)
# Endpoints closed from public access
class APIClosed(Resource):
def get(self):
ret = {
"message2": "hi there",
"current_user": dict(current_user) if current_user else None,
}
return ret
api.add_resource(APIClosed, '/apiclosed', endpoint="apiclosed")
from flask_restful import Api
from app.controllers import (IndexView, UserView, UserDetailView,
UserLoginView, ResetPassword)
api = Api()
# Index route
api.add_resource(IndexView, '/')
# User routes
api.add_resource(UserView, '/users', endpoint='users')
api.add_resource(UserDetailView, '/users/<string:user_id>', endpoint='user')
api.add_resource(UserLoginView, '/users/login', endpoint='user_login')
api.add_resource(ResetPassword,
'/users/reset_password',
endpoint='reset_password')
# coding: utf-8
import os
from flask import jsonify, request, Flask, send_from_directory, url_for
from flask_restful import Resource, Api, abort
from werkzeug.utils import secure_filename, redirect
from models import FileManager
from app.helper import lock_access, get_config, check_manage, check_remote, get_md5
from app.helper import get_logger
logger = get_logger()
app = Flask(__name__)
APP_API = Api(app)
Myconfig = get_config()
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1] in Myconfig.ALLOWED_EXTENSIONS
class OK(Resource):
def get(self):
return 'ok'
class TokenApi(Resource):
@check_manage
def load_api(app):
apis = Api(app)
apis.decorators = [cors.crossdomain(origin='*')]
apis.add_resource(Login, '/login')
apis.add_resource(Reg, '/register')
import ruamel.yaml
from flask import Blueprint, abort, request, current_app
from flask_jwt_extended import jwt_required, get_jwt_identity
from flask_restful import Resource, Api, fields, marshal_with
from caas.core.exc import UnknownFormatError
from caas.extensions import csrf_protect
from caas.provider.models import App as AppModel, Cluster
from caas.utils import get_config_file_path
blueprint = Blueprint('api',
__name__,
url_prefix='/api',
static_folder='../static')
api = Api(blueprint, decorators=[jwt_required])
app_info = {
'name': fields.String,
'config': fields.String,
}
csrf_protect.exempt(blueprint)
def parse_config_file_data(config_data, app):
app_machine_types = []
for app_type in AppModel.APP_TYPE:
app_type_keyword = app_type.value
if app_type_keyword in config_data:
app_machine_types.append(app_type)
part_config_data = config_data[app_type_keyword]
with open(get_config_file_path(app.config_file_name[app_type]),
from http import HTTPStatus
from bson import ObjectId
from flask_restful import Resource, Api
from flask_restful.reqparse import RequestParser
from . import api_blueprint, db
from ..util import security
from ._conversions import create_release_result
from ._deletion import delete_release
from common.database.contracts import artist_contract as c
from common.database.codecs import release_from_document
api = Api(api_blueprint, prefix='/release')
_arg_parser_create = RequestParser()\
.add_argument('artist_id', required=True)\
.add_argument('name', required=True)\
.add_argument('date')\
.add_argument('type')
_arg_parser_get = RequestParser()\
.add_argument('songs')
_arg_parser_patch = RequestParser()\
.add_argument('name')\
.add_argument('date')\
.add_argument('type')
@api.resource('')
# Global var
Gd_internalvar = {
'name': "pfioh",
'version': "",
'verbosity': 1,
'storeBase': "/tmp",
'key2address': {},
'httpResponse': False,
'createDirsAsNeeded': False,
'b_swiftStorage': False,
'b_tokenAuth': False,
'authModule': None
}
StoreHandler = Flask(__name__)
restful_api = Api(StoreHandler, prefix="/api/v1/cmd")
suppressFlaskOutput = sys.modules['flask.cli']
suppressFlaskOutput.show_server_banner = lambda *x: None
class HandleRequests(Resource):
b_quiet = False
def __init__(self, *args, **kwargs):
"""
"""
global Gd_internalvar
self.__auth = None
self.__name__ = 'StoreHandler'
self.d_ctlVar = Gd_internalvar
b_test = False
import datetime
from flask import Blueprint
from flask_restful import Resource, Api, reqparse, marshal, inputs
from blueprints import internal_required, non_internal_required
from flask_jwt_extended import jwt_required, get_jwt_claims
from .model import PenerimaanDonasi
from blueprints import db, app
from sqlalchemy import desc
# 'client' penamaan (boleh diganti)
bp_penerimaanDonasi = Blueprint('penerimaanDonasi', __name__)
api = Api(bp_penerimaanDonasi)
class PenerimaanDonasiResource(Resource):
@jwt_required
@internal_required
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('id',location='args', help='invalid id', required=True)
args = parser.parse_args()
qry = PenerimaanDonasi.query.get(args["id"])
if qry is not None:
return {"status":"success", "result":marshal(qry, PenerimaanDonasi.response_field)}, 200, {'Content-Type':'application/json'}
return {'status':'failed',"result":"ID Not Found"}, 404, {'Content-Type':'application/json'}
from flask import Blueprint, jsonify, request
from flask_restful import Resource, Api
import logging
from service.crud import add_department, get_departments, get_department, del_department, put_department
from service.checkers import department_check
from models.models import department_keys
rest_departments_blueprint = Blueprint('departments', __name__)
dept_api = Api(rest_departments_blueprint)
logger = logging.getLogger('dep')
from datetime import datetime
class Departments(Resource):
def post(self):
"""
Create department with data from POST reuest body.json
:return: departmen id, title
"""
data = request.get_json()
if not department_check(data, department_keys):
return 'Bad Request', 400
title = data.get('title')
item_id = add_department(title)
department = {'title': title, 'id': item_id}
resp = jsonify(department)
resp.status_code = 201
log_msg = f'dep {item_id}, {title}, created : {datetime.now()}'
logger.warning(log_msg)
return resp
def get(self):
import os
import logging
from flask import Flask
from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy
from flask_apscheduler import APScheduler
student_app = Flask(__name__)
student_app.config.from_object(os.environ.get('app_env'))
db = SQLAlchemy(student_app)
# db.app = student_app
# db.init_app(student_app)
scheduler = APScheduler()
scheduler.init_app(student_app)
scheduler.start()
student_api = Api(student_app)
from student_directory.students.views.students import Students
from student_directory.students.views.edit_student import EditStudent
from student_directory.students.views.executive_summary import ExecutiveSummary
from student_directory.students.views.by_state import ByState
from student_directory import jobs
students_view = Students.as_view(name="students")
edit_student_view = EditStudent.as_view(name='edit_student')
executive_summary = ExecutiveSummary.as_view(name='executive')
by_state_view = ByState.as_view(name='by_state')
student_app.add_url_rule('/', view_func=students_view, methods=['GET', 'POST'])
student_app.add_url_rule('/student/<student_id>',
view_func=edit_student_view,
methods=['GET', 'POST'])
from flask import Flask, request from flask_restful import Resource, Api, reqparse, abort from time import strftime import json, logging from logging.handlers import RotatingFileHandler from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate, MigrateCommand from blueprints import * from flask_script import Manager from flask_jwt_extended import JWTManager from datetime import timedelta app = Flask(__name__) ## initiate flask-restful instance api = Api(app, catch_all_404s=True) # app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://fatmajan:[email protected]:3306/olshop' app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://fatimahfashion:password@fatimahfashion.cr3knnpxz7n1.ap-southeast-2.rds.amazonaws.com:3306/fatimahfashion' # app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['JWT_SECRET_KEY'] = 'SFsieaaBsLEpecP675r243faM8oSB2hV' app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta( days=1) #bestpractice expiry is 1 hour jwt = JWTManager(app) @jwt.user_claims_loader
import json
import DataDestination.*
# import asyncio
# from azure.eventhub import EventData
from flask import Flask, jsonify, request
# from azure.eventhub.aio import EventHubProducerClient
from flask_restful import Resource, Api, reqparse, abort
application = Flask(__name__)
api = Api(application)
class EventhubsApi(Resource):
def get(self):
return "working"
def post(self):
json_data = request.data
dataDestinationEventHubs = DataDestinationEventHubs(json_data)
return "nada"#resultado.tolist()
api.add_resource(EventhubsApi,'/EventhubsApi')
if __name__=='__main__':
application.run(debug=True,host='0.0.0.0',port=5000)
from flask import Blueprint
from flask_restful import Api, Resource, reqparse, marshal
from flask_jwt_extended import create_access_token, get_jwt_identity, get_jwt_claims, jwt_required
import hashlib
from blueprints import db
from ..user.model import User
bp_auth = Blueprint('auth', __name__)
api = Api(bp_auth)
class CreateTokenResource(Resource):
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('username', location='args', required=True)
parser.add_argument('password', location='args', required=True)
args = parser.parse_args()
qry_user = User.query.filter_by(username=args['username']).first()
user_salt = qry_user.salt
hash_pass = hashlib.sha512(
('%s%s' %
(args['password'], user_salt)).encode('utf-8')).hexdigest()
if hash_pass == qry_user.password:
qry_user = marshal(qry_user, User.jwt_claim_fields)
token = create_access_token(identity=args['username'],
user_claims=qry_user,
expires_delta=False)
return {'token': token}, 200
else:
#coding:utf8
from flask import Blueprint
from flask_restful import Api, Resource, url_for
admin = Blueprint("admin", __name__)
api = Api(admin)
import app.admin.views
from flask import Blueprint, request, jsonify
from flask_restful import Resource, Api
from sqlalchemy import exc
from project import db
from project.api.models import Exercise
from project.api.utils import authenticate_restful
exercises_blueprint = Blueprint('exercises', __name__)
api = Api(exercises_blueprint)
class ExercisesList(Resource):
method_decorators = {'post': [authenticate_restful]}
def get(self):
"""Get all exercises"""
response_object = {
'status': 'success',
'data': {
'exercises':
[exercise.to_json() for exercise in Exercise.query.all()]
}
}
return response_object, 200
def post(self, resp):
"""Add exercise"""
from flask import Blueprint
from flask_restful import Api, Resource, reqparse, marshal
from flask_jwt_extended import create_access_token
from blueprints.users.model import Users
import hashlib
blueprint_login = Blueprint("login", __name__)
api = Api(blueprint_login)
#login / create token resources
class CreateTokenResources(Resource):
def options(self, id=None):
return {'status': 'ok'}, 200
def post(self): #method untuk login dan mengambil token
parser = reqparse.RequestParser()
parser.add_argument("username", location="json", required=True)
parser.add_argument("password", location="json", required=True)
args = parser.parse_args()
password = hashlib.md5(args["password"].encode()).hexdigest()
if args["username"] == "admin" and args["password"] == "Admin@creart":
user_claims_data = {}
user_claims_data["is_admin"] = True
else:
qry = Users.query.filter_by(username=args["username"])
qry = qry.filter_by(password=password)
qry = qry.filter_by(status=True).first()
if qry is None:
return {
"status": "UNAUTHORIZED",
# -*- coding: utf-8 -*-
import io
import qrcode
from flask import send_file, Blueprint
from flask_restful import Resource
from flask_restful import Api, Resource, reqparse, abort
from app.api import restful_api, AddResource
qr_code_bp = Blueprint('qr_code', __name__)
qr_code_api = Api(qr_code_bp)
qr_code = AddResource(qr_code_api)
# 二维码
@qr_code.add_resource('/address_qr_code/<string:address>')
class AddressQrCodeApi(Resource):
def get(self, address):
qr = qrcode.QRCode(
version=2,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=1)
url = address
qr.add_data(url)
qr.make(fit=True)
qr_img = qr.make_image()
byte_io = io.BytesIO()
qr_img.save(byte_io, 'PNG')
