def add_resources():
# We will add our resources here
api.add_resource(GameServer, "/games/server", "/games/server/<game_id>")
api.add_resource(GameServerList, "/games/list")
api.add_resource(GameServerConnect, "/games/server/<game_id>/connect")
api.add_resource(GameServerDisconnect, "/games/server/<game_id>/disconnect")
print("Added resources")
msg = "Data recorded. Your reference number is {}".format(ref)
return {"status":True, "message":msg, "data":ref}, 200
def get(self):
#get all the data in the database
getall = mongo.db.payfees.find({}, {"_id":0})
result = []
for element in getall:
result.append(element)
if result == []:
return {"message":'Oops! no recorded information yet.'}, 200
return {"status":True, "message":'data retrieved', "data":result}, 200
api.add_resource(PaymentDetails, '/api/payfees')
class GetOneRecord(Resource):
def get(self, reference):
#get all the data in the database
getone = mongo.db.payfees.find_one({"ref":reference}, {"_id":0})
if not getone:
return {"message":'No record found for the user'}, 200
return {"status":True, "message":'data retrieved', "data":getone}, 200
def put(self, reference):
#get all the data in the database
getone = mongo.db.payfees.update_one({"ref":reference}, {'$set': {"date":nigerian_time(), "frequency":"fine"}})
from flask_restful import Resource
from app import api
from apps.auth import models
from apps.utils import MiximJson
class GetUsers(Resource, MiximJson):
def get(self):
users = models.User.query.all()
return self.to_json(users)
api.add_resource(GetUsers, '/api/getusers')
class AnalysisController(Resource):
# parser = reqparse.RequestParser()
# parser.add_argument('id', type=int, required=True, location='values')
# curl -X POST -d '{"phrase": "immigration", "frame": 1}' http://localhost:5000/api/analyses/ -H "Content-Type: application/json"
@marshal_with(analysis_marshall)
def get(self, id):
"""
Return percent complete (meta).
Return either empty json or completed frame and topic plot (text).
"""
analysis_obj = Analysis.get(Analysis.id == id)
info = analysis_obj.check_if_complete()
data = get_dictionary_from_model(analysis_obj)
data['topic_plot'] = eval(data['topic_plot']) if data['topic_plot'] else None
data['frame_plot'] = eval(data['frame_plot']) if data['frame_plot'] else None
data['wordcount_plot'] = eval(data['wordcount_plot']) if data['wordcount_plot'] else None
return { 'meta': info, 'data': data }
def put(self, id):
"""Update analysis in persistant storage"""
pass
api.add_resource(AnalysisListController, '/api/analyses/', endpoint = 'analyses')
api.add_resource(AnalysisController, '/api/analyses/<int:id>/', endpoint = 'analysis')
p_result = program_result["result"][0]["id"]
else:
p_result = program_result["errors"]
break
except Exception as e:
print(e)
trialcounter += 1
if trialcounter == 3:
p_result = "Unknown Error"
# result[0] is the id of the parent folder, finish writing create_program api call first
# prog_result = restClient.create_program()
return {"success": True, "folder_name": foldername, "folder_results": results, "program_result": p_result}
api.add_resource(CreateFolders, "/createfolders/<string:api_key_in>/<string:new_email>")
#
# Create User
#
# /api/<string:api_key_in>/newuser
# POST, Content-Type = application/x-www-form-urlencoded OR application/json
#
# inputs = *firstName, *lastName, *email, role, language (*REQUIRED)
#
# Output = {
# 'success':True/False,
# 'message':[error message if unsuccessful or blank if wrong API key],
# 'result':''
# }
#
class Control(Resource): # '''this part need to change to tcp connection'''
def get(self):
userid = request.args.get('userid')
control = request.args.get('control', type=str) # left,right,forward,stop
app.logger.info("userid:%s control:%s", userid, control)
user=User.query.get(int(userid))
print user.registration_token
body = {}
body["to"] = user.registration_token # need to edit
# body["notification"] = {"title": "Portugal vs. Denmark", "body": "5 to 1", "icon": "myicon"}
body['data'] = {'message': control}
headers = {'Content-Type': 'application/json', 'Authorization': 'key=' + API_KEY}
print "Send data \n" + str(body)
#r = requests.post(url, data=json.dumps(body), headers=headers)
r = requests.post(url, data=json.dumps(body), headers=headers)
print r.status_code
print r.text
pass # Add the resources.''''
api.add_resource(Register, '/oldbirds/api/register', endpoint='register') # is ok
api.add_resource(Users, '/oldbirds/api/users/', endpoint='users') # is ok
api.add_resource(User_location, '/oldbirds/api/user_location/', endpoint='user_location') # get is ok need post part.
api.add_resource(Control, '/oldbirds/api/control/', endpoint='control') # need hannu reply
if user is None:
return {'success': False, 'message': 'No user in DB!'}
user.gardens.append(garden)
db.session.add(user)
db.session.add(garden)
db.session.commit()
return {'success': True}
#########################################################################################
# API URIs
#########################################################################################
# offering
api.add_resource(Offering, '/api/offering', '/api/offering/<string:id>')
api.add_resource(OfferingAll, '/api/offering/all')
# address
api.add_resource(Address, '/api/address/<string:id>')
api.add_resource(AllUserAddresses, '/api/address')
# product
api.add_resource(Product, '/api/product')
api.add_resource(ProductsAll, '/api/product/all')
# garden
api.add_resource(Garden, '/api/garden')
api.add_resource(GardensAll, '/api/garden/all')
api.add_resource(Route, '/api/route')
def register_product_resource():
api.add_resource(ProductResource, '/products', endpoint='products')
api.add_resource(CategoryResource, '/categories', endpoint='categories')
class BookApprovalAPI(Resource):
@admin_required
def put(self, id):
book = Book.query.filter_by(id=id).first()
if book is None:
response = {'message': 'book does not exist'}
return response, 404
else:
book.approved = True
db.session.commit()
return "", 204
api.add_resource(BookAPI, '/books/<int:id>', endpoint='book')
api.add_resource(BookListAPI, '/books', endpoint='books')
api.add_resource(ReadBookListAPI,
'/books/read',
'/books/read/<int:user_id>',
endpoint='read-books')
api.add_resource(BookPendingListAPI,
'/books/pending',
endpoint='books-pending')
api.add_resource(BookApprovalAPI,
'/books/approve/<int:id>',
endpoint='approve-book')
api.add_resource(AuthorBookListAPI,
'/books/author/<int:author_id>',
endpoint='books_by_author')
api.add_resource(BookTitleSearchAPI,
def post(self):
data = request.get_json()['params']
rows = [data]
db.session.execute(Role.__table__.insert(),rows)
db.session.commit()
return json.dumps({'code':0,'msg':'添加成功'})
class RoleAPI(Resource):
decorators = [auth.login_required]
def delete(self,id):
obj = Role.query.filter_by(id=int(id)).first()
db.session.delete(obj)
db.session.commit()
return json.dumps({'code':0,'msg':'成功'})
def put(self,id):
data = request.get_json()['params']
data.pop('id')
ret = db.session.query(Role).filter_by(id=id).update(data)
db.session.commit()
return json.dumps({'code':0,'msg':'更新成功'})
api.add_resource(RoleListAPI, '/devops/api/v1.0/role', endpoint = 'role')
api.add_resource(RoleAPI, '/devops/api/v1.0/role/<int:id>', endpoint = 'roleedit')
args = parser.parse_args()
t = arrow.get(request.json['jgsj']).replace(hours=-8).to('local')
hbc = Hbc(date=t.format('YYYY-MM-DD'),
jgsj=t.datetime,
hphm=request.json['hphm'],
kkdd_id=request.json['kkdd_id'],
hpys_id=request.json['hpys_id'],
fxbh_id=request.json['fxbh_id'],
cdbh=request.json['cdbh'],
imgurl=request.json['imgurl'],
imgpath=request.json.get('imgpath', ''),
banned=0)
db.session.add(hbc)
db.session.commit()
result = row2dict(hbc)
result['jgsj'] = str(result['jgsj'])
del result['date']
return result, 201
api.add_resource(Index, '/')
api.add_resource(User, '/user/<int:user_id>')
api.add_resource(UserList, '/user')
api.add_resource(ScopeList, '/scope')
api.add_resource(TokenList, '/token')
api.add_resource(HbcImg, '/hbcimg/<string:date>/<string:hphm>/<string:kkdd>')
api.add_resource(HbcApi, '/hbc/<string:jgsj>/<string:hphm>/<string:kkdd>')
api.add_resource(HbcList, '/hbc')
from app import api
from app.base import resource as base
from app.phi import resource as phi
import schema, dao
api.add_resource(phi.PHIEntityResource,
'/kits/<string:id>',
resource_class_args=(dao.kit_dao, schema.kit_schema),
endpoint='Kit::Entity')
api.add_resource(phi.PHICollectionResource,
'/kits',
resource_class_args=(dao.kit_dao, schema.kit_schema),
endpoint='Kit::Collection')
api.add_resource(phi.PHISearchResource,
'/search/kits',
resource_class_args=(dao.kit_dao, schema.kit_schema),
endpoint='Kit::Search')
api.add_resource(base.EntityResource,
'/kit-types/<string:id>',
resource_class_args=(dao.kit_type_dao,
schema.kit_type_schema),
endpoint='KitType::Entity')
api.add_resource(base.CollectionResource,
'/kit-types',
resource_class_args=(dao.kit_type_dao,
schema.kit_type_schema),
endpoint='KitType::Collection')
from app import api as url from app.controllers.NetworkdeviceController import NetworkDeviceController # api.add_resource(NetworkDeviceController, '/network-device') url.add_resource(NetworkDeviceController, '/network-device')
from app import api as rest_api from app.users import api as users_api rest_api.add_resource(users_api.VirsChatHome, '/') rest_api.add_resource(users_api.UserAPI, '/api/v1/user') rest_api.add_resource(users_api.AuthenticationAPI, '/api/v1/authenticate') rest_api.add_resource(users_api.PasswordResetRequestAPI, '/api/v1/password-reset/request') rest_api.add_resource(users_api.PasswordResetConfirmAPI, '/api/v1/password-reset/confirm') rest_api.add_resource(users_api.AdminOnlyAPI, '/api/v1/admin')
response = requests.post(url, params=args)
return {'response': response.json()}
class test(Resource):
def get(self):
return {'url': 'url'}
class Dashboard(Resource):
def get(self):
engine = sqlalchemy.create_engine(settings['ASSETDB'],
pool_pre_ping=True,
pool_size=20,
max_overflow=5)
Session = scoped_session(sessionmaker(autocommit=False, bind=engine))
s = Session()
result = s.execute(
'select count(*), c.componenttypename,d.displaystate from resources as a left join componentdefinition as b on (a.componentid = b.componentid) left join componenttype as c on (b.componenttypeid = c.componenttypeid) left join resourcestate as d on (d.resourcestateid = a.resourcestateid) group by c.componenttypename,d.displaystate'
)
query = json.dumps([dict(ix) for ix in result])
return {"query": json.loads(query)}
s.close()
engine.close()
api.add_resource(Dashboard, '/api/v1/dashboard')
from app import api, resources api.add_resource(resources.Test, '/')
#======end=====
for item in self.receipt['consentReceipt']:
if item is None:
logger.debug(item + 'can not be none!')
abort(409, item + 'can not be none!')
# receipt[item] = self.receipt[item]
receipt = Receipts(
self.receipt['rpt'],
self.receipt['consentReceipt']['rs_id'],
str(self.receipt['consentReceipt']['consent_receipt_id']),
str(self.receipt['consentReceipt']['service_contract_id']),
self.receipt['consentReceipt']['authorization_status'],
str(self.receipt['consentReceipt']['data_usage_license']),
json.dumps(self.receipt['consentReceipt']['consent_summary']))
mapping = Mappings(
self.receipt['consentReceipt']['account_id'],
str(self.receipt['consentReceipt']['consent_receipt_id']),
datetime.datetime.now()
)
db.session.add(mapping)
db.session.add(receipt)
db.session.commit()
return {'message': 'created'}, 201
api.add_resource(ReceiptAPI, '/receipt', endpoint='receipt')
#-*- coding: UTF-8 -*- from app import api # 活动信息接口--GET POST PUT DELETE from app.json.activity import activity api.add_resource(activity, '/activity') # 相关活动接口--POST from app.json.findActivities import findActivities api.add_resource(findActivities, '/activity/find') # 活动模板信息接口--GET POST PUT DELETE from app.json.activityModel import activityModel api.add_resource(activityModel, '/activityModel') # 活动纪念品信息接口--GET POST PUT DELETE from app.json.activitySouvenir import activitySouvenir api.add_resource(activitySouvenir, '/activitySouvenir') # 公寓信息接口--GET POST PUT DELETE from app.json.apartment import apartment api.add_resource(apartment, '/apartment') # 宾馆信息接口--GET POST PUT DELETE from app.json.hotel import hotel api.add_resource(hotel, '/hotel') # 超市信息接口--GET POST PUT DELETE from app.json.market import market api.add_resource(market, '/market')
def register_order_resource():
api.add_resource(OrderResource, '/orders', endpoint='orders')
from app import app, api
from flask import Flask
from app.controller import comentController
api.add_resource(comentController.CommentController,
'/comment',
methods=['POST', 'GET'],
endpoint='comment')
api.add_resource(comentController.CommentController,
'/comment/<int:id>',
methods=['GET', 'PUT', 'DELETE'],
endpoint='comment-edit')
api.init_app(manufacturer_blueprint)
class Manufacturer(Resource):
method_decorators = [jwt_required()]
def get(self, id):
manufacturer = ManufacturerModel.find(id=id)
assets = []
for asset in manufacturer.assets:
assets.append(asset.id)
model = {
'manufacturer': {
'id': manufacturer.id,
'description': manufacturer.description,
'title': manufacturer.title,
'note': manufacturer.note,
'assets': assets,
'image': manufacturer.image
}
}
return jsonify(model)
def post(data):
pass
api.add_resource(Manufacturer, '/api/manufacturers/<int:id>')
}
}
else:
return {'error': 'Credentials provided are incorrect'}
else:
return {'error': 'User does not exist'}
class UserView(Resource):
@jwt_required
def get(self):
current_user = User.query.filter_by(username=get_jwt_identity()).first()
return {'result': user_schema.dump(current_user)}
class UserLogoutView(Resource):
@jwt_required
def post(self):
jti = get_raw_jwt()['jti']
user_identity = get_jwt_identity()
revoke_token(jti, user_identity)
return {"message": "Successfully logged out"}, 200
api.add_resource(Register, '/users/register')
api.add_resource(Login, '/users/login')
api.add_resource(UserLogoutView, '/users/logout')
api.add_resource(UserView, '/users/me')
departmentlist.append(model)
return jsonify({'departments': departmentlist})
@roles_required(['administrator'])
def post(self):
json = request.json['department']
department = DepartmentModel(
name=json['name'],
description=json['description'],
parent_id=json['parent_id'],
id=json['id']
)
department.save()
model = {
'department': {
'id': department.id,
'name': department.name,
'description': department.description,
'parent_id': department.parent_id
}
}
print model
return jsonify(model), 201
api.add_resource(DepartmentList, '/api/departments')
#!/usr/bin/env python3
# custom imports
from app import app, api, mongo
from resources import resources as res
api.add_resource(res.UserSignup, '/signup')
api.add_resource(res.UserSignin, '/signin')
api.add_resource(res.TokenRefresh, '/token/refresh')
api.add_resource(res.ConfirmToken, '/confirm')
api.add_resource(res.ChangePassword, '/change')
api.add_resource(res.ResetPassword, '/reset')
api.add_resource(res.User, '/user', '/user/<string:id>')
api.add_resource(res.UserList, '/user/list')
api.add_resource(res.UserAvatar, '/user/avatar/<string:id>')
api.add_resource(res.UserProfile, '/user/profile/<string:id>')
api.add_resource(res.UserLastseen, '/user/lastseen/<string:id>')
api.add_resource(res.UserChangePassword, '/user/change/<string:id>')
api.add_resource(res.UserDeleteAccount, '/user/delete/account')
api.add_resource(res.UserChallenge, '/user/challenge')
api.add_resource(res.UserExport, '/user/export')
api.add_resource(res.Challenge, '/challenge', '/challenge/<string:id>')
api.add_resource(res.ChallengeList, '/challenge/list')
api.add_resource(res.ChallengeSubscription, '/challenge/subscription')
api.add_resource(res.ChallengeSubscriptionList, '/challenge/subscription/list')
api.add_resource(res.ChallengeExport, '/challenge/export')
api.add_resource(res.ChallengeTask, '/challenge/task',
'/challenge/task/<string:id>')
from app import api from app.api.users import User,UserList api.add_resource(User,'/api/users/<int:id>') api.add_resource(UserList,'/api/users')
from app import api, db
from flask import jsonify
from flask_restful import Resource, reqparse
from dateutil.parser import parse as date_parser
from app.models import SensorData, SensorDataTest, SensorDataSchema
data_schema = SensorDataSchema(many=True)
class Heartbeat(Resource):
def get(self):
return {'STATUS': 'OK', 'message': 'Server is running ok :)'}
api.add_resource(Heartbeat, '/', endpoint="heartbeat")
class DataPointList(Resource):
def __init__(self):
self.reqparse = reqparse.RequestParser()
self.reqparse.add_argument('datapoints', type = list, required=True, help="No data provided", location = 'json')
def get(self, table='live', gait = None):
if table == 'test':
if gait:
data = SensorDataTest.query.filter_by(gait=gait).all()
else:
data = SensorDataTest.query.all()
else:
if gait:
data = SensorData.query.filter_by(gait=gait).all()
from __future__ import absolute_import
from flask import request
from flask_login import login_user, logout_user
from flask_restful import Resource
from app import api
from models.account import User
class Authorize(Resource):
def post(self):
user = User.query.filter(User.email == request.form.get('email')).first()
if user and user.verify_password(request.form.get('password')):
login_user(user)
return user.id
return {'message': 'Invaild authorization information given'}, 400
api.add_resource(Authorize, '/users/authorize')
class Logout(Resource):
def post(self):
logout_user()
return ''
api.add_resource(Logout, '/users/logout')
from app.resources.base import Index
from app.resources.auth import UserLogin, UserRegister
from app.resources.bucketlists import BucketListsAPI, BucketListAPI
from app.resources.items import ItemsAPI, ItemAPI
from app import api, app
""" Defining the API endpoints """
api.add_resource(Index, "/")
api.add_resource(UserRegister, "/auth/register/")
api.add_resource(UserLogin, "/auth/login/")
api.add_resource(BucketListsAPI, "/bucketlists/")
api.add_resource(BucketListAPI, "/bucketlists/<id>")
api.add_resource(ItemsAPI, "/bucketlists/<id>/items/")
api.add_resource(ItemAPI, "/bucketlists/<id>/items/<item_id>")
if __name__ == "__main__":
app.run()
'code': args['code'],
'friendly_code': args['friendly_code'],
"type": args['type'],
"description": args['description'],
"status": args['status'],
"value_type": args['value_type'],
"value_amount": args['value_amount'],
"value_currency": args['value_currency'],
"minimum": args['minimum'],
"minimum_currency": args['minimum_currency'],
"total": args['total'],
"remaining": args['remaining'],
}
return codes_data[code_id], 201
api.add_resource(Codes, '/campaigns/<string:campaign_id>/codes')
class Code(Resource):
""" Individual Code """
@shareddefs.campaigns_api_token_required
def get(self, campaign_id, code_id):
abort_code_not_found(code_id)
return codes_data[code_id], 200
@shareddefs.campaigns_api_token_required
def put(self, campaign_id, code_id):
args = parser.parse_args()
code = {
'code': args['code'],
'friendly_code': args['friendly_code'],
hate=args['hate'],
dreams=args['dreams'],
dreamcity=args['dreamcity'])
interests1 = Interests.query.filter_by(
user_id=new_interests.user_id).first()
if interests1 is not None:
interests1.modify(new_interests)
else:
db.session.add(new_interests)
db.session.commit()
return {'interest': marshal(new_interests, interest_fields)}
api.add_resource(UserAPI, '/api/users/<int:id>', endpoint='user')
api.add_resource(UserAPI, '/api/users', endpoint='user_add')
api.add_resource(InterestsAPI,
'/api/interests/<int:user_id>',
endpoint='interests')
api.add_resource(InterestsAPI, '/api/interests', endpoint='interests_add')
@app.route('/api/token')
@auth.login_required
def get_auth_token():
token = g.user.generate_auth_token(600)
ints = Interests.query.get(g.user.id)
first_time = False
if ints is None:
first_time = True
db.session.commit()
class AddFriend(Resource):
def get(self, username, friend):
u = User.query.filter_by(username=username).first()
f = User.query.filter_by(username=friend).first()
u.add_friend(f)
db.session.commit()
return succes()
def delete(self, username, friend):
u = User.query.filter_by(username=username).first()
f = User.query.filter_by(username=friend).first()
u.delete_friend(f)
db.session.commit()
return succes()
api.add_resource(UserListApi, '/api/user', endpoint='users')
api.add_resource(AddFriend,
'/api/user/<string:username>/<string:friend>/',
endpoint='add')
api.add_resource(UserApi, '/api/user/<string:username>', endpoint='user')
api.add_resource(RoomApi, '/api/room', endpoint='rooms')
api.add_resource(MessageListAPI, '/api/message', endpoint='messages')
api.add_resource(MessageAPI, '/api/message/<int:id>', endpoint='message')
from app import api from app.ressources import TextEditApi, TextListApi, SummaryListApi, DocumentListApi api.add_resource(TextEditApi, '/text') api.add_resource(TextListApi, '/text/<string:document_id>') api.add_resource(SummaryListApi, '/summary/<string:document_id>') api.add_resource(DocumentListApi, '/document')
def full_get(self, people):
return people
@marshal_with(restricted_member_fields)
def restricted_get(self, people):
return people
def get(self):
people = db.session.query(models.Member) \
.join(models.Member.user) \
.filter(models.Member.cycle != 0) \
.order_by(models.Member.cycle.desc()) \
.order_by(models.User.nickname).all()
for person in people:
if person.stem_department:
person.stem_dept = person.stem_department.name
if person.department:
person.dept = person.department.name
if not current_user.is_anonymous() and current_user.member:
return self.full_get(people)
return self.restricted_get(people)
api.add_resource(Members, '/people')
api.add_resource(WritePost, '/post/write')
api.add_resource(ModifyPost, '/post/<int:id>/modify')
api.add_resource(DeletePost, '/post/<int:id>/delete')
api.add_resource(Comment, '/post/comment', '/post/comment/<int:id>')
api.add_resource(IdCheck, '/member/register/idcheck')
data = request.get_json()['params']
data.pop('id')
if 'user_role' in data:
data.pop('user_role')
ret = db.session.query(User).filter_by(id=id).update(data)
db.session.commit()
return json.dumps({'errcode': 0})
class EditRoleUser(Resource):
decorators = [auth.login_required]
def put(self, id):
data = request.get_json()['params']
Role_data = []
user = User.query.filter_by(id=int(id)).first()
for i in data:
Role_data.append(Role.query.filter_by(id=int(i)).first())
user.roles = Role_data
db.session.commit()
return json.dumps({'errcode': 0})
api.add_resource(UserListAPI, '/devops/api/v1.0/user', endpoint='user')
api.add_resource(UserAPI,
'/devops/api/v1.0/user/<int:id>',
endpoint='useredit')
api.add_resource(EditRoleUser,
'/devops/api/v1.0/editRoleUser/<int:id>',
endpoint='editRoleUser')
from app import app, api
from app.database import db_session
from app.models import *
from app.utils import APIResponse
from app.controllers.api import *
#@app.route('/api/blogs', methods=['GET'])
#def get_all_blogs():
# response = APIResponse(None)
# return response.get_response(200, [{'test': 'foo bar'}])
api.add_resource(BlogListAPI, '/api/blogs')
data = request.get_json()['params']
rows = [data]
db.session.execute(Product.__table__.insert(), rows)
db.session.commit()
return json.dumps({'code': 0, 'msg': '添加成功'})
class ProductAPI(Resource):
decorators = [auth.login_required]
def delete(self, id):
obj = Product.query.filter_by(id=int(id)).first()
db.session.delete(obj)
db.session.commit()
return jsonify({'code': 0, 'msg': '成功'})
def put(self, id):
data = request.get_json()['params']
data.pop('id')
ret = db.session.query(Product).filter_by(id=id).update(data)
db.session.commit()
return jsonify({'code': 0, 'msg': '更新成功'})
api.add_resource(ProductListAPI,
'/devops/api/v1.0/product',
endpoint='product')
api.add_resource(ProductAPI,
'/devops/api/v1.0/product/<int:id>',
endpoint='productedit')
class Inflate(Resource):
def get(self, url_hash):
id = Base62().decode(url_hash=url_hash)
url_in_db = UrlInfo.query.filter_by(id=id).first()
if not url_in_db:
return 'not valid url'
else:
response = {}
hourly_hits = {}
# raw mysql query to get hourly info
result = db.engine.execute(
"SELECT DAY(visit_time), MONTH(visit_time), YEAR(visit_time), HOUR(visit_time), COUNT(*) " +
"FROM url_hits WHERE url_hash=%s GROUP BY HOUR(visit_time)" % url_in_db.url_hash)
total_hits = 0
for row in result:
hourly_hits.update({
'-'.join(map(str, row[0:3])) + 'T' + str(row[3]): row[4]
})
total_hits += row[4]
return response.update({'total_hits': total_hits}) or response.update({'hourly_hits': hourly_hits})\
or response
api.add_resource(UrlShorten, '/urls/url_shorten', endpoint='url_shorten')
api.add_resource(UrlSimilar, '/urls/url_similar', endpoint='url_similar')
api.add_resource(Inflate, '/inflate/<string:url_hash>', endpoint='inflate')
from flask_restful import Resource
from flask import request
from app import api
from app.amqpclient.amqp_consumer import data_amqpconsumer
from app.mqttclient.mqtt_producer import producer_data
class PikaOut(Resource):
def get(self):
return {"mqtt_consumer": data_amqpconsumer}, 200
api.add_resource(PikaOut, '/api/robot/all')
class MqttProducer(Resource):
def get(self):
return {"producer_data": producer_data}, 200
api.add_resource(MqttProducer, '/api/robot/producer')
:return: result of insert into DB
"""
args = measurement_parser.parse_args()
logger.debug('Search.post(id={}) with args: {}'.format(id, args))
new_measurement = models.Measurement(search_id=id,
heading=float(args.heading),
strength=int(args.strength),
timestamp=datetime.strptime(args.timestamp, '%Y-%m-%d %H:%M'),
latitude=float(args.latitude),
longitude=float(args.longitude),
user_id=current_user.get_id())
db.session.add(new_measurement)
db.session.commit()
return redirect(url_for('web_app', search=args.search))
api.add_resource(User, '/users')
api.add_resource(SearchList, '/searches')
api.add_resource(Search, '/searches/<id>')
@app.route('/login')
def login():
"""
Login page
"""
logger.debug('login()')
return render_template('login.html', user=None)
@app.route('/')
@login_required
def put(self, task_id):
task = Tasks.query.get(task_id)
task.name = request.json.get('name')
task.description = request.json.get('description')
task.is_done = request.json.get('is_done')
task.category = request.json.get('category')
task.priority = request.json.get('priority')
db.session.commit()
return {'task': task.to_json()}
def delete(self, task_id):
task = Tasks.query.get(task_id)
db.session.delete(task)
db.session.commit()
return {'result': True}
class TaskApi(Resource):
decorators = [auth.login_required]
def get(self, user_id):
tasks = Tasks.query.filter_by(user_id=user_id).all()
return {'tasks': [task.to_json() for task in tasks]}
api.add_resource(TaskListApi, '/todo/api/tasks', endpoint='get_tasks')
api.add_resource(TaskListApi, '/todo/api/tasks/<int:task_id>', endpoint='update_task')
api.add_resource(TaskListApi, '/todo/api/tasks/<int:task_id>', endpoint='delete_task')
api.add_resource(TaskApi, '/todo/api/tasks/<int:user_id>', endpoint='get_user_tasks')
db.session.commit()
return 201
except IntegrityError:
abort(400, message="User {} already exists".format(args['username']))
def delete(self, username):
args = self.parser.parse_args()
try:
user = models.User.query.get(username)
db.session.delete(user)
db.session.commit()
return 201
except UnmappedInstanceError:
abort(400, message="User {} does not exist".format('username'))
api.add_resource(User, '/u/<string:username>')
### User - owns - Project ###
class Ownership(restful.Resource):
def get(self, username):
projects = models.Project.query.filter_by(owner_id=username).all()
return jsonify({ 'projects' : [p.serialize() for p in projects] })
api.add_resource(Ownership, '/u/<string:username>/owned')
### User - is in task comprised by - Project ###
class UserInvolvement(restful.Resource):
def get(self, username):
user = models.User.query.get(username)
from app import api from app.resources.login import LoginResource from app.resources.account import AccountResource from app.resources.lists import ListsResource from app.resources.lists import ListIdResource from app.resources.todos import TodosResource from app.resources.todos import TodosIdResource # Account api.add_resource(AccountResource, '/account') # Login api.add_resource(LoginResource, '/login') # Todos app api.add_resource(ListsResource, '/lists') api.add_resource(ListIdResource, '/lists/<int:id_list>') api.add_resource(TodosResource, '/lists/todos/<int:id_list>') api.add_resource(TodosIdResource, '/lists/todos/<int:id_list>/<int:id_todo>')
class Auth(Resource):
def post(self):
""" Authentication endpoint
Args:
uid (str) : user id
password (str) : user password
Returns:
str: access token if login details are correct, otherwise
returns an error message
"""
args = usr_parser.parse_args()
user = User.query.get(args['uid'])
if user and sha256.verify(args['password'], user.password):
return {'access_token': create_jwt(identity=user.id)}, 200
return { "message" : "Login details are incorrect" }, 401
api.add_resource(Auth, '/auth')
@jwt.expired_token_loader
def expired_token():
return jsonify({ "message":"Access token has expired" }), 401
@jwt.invalid_token_loader
def invalid_token(error_msg):
return jsonify({ "message":"Access token is invalid" }), 401
@jwt.unauthorized_loader
def unauthorized_token(error_msg):
return jsonify({ "message":"Access token is invalid" }), 401
roles = 'user'
return {'roles': roles}
def post(self):
ls = login_schema.LoginSchema()
validate = ls.validate(request.json)
if validate:
return make_response(jsonify({'message': validate}), 401)
else:
apelido = request.json['apelido']
senha = request.json['senha']
usuario_db = usuario_service.listar_usuario_apelido(
apelido=apelido)
user_validate = usuario_db is None or usuario_db.is_active is False or not usuario_db.ver_senha(
senha=senha)
if user_validate:
return make_response(jsonify({'message': 'usuario não entrado ou não está ativo.'}), 403)
token_access = create_access_token(identity=usuario_db.email,
expires_delta=datetime.timedelta(seconds=60))
return make_response(jsonify({'message': 'login efetuado com sucesso',
'token_access': token_access}), 200)
api.add_resource(LoginList, '/login')
t = arrow.get(request.json['jgsj']).replace(hours=-8).to('local')
hbc = Hbc(date=t.format('YYYY-MM-DD'),
jgsj=t.datetime,
hphm=request.json['hphm'],
kkdd_id=request.json['kkdd_id'],
hpys_id=request.json['hpys_id'],
fxbh_id=request.json['fxbh_id'],
cdbh=request.json['cdbh'],
imgurl=request.json['imgurl'],
imgpath=request.json.get('imgpath', ''),
banned=0)
db.session.add(hbc)
db.session.commit()
result = row2dict(hbc)
result['jgsj'] = str(result['jgsj'])
del result['date']
return result, 201
api.add_resource(Index, '/')
api.add_resource(User, '/user/<int:user_id>')
api.add_resource(UserList, '/user')
api.add_resource(ScopeList, '/scope')
api.add_resource(TokenList, '/token')
api.add_resource(HbcImg, '/hbcimg/<string:date>/<string:hphm>/<string:kkdd>')
api.add_resource(HbcApi, '/hbc/<string:jgsj>/<string:hphm>/<string:kkdd>')
api.add_resource(HbcList, '/hbc')
from app import app, api
from flask import send_from_directory
from .ping import Ping
#
# FRONTEND
#
@app.route('/', methods=['GET'])
def index():
return app.send_static_file('index.html')
@app.route('/assets/<path:path>')
def static_dist(path):
return send_from_directory('../public/assets', path)
#
# API
#
api.add_resource(Ping, '/api/ping')
from app import app, db, lm, api
from flask.ext.login import login_user, logout_user, current_user, login_required
from flask import render_template, flash, redirect, session, url_for, request, g
from flask_restful import Api
from .models import Admin, Team
from .api import CreateTeam
from .forms import TeamLoginForm
@lm.user_loader
def load_Team(id):
return Team.query.get(int(id))
@app.route('/')
def index():
return "Hello World"
@app.route('/login', methods=['GET', 'POST'])
def login():
form = TeamLoginForm()
return render_template('login.html', title='Sign In', form=form)
"""
@app.route('/sponsors')
@app.route('/rules')
"""
api.add_resource(CreateTeam, '/CreateTeam')
return send_from_directory('client/', 'index.html')
@app.route('/<path:path>')
def serve_web_client(path):
return send_from_directory('client', path)
@app.route('/store/<path:path>')
def serve_stores(path):
return send_from_directory('store', path)
############ API ###############
api.add_resource(WebsiteController, '/website', '/website/<string:id>')
api.add_resource(CookieController, '/cookie', '/cookie/<string:id>')
api.add_resource(PageController, '/page/<string:id>')
api.add_resource(PageScreenshotController, '/page_screenshot/<string:id>')
api.add_resource(FormController, '/form/<string:id>')
api.add_resource(FieldController, '/field/<string:id>')
api.add_resource(TestController, '/test', '/test/<string:form_id>')
api.add_resource(SQLiController, '/sql')
api.add_resource(AutoSQLAttack, '/autosqlattack')
return "Hello"
@app.route('/ESP', methods = ['GET','POST'])
def func():
if request.method == 'GET':
power = request.args.get('power','')
IP = request.environ['REMOTE_ADDR']
Device = models.Device.query.filter_by(device_ip = IP).first()
if not Device:
temp = models.Device(device_ip = IP)
db.session.add(temp)
db.session.commit()
tempreading = models.Reading(Power = int(power))
Readings = temp.readings
Readings.append(tempreading)
db.session.add(temp )
db.session.commit()
else:
temp = models.Reading(Power = int(power))
Readings = Device.readings
Readings.append(temp)
db.session.add(Device)
db.session.commit()
return "Added device."
@app.route('/chart')
def chart():
return render_template('live-server.html')
api.add_resource(ReadingList,'/list')
from app import api
from app.resources.login import LoginResource
from app.resources.account import AccountResource
from app.resources.todo_list import TodoListResource, TodoListByIdResource
from app.resources.todo import TodoResource, TodoByIdResource
# Account
api.add_resource(AccountResource, '/account')
# Login
api.add_resource(LoginResource, '/login')
# Todo lists
api.add_resource(TodoListResource, '/lists')
api.add_resource(TodoListByIdResource, '/lists/<string:list_id>')
# Todo
api.add_resource(TodoResource, '/lists/todos/<string:list_id>')
api.add_resource(TodoByIdResource,
'/lists/todos/<string:list_id>/<string:todo_id>')
print "Retrieved inventory data"
shared_json = get_shared_inventory(encoded_key)
print "Retrieved shared data"
bank_json = get_bank(encoded_key)
print "Retrieved bank data"
materials_json = get_materials(encoded_key)
print "Retrieved materials data"
exists = models.db.session.query(models.Snapshot.api_key).filter_by(
api_key=api_key).scalar() is not None
if exists:
snapshot = models.Snapshot.query.filter_by(api_key=api_key).first_or_404()
snapshot.inventory = inventory_json
snapshot.materials = materials_json
snapshot.bank = bank_json
snapshot.shared = shared_json
snapshot.wallet = wallet_json
models.db.session.commit()
else:
snapshot = models.Snapshot(api_key, inventory_json, materials_json, bank_json, shared_json, wallet_json)
models.db.session.add(snapshot)
models.db.session.commit()
models.db.session.close()
print "Snapshot added to database"
session['wallet'] = wallet_json
return api_key
api.add_resource(Snapshot, '/snapshot')
from app import api from app.resources.helloworld import HelloWorldResource, HelloWorldResourceNameToken, HelloWorldResourceNameURL, HelloWorldResourceNames from app.resources.login import LoginResource from app.resources.todos import TodoManagementResource, TodoManagementResourceByID # Hello World api.add_resource(HelloWorldResource, '/api/helloworld') api.add_resource(HelloWorldResourceNameToken, '/api/hello') api.add_resource(HelloWorldResourceNameURL, '/api/hello/<string:name>') api.add_resource(HelloWorldResourceNames, '/api/hello/<int:count>') # Login api.add_resource(LoginResource, '/api/login') # Todos app api.add_resource(TodoManagementResource, '/api/todos') api.add_resource(TodoManagementResourceByID, '/api/todos/<int:todo_id>')
'Connection': 'keep-alive',
'Accept': '*/*',
'User-Agent': 'Entplus/1.3.3 (iPhone; iOS 8.0.2; Scale/2.00)',
'Accept-Language': 'en;q=1, zh-Hans;q=0.9',
'Accept-Encoding': 'gzip, deflate',
'Cookie': 'JSESSIONID=5F1F6254655B935D851FD6F5F299EDB1'
# 'Cookie': 'JSESSIONID=6E7A6C44444C635CE411B9BAD407D446'
}
def grab(self):
return self.post_fnc(self.url, self.data, self.headers)
def post_fnc(self, url, data, headers):
# time.sleep(random.randint(10, 20))
data = urllib.urlencode(data)
req = urllib2.Request(url, data, headers)
response = urllib2.urlopen(req)
return json.loads(response.read())
class GrabEnterprise(Resource):
def get(self, lcid):
url = '/company/fQyMaininvestList'
return GrabClawer(url, lcid).grab()
api.add_resource(GrabEntListAPI, '%s/searchqy' % app.config["API_URI"])
api.add_resource(GrabQy, '%s/grab/<lcid>' % app.config["API_URI"])
api.add_resource(GrabAllQy, '%s/grab' % app.config["API_URI"])
api.add_resource(GrabEnterprise, '%s/grabenterprise/<lcid>' % app.config["API_URI"])
api.add_resource(GrabAllQyByName, '%s/graballqybyname' % app.config["API_URI"])
@isAdmin
def put(self, recursoId):
pass
@isAuth
@isAdmin
def delete(self, recursoId):
userId = localStorage['payload']['sub']
if not recursoId:
abort(400, message='Bad Request')
try:
pm = Perms.query.filter_by(userId=userId,
recursoId=recursoId).first()
except Exception as e:
abort(500, message=f'Error {e}')
if not pm:
abort(404, message='No existen permisos previos')
try:
db.session.delete(pm)
db.session.commit()
except Exception as e:
abort(500, message=f'Error {e}')
return {'message': 'Success!'}
api.add_resource(HelloWorld, '/')
api.add_resource(UserR, '/user/<string:userId>', '/user')
api.add_resource(LoginR, '/login')
api.add_resource(RecursoR, '/recurso/<string:recursoId>', '/recurso')
api.add_resource(PermsR, '/perms/<string:recursoId>', '/perms')
@app.route('/')
def index():
#api_manager.create_api(tweets,methods=['GET','POST'])
return app.send_static_file('index.html')
# Creating web service for getting the list of posts.
class PostList(Resource):
@marshal_with(PL_fields.posts_fields)
def get(self):
posts = SL_impl.get_all_posts()
return posts
api.add_resource(PostList, '/twitter/api/v1.0/posts', endpoint = 'posts')
# Creating a web service to get the table headers of the Post table
class PostListHeader(Resource):
def get(self):
postHeaders = SL_impl.get_Post_table_headers()
print "printing post headers"
return postHeaders
api.add_resource(PostListHeader, '/twitter/api/v1.0/postsheaders', endpoint = 'postsheaders')
# Creating web service for getting the list of posts.
class CommentList(Resource):
class UsuarioConfirm(Resource):
def get(self, usuario_id):
usuario_db = usuario_service.listar_usuario_id(usuario_id)
if usuario_db is None:
return make_response(jsonify({'message': 'user not found.'}), 404)
else:
try:
if usuario_db.is_active:
return make_response(jsonify({'message': f'usuario id {usuario_id} cadastro já confirmado.'}), 200)
usuario_service.ativar_usuario(usuario_db)
headers = {'Content-Type': 'text/html'}
return make_response(render_template('confirmacao_usuario.html', usuario=usuario_db.apelido), 200,
headers)
except Exception as e:
return make_response(
jsonify(
{'message': f'{str(e)}'}
),
500
)
api.add_resource(UsuarioList, '/usuario')
api.add_resource(UsuarioDetail, '/usuario/<int:usuario_id>')
api.add_resource(UsuarioConfirm, '/confirma_cadastro/<int:usuario_id>')
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Date : 17/2/16 PM4:02
# Copyright: TradeShift.com
__author__ = 'liming'
from app import app, api
import resource
RESOURCES = [
(resource.tag_submit, '/tag/submit'),
(resource.tag_list, '/tag/list/<string:project>/<string:domain>/<string:role>/<string:branch>'),
(resource.tag_url, '/tag/url/<string:project>/<string:domain>/<string:role>/<string:branch>/<string:tag>'),
(resource.branch_list, '/branch/<string:project>/<string:domain>/<string:role>')
]
for res, uri in RESOURCES:
api.add_resource(res, uri)
asset = AssetModel(
name=json['name'],
description=json['description'],
manufacturer_id=json['manufacturer'],
min_quantity=json['min_quantity'],
image=json['image'],
max_quantity=json['max_quantity']
)
asset.manufacturer = Manufacturer().find(id=json['manufacturer'])
asset.save()
model = {
'department': {
'id': asset.id,
'name': asset.name,
'description': asset.description,
'manufacturer': asset.manufacturer_id,
'min_quantity': asset.min_quantity,
'max_quantity': asset.max_quantity,
'image': asset.image,
'requires_approval': 'true' if asset.requires_approval else 'false'
}
}
print model
return jsonify(model), 201
api.add_resource(AssetList, '/api/assets')
asset = AssetModel(
name=json['name'],
description=json['description'],
manufacturer_id=json['manufacturer'],
min_quantity=json['min_quantity'],
image=json['image'],
max_quantity=json['max_quantity']
)
asset.manufacturer = Manufacturer().find(id=json['manufacturer'])
asset.save()
model = {
'department': {
'id': asset.id,
'name': asset.name,
'description': asset.description,
'manufacturer': asset.manufacturer_id,
'min_quantity': asset.min_quantity,
'max_quantity': asset.max_quantity,
'image': asset.image,
'requires_approval': 'true' if asset.requires_approval else 'false'
}
}
print model
return jsonify(model), 201
api.add_resource(Asset, '/api/assets/<int:id>')
# curl -X POST -d '{"phrase": "immigration", "frame": 1}' http://localhost:5000/api/analyses/ -H "Content-Type: application/json"
@marshal_with(analysis_marshall)
def get(self, id):
"""
Return percent complete (meta).
Return either empty json or completed frame and topic plot (text).
"""
analysis_obj = Analysis.get(Analysis.id == id)
info = analysis_obj.check_if_complete()
data = get_dictionary_from_model(analysis_obj)
data['topic_plot'] = eval(
data['topic_plot']) if data['topic_plot'] else None
data['frame_plot'] = eval(
data['frame_plot']) if data['frame_plot'] else None
data['wordcount_plot'] = eval(
data['wordcount_plot']) if data['wordcount_plot'] else None
return {'meta': info, 'data': data}
def put(self, id):
"""Update analysis in persistant storage"""
pass
api.add_resource(AnalysisListController, '/api/analyses/', endpoint='analyses')
api.add_resource(AnalysisController,
'/api/analyses/<int:id>/',
endpoint='analysis')
