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')