class OrderCollectionResource(Resource):
decorators = [auth.login_required]
@marshal_with(order_list_fields)
def get(self, enter_id=None, monitor_id=None):
parser = reqparse.RequestParser()
parser.add_argument('currentPage', type=int, default=1)
parser.add_argument('pageSize', type=int, default=20)
parser.add_argument('enterId', default=enter_id)
parser.add_argument('monitorId', default=monitor_id)
parser.add_argument('state', type=str, default='')
args = parser.parse_args()
current_page = args.pop('currentPage')
page_size = args.pop('pageSize')
if args['enterId']:
query = Enter.query.get_or_abort(args.pop('enterId')).orders
elif args['monitorId']:
query = Monitor.query.get_or_abort(args.pop('monitorId')).orders
else:
query = Order.query.filter_by_user()
return query.filter_by_state(args.pop('state')) \
.filter_by_args(args) \
.paginate(current_page, page_size, False)
api.add_resource(OrderResource, '/orders/<int:order_id>', '/processes/<int:process_id>/order')
api.add_resource(OrderCollectionResource, '/orders', '/enters/<int:enter_id>/orders',
'/monitors/<int:monitor_id>/orders')
Date: 2018/6/2
"""
from flask_restful import Resource
from app.api import api
from app.models.admin.config import FConfig, config_parse
from lib.principal.auth import admin_authority, auth_token
from flask_login import login_required
from lib.code import Msg
from datetime import datetime
from flask import g
class CrudConfig(Resource):
@auth_token
@admin_authority
def post(self):
arg = config_parse.parse_args()
config = FConfig.query_one(server_name=arg['server_name'])
if config:
arg['update_time'] = datetime.now()
config.update(**arg)
arg['update_time'] = str(config.update_time)
arg['create_time'] = str(config.create_time)
return Msg.success('ok', config=arg)
else:
FConfig.create(**arg)
return Msg.success('ok', config=arg)
api.add_resource(CrudConfig, '/config', endpoint='config')
teams.append(team)
return {'success': teams}
class AllPlayers(Resource):
"""AllPlayers Class is the Resource for fetching all players in the elastic
search index
:extends Resource
:returns: a JSON response
"""
@api_response
def get(self):
query = {"query": {"match_all": {}}}
resp = requests.post(elasticsearch_url + 'nba_players/_search',
json=query)
data = resp.json()
teams = []
for hit in data['hits']['hits']:
team = hit['_source']
team['id'] = hit['_id']
teams.append(team)
return {'success': teams}
# Add resource endpoints here =================================================
api.add_resource(Player, '/player/search')
api.add_resource(AllPlayers, '/players')
topic.followers_count += 1
print topic.followers_count
db.session.commit()
except:
db.session.rollback()
return abort(500, message='operation failed')
return topic
def delete(self, name):
topic = None
if not current_user.is_authenticated:
return abort(401, message='permission denied')
for topic in current_user.following_topics:
if topic.name == name:
break
else:
return abort(400, message='topic not found')
try:
current_user.following_topics.remove(topic)
if topic.followers_count > 0:
topic.followers_count -= 1
db.session.commit()
except:
db.session.rollback()
return abort(500, message='operation failed')
api.add_resource(UserTopics,
'/api/user/topics/<string:name>',
endpoint='api.user_topics')
}
class CtlUser(Resource):
@marshal_with(user_fields)
def get(self, uid=None):
arg = user_get_parser.parse_args()
id = arg.get('uid')
user = User.get_by_id(id)
return user
@marshal_with(user_fields)
def post(self):
arg = user_parser.parse_args()
user = User.create(**arg)
use_folder = user.use_folder
os.mkdir(os.path.join(UPLOAD_PATH, use_folder))
return user
class UpdateUser(Resource):
@marshal_with(user_fields)
def post(self):
arg = user_parser.parse_args()
user = User.update(**arg)
return user
api.add_resource(HelloWorld, '/hello', endpoint='hello')
api.add_resource(CtlUser, '/user', endpoint='user')
from app.api import api
from app.main.resources import UserListResource
from app.climbing.resources import (RouteResource, RouteListResource,
SessionResource)
api.add_resource(UserListResource, '/users')
api.add_resource(RouteListResource, '/routes')
api.add_resource(RouteResource, '/route/<int:route_id>')
api.add_resource(SessionResource, '/session', '/session/<int:session_id>')
application.logger.error("UnicodeError: " + str(e))
return "Bad Request", 400
except TypeError as e:
application.logger.error("TypeError: " + str(e))
return "Bad Request", 400
except KeyError as e:
application.logger.error("KeyError: " + str(e))
return "Bad Request", 400
except Exception as e:
application.logger.error("Unknow Exception: " + str(e))
return "Bad Request", 400
return save_events(events)
api.add_resource(ReadEventsFromArgument, "/api/events")
@application.route("/events", methods=["POST"])
@auth.login_required
def save_events_from_file():
"""
Api method to receive the events from all the devices
:return: HTML answer
"""
try:
f = request.files["uploaded_file"]
# Uncompress Gzip file
u = gzip.open(f, "rb")
class LicenseFactorCollectionResource(Resource):
decorators = [auth.login_required]
@marshal_with(license_factor_list_fields)
def get(self, license_id=None):
parser = reqparse.RequestParser()
parser.add_argument('currentPage', type=int, default=1)
parser.add_argument('pageSize', type=int, default=20)
parser.add_argument('licenseId', default=license_id)
args = parser.parse_args()
current_page = args.pop('currentPage')
page_size = args.pop('pageSize')
if args['licenseId']:
query = License.query.get_or_abort(
args.pop('licenseId')).licenseFactors
else:
query = LicenseFactor.query
return query.filter_by_args(args) \
.paginate(current_page, page_size, False)
api.add_resource(LicenseResource, '/licenses/<int:license_id>',
'/licenseFactors/<int:factor_id>/license')
api.add_resource(LicenseCollectionResource, '/licenses',
'/enters/<int:enter_id>/licenses')
api.add_resource(LicenseFactorResource, '/licenseFactors/<int:factor_id>')
api.add_resource(LicenseFactorCollectionResource, '/licenseFactors',
'/licenses/<int:license_id>/licenseFactors')
@auth_token
def post(self):
arg = self.parse.parse_args()
folder = DiskFolder.get_by_id(arg['id'])
if folder:
print(arg)
folder.update(**arg)
return Msg.success('ok')
else:
return Msg.failed_dict(1002)
class DeleteFolder(Resource):
parse = reqparse.RequestParser()
parse.add_argument('id', type=int, required=True)
@auth_token
def post(self):
arg = self.parse.parse_args()
folder = DiskFolder.get_by_id(**arg)
if folder:
folder.delete()
return Msg.success('ok')
else:
return Msg.failed_dict(1002)
api.add_resource(CreateFolder, '/folder/add', endpoint='c_folder')
api.add_resource(UpdateFolder, '/folder/update', endpoint='u_folder')
api.add_resource(DeleteFolder, '/folder/delete', endpoint='d_folder')
user_fields = {
'username': fields.String,
'email': fields.String,
}
class UserResource(Resource):
# @marshal_with(user_fields)
def get(self, username=None):
user = User.query.filter_by(username=username).first()
if user is None:
raise NotFoundError(
message="not found username like '{0}'".format(username))
return user.to_dict()
class UserCollectionResource(Resource):
def get(self):
users = [item.to_dict() for item in User.query.all()]
return {'data': users}
@marshal_with(user_fields)
def post(self):
user = User.create(**user_parser.parse_args())
return user, 201
api.add_resource(UserResource, '/users/<username>')
api.add_resource(UserCollectionResource, '/users')
parser.add_argument('pageSize', type=int, default=20)
parser.add_argument('enterId', default=enter_id)
parser.add_argument('dischargeId', default=discharge_id)
parser.add_argument('enterName', default=None)
parser.add_argument('areaCode', default=None)
parser.add_argument('monitorType', default=None)
parser.add_argument('state', type=str, default='')
args = parser.parse_args()
current_page = args.pop('currentPage')
page_size = args.pop('pageSize')
if args['enterId']:
query = Enter.query.get_or_abort(args.pop('enterId')).monitors
elif args['dischargeId']:
query = Discharge.query.get_or_abort(
args.pop('dischargeId')).monitors
else:
query = Monitor.query.filter_by_user()
return query.filter_by_state(args.pop('state')) \
.filter_by_args(args) \
.paginate(current_page, page_size, False)
api.add_resource(MonitorResource, '/monitors/<int:monitor_id>',
'/orders/<int:order_id>/monitor',
'/reports/<int:report_id>/monitor',
'/dischargeReports/<int:discharge_report_id>/monitor',
'/factorReports/<int:factor_report_id>/monitor')
api.add_resource(MonitorCollectionResource, '/monitors',
'/enters/<int:enter_id>/monitors',
'/discharges/<int:discharge_id>/monitors')
return DischargeReport.query.get_or_abort(discharge_report_id).discharge
elif factor_report_id:
return FactorReport.query.get_or_abort(factor_report_id).discharge
class DischargeCollectionResource(Resource):
decorators = [auth.login_required]
@marshal_with(discharge_list_fields)
def get(self, enter_id=None):
parser = reqparse.RequestParser()
parser.add_argument('currentPage', type=int, default=1)
parser.add_argument('pageSize', type=int, default=20)
parser.add_argument('enterId', default=enter_id)
parser.add_argument('dischargeType', default=None)
args = parser.parse_args()
current_page = args.pop('currentPage')
page_size = args.pop('pageSize')
if args['enterId']:
query = Enter.query.get_or_abort(args.pop('enterId')).discharges
else:
query = Discharge.query.filter_by_user()
return query.filter_by_args(args) \
.paginate(current_page, page_size, False)
api.add_resource(DischargeResource, '/discharges/<int:discharge_id>', '/monitors/<int:monitor_id>/discharge',
'/reports/<int:report_id>/discharge', '/dischargeReports/<int:discharge_report_id>/discharge',
'/factorReports/<int:factor_report_id>/discharge')
api.add_resource(DischargeCollectionResource, '/discharges', '/enters/<int:enter_id>/discharges')
from app.api import api
from app.api.api_classes import *
""" Applications """
api.add_resource(Applications, '/applications')
api.add_resource(ApplicationSingle, '/applications/<application_id>')
api.add_resource(ApplicationSingleCargos,
'/applications/<application_id>/cargos')
api.add_resource(ApplicationSingleDrivers,
'/applications/<application_id>/drivers')
api.add_resource(ApplicationSingleCars, '/applications/<application_id>/cars')
api.add_resource(ApplicationSingleDriverSingle,
'/applications/<application_id>/drivers/<driver_id>')
api.add_resource(ApplicationSingleCarSingle,
'/applications/<application_id>/cars/<car_id>')
""" Drivers """
api.add_resource(Drivers, '/drivers')
api.add_resource(DriverSingle, '/drivers/<driver_id>')
api.add_resource(DriversService, '/drivers/<driver_id>/service')
api.add_resource(DriversApplications, '/drivers/<driver_id>/applications')
""" Cars """
api.add_resource(Cars, '/cars')
api.add_resource(CarSingle, '/cars/<car_id>')
api.add_resource(CarsService, '/cars/<car_id>/service')
api.add_resource(CarsApplications, '/cars/<car_id>/applications')
""" Clients """
api.add_resource(Clients, '/clients')
api.add_resource(ClientSingle, '/clients/<client_id>')
@auth_token
def post(self):
arg = self.parse.parse_args()
file = DiskFile.query_one(id=arg['id'], user_id=g.user.id)
if file:
file.update(**arg)
return Msg.success('ok')
else:
return Msg.failed_dict(1002)
# 此处删除为逻辑删除
class DeleteFile(Resource):
parse = reqparse.RequestParser()
parse.add_argument('id', type=int, required=True)
@auth_token
def post(self):
arg = self.parse.parse_args()
file = DiskFile.query_one(id=arg['id'], user_id=g.user.id)
if file:
file.update(id=arg['id'], is_trash=1)
return Msg.success('ok')
else:
return Msg.failed_dict(1002)
api.add_resource(CreateFile, '/file/add', endpoint='c_file')
api.add_resource(UpdateFile, '/file/update', endpoint='u_file')
api.add_resource(DeleteFile, '/file/delete', endpoint='d_file')
class BackupFiles(Resource):
folder_parse = reqparse.RequestParser()
# folder_parse.add_argument('event', required=True, type=str)
folder_parse.add_argument('file_data',
required=True,
type=FileStorage,
location='files')
folder_parse.add_argument('show_name', required=True, type=int)
folder_parse.add_argument('file_name', required=True, type=int)
folder_parse.add_argument('file_size', required=True, type=str)
folder_parse.add_argument('user_id', required=True, type=str)
folder_parse.add_argument('is_share', required=True, type=str)
@admin_authority
@auth_token
def post(self):
arg = self.folder_parse.parse_args()
ad_config = FConfig.query_one(server_name=SERVER_NAME)
backup_base_path = ad_config.backup_base_path
path = os.path.join(backup_base_path, arg['file_name'])
file = arg['file_data']
file.save(path)
arg['path'] = path
arg.pop('file_data')
Backup.create(**arg)
return Msg.success('ok', filename=arg['file_name'])
api.add_resource(BackupFiles, '/backup', endpoint='backup')
db.session.flush()
if files:
for file in files:
file_args = save_file(file)
file_args['fileModelId'] = report.reportId
file_args['fileModel'] = app.app.config[
'FACTOR_REPORT_FILE_MODEL']
file_args['fileType'] = app.app.config[
'FACTOR_REPORT_FILE_TYPE']
attachment = Attachment(**file_args)
db.session.add(attachment)
db.session.commit()
return {'success': True, 'message': '提交成功'}
api.add_resource(ReportResource, '/reports/<int:report_id>')
api.add_resource(ReportCollectionResource, '/reports',
'/enters/<int:enter_id>/reports',
'/discharges/<int:discharge_id>/reports',
'/monitors/<int:monitor_id>/reports')
api.add_resource(LongStopReportResource, '/longStopReports/<int:report_id>')
api.add_resource(LongStopReportCollectionResource, '/longStopReports',
'/enters/<int:enter_id>/longStopReports')
api.add_resource(DischargeReportResource, '/dischargeReports/<int:report_id>')
api.add_resource(DischargeReportCollectionResource, '/dischargeReports',
'/enters/<int:enter_id>/dischargeReports',
'/discharges/<int:discharge_id>/dischargeReports',
'/monitors/<int:monitor_id>/dischargeReports')
api.add_resource(FactorReportResource, '/factorReports/<int:report_id>')
api.add_resource(FactorReportCollectionResource, '/factorReports',
'/enters/<int:enter_id>/factorReports',
from flask_restful import reqparse, Resource
from app.api import api
from workers.worker1 import printNumbers
from random import randint
parser = reqparse.RequestParser()
parser.add_argument('url')
class UrlsResource(Resource):
def post(self):
args = parser.parse_args()
#add celery job here
printNumbers.delay()
#for now make dummy response with post url parameters
response = {
'job_id' : randint(0,1000),
'status' : "queued",
'description' : 'Your crawling reuest for url ' + args.url + 'is accpeted',
}
return response,200
api.add_resource(UrlsResource, '/urls')
from app.api import (AllUsers, AllRequests, Manage, ManageRequests, UserLogin,
UserRegistration, api, app, AdminApproval,
AdminDisapprove, AdminResolve)
from flask_jwt_extended import JWTManager
app.config['JWT_SECRET_KEY'] = 'jwt-secret-string'
jwt = JWTManager(app)
api.add_resource(UserRegistration, '/auth/signup') # user registration
api.add_resource(UserLogin, '/auth/login') # user login
api.add_resource(ManageRequests, '/users/requests') # creating a request
api.add_resource(AllRequests, '/requests') # view all requests
# put and get for a single record
api.add_resource(Manage, '/users/requests/<int:id>')
# approve a request
api.add_resource(AdminApproval, '/requests/<int:id>/approve')
# disapprove a request
api.add_resource(AdminDisapprove, '/requests/<int:id>/disapprove')
# resolve approved requests
api.add_resource(AdminResolve, '/requests/<int:id>/resolve')
api.add_resource(AllUsers, '/users')
if __name__ == '__main__':
app.run(debug=True)
return abort(403, message='points are not enough')
current_user.points -= pt
s.ratings_count += 1
s.rating = (rating_sum + rating) / s.ratings_count
log = PointLog('SNIPPET_RATING', pt, user, s)
voter = Voter(user, s)
voter.value = rating
db.session.add(voter)
db.session.add(log)
db.session.add(s)
else:
s.rating = (rating_sum - voter.value + rating) / s.ratings_count
voter.value = rating
db.session.add(voter)
try:
db.session.commit()
except:
db.session.rollback()
return abort(500, message='operation failed')
result = marshal(voter, voter_fields)
result['snippet'] = marshal(s, snippet_fields)
return result
api.add_resource(Snippets,
'/api/repos/<string:username>/<string:repo>/snippets',
endpoint='api.snippets')
api.add_resource(SnippetVoters,
'/api/snippets/<string:id>/voters/<string:username>',
endpoint='api.snippet_voters')
from app.api import api from app.api.resources.ping import Ping from app.api.resources.login import Login from app.api.resources.user import User, UserList from app.api.resources.post import Post, PostList from app.api.resources.comment import Comment, CommentList from app.api.resources.info import Info api.add_resource(Ping, "/ping/") api.add_resource(Login, "/login/") # api.add_resource(UserList, "/users") api.add_resource(User, "/users/<user_id>/") api.add_resource(PostList, "/posts/") api.add_resource(Post, "/posts/<post_id>/") api.add_resource(CommentList, "/comments/") api.add_resource(Comment, "/comments/<comment_id>/") api.add_resource(Info, "/info/")
"""
CREATE: 2018/5/16
AUTHOR: HEHAHUTU
"""
from flask_restful import Resource
from app.api import api
from flask_login import login_required
from lib.code import Msg
class TaskOperation(Resource):
@login_required
def get(self):
return Msg.success('success')
api.add_resource(TaskOperation, '/task', endpoint='task')
@marshal_with(factor_list_fields)
def get(self, enter_id=None, discharge_id=None, monitor_id=None):
parser = reqparse.RequestParser()
parser.add_argument('currentPage', type=int, default=1)
parser.add_argument('pageSize', type=int, default=20)
parser.add_argument('factorCode', default=None)
parser.add_argument('enterId', default=enter_id)
parser.add_argument('dischargeId', default=discharge_id)
parser.add_argument('monitorId', default=monitor_id)
args = parser.parse_args()
current_page = args.pop('currentPage')
page_size = args.pop('pageSize')
if args['enterId']:
query = Enter.query.get_or_abort(args.pop('enterId')).factors
elif args['dischargeId']:
query = Discharge.query.get_or_abort(
args.pop('dischargeId')).factors
elif args['monitorId']:
query = Monitor.query.get_or_abort(args.pop('monitorId')).factors
else:
query = Factor.query
return query.filter_by_args(args) \
.paginate(current_page, page_size, False)
api.add_resource(FactorResource, '/factors/<int:factor_id>')
api.add_resource(FactorCollectionResource, '/factors',
'/enters/<int:enter_id>/factors',
'/discharges/<int:discharge_id>/factors',
'/monitors/<int:monitor_id>/factors')
factor_report_id=None,
process_id=None):
parser = reqparse.RequestParser()
parser.add_argument('currentPage', type=int, default=1)
parser.add_argument('pageSize', type=int, default=20)
parser.add_argument('dischargeReportId', default=discharge_report_id)
parser.add_argument('factorReportId', default=factor_report_id)
parser.add_argument('processId', default=process_id)
args = parser.parse_args()
current_page = args.pop('currentPage')
page_size = args.pop('pageSize')
if args['dischargeReportId']:
query = DischargeReport.query.get_or_abort(
args.pop('dischargeReportId')).attachments
elif args['factorReportId']:
query = FactorReport.query.get_or_abort(
args.pop('factorReportId')).attachments
elif args['processId']:
query = Process.query.get_or_abort(
args.pop('processId')).attachments
else:
query = Attachment.query
return query.paginate(current_page, page_size, False)
api.add_resource(AttachmentResource, '/attachments/<int:attachment_id>')
api.add_resource(AttachmentCollectionResource, '/attachments',
'/dischargeReports/<int:discharge_report_id>/attachments',
'/factorReports/<int:factor_report_id>/attachments',
'/processes/<int:process_id>/attachments')
from flask_restful import Resource
from app.api import api
from app.api.helpers import cityAddress
# @app.route('/city/<cityname>')
# def get_city(cityname):
# return 'User %s' % cityname
class city(Resource):
def get(self, cityname):
return cityAddress.get_address(cityname)
api.add_resource(city, '/city/<string:cityname>')
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 100)
data = Task.to_collection_dict(Task.query, page, per_page)
return data
class ApiTaskToggleDone(Resource):
"""
Defines resource class for task done
"""
def put(self, task_id):
"""
Implement PUT method
"""
task = Task.query.get(task_id)
if not task:
return error_response(404, "There is no task with this id")
if task.done:
done_task = DoneTask.query.filter_by(task_id=task_id).first()
db.session.delete(done_task)
else:
done_task = DoneTask(task_done=task)
db.session.add(done_task)
db.session.commit()
return jsonify(task.to_dict())
api.add_resource(ApiTask, '/api/tasks')
api.add_resource(ApiTaskId, '/api/tasks/<int:task_id>')
api.add_resource(ApiTaskToggleDone, '/api/tasks/<int:task_id>/toggle_done')
from flask_restful import Resource
from app.api import api
from flask_restful_swagger import swagger
class CustomersResource(Resource):
"My CUSTOMER API"
@swagger.operation(
notes='get a customer list',
nickname='get',
# Parameters can be automatically extracted from URLs (e.g. <string:id>)
# but you could also override them here, or add other parameters.
parameters=[
{
"name": "customer_id",
"description": "The ID of customer",
"required": True,
"allowMultiple": False,
"dataType": 'string',
}
])
def get(self):
customers = {
'1' : "customer 1",
'2' : "customer 2",
'3' : "customer 3",
}
return customers,200
api.add_resource(CustomersResource, '/customers')
class LoginUser(Resource):
def post(self):
arg = login_parse.parse_args()
user = User.query.filter_by(username=arg.get('username')).first()
if user:
if user.check_password(arg.get('password')):
next = request.args.get('next')
# next_is_valid should check if the user has valid
# identity_changed.send(current_app._get_current_object(), identity=Identity(user.id))
# permission to access the `next` url
if not next_is_valid(next):
return {'message': 'next url valid failed'}, 400
return Msg.success('登录成功',
assess_key=user.generate_auth_token())
else:
return Msg.login_password_error('用户名和密码不匹配')
else:
return Msg.login_username_error('用户名不存在')
class LogoutUser(Resource):
def post(self):
return Msg.success('logout success')
api.add_resource(LoginUser, '/login', endpoint='login')
api.add_resource(LogoutUser, '/logout', endpoint='logout')
"1,1452*,785*,452*,15*,23*,1*",
"50":
"1,%s,0*,%s" %
(g.user.rainEnterCount, g.user.rainDischargeCount),
"40":
"1,%s,%s,257*,%s,%s,%s,%s,%s,0*" %
(g.user.totalEnterCount, g.user.importantEnterCount,
g.user.waterEnterCount, g.user.airEnterCount,
g.user.waterAirEnterCount, g.user.waterDischargeCount,
g.user.airDischargeCount),
"30":
"1, 16*, 93.75*, 92.75*, 100*",
"20":
"1,41*, 28*, 30*",
"31":
"1, 10*, 100*, 100*, 88.89*",
"10":
"1,南昌市*,2019年08月10日 09时*,67*,良*,PM2.5 SO2*,80*,72*,12*,22*,20*,0.32*",
"21":
"1, 91.4*, 96.19*, 202*"
}
}
api.add_resource(AdminUserResource, '/admin/users/<int:id>',
'/admin/users/<string:user_name>')
api.add_resource(AdminUserCollectionResource, '/admin/users')
api.add_resource(AdminTokenResource, '/admin/token')
api.add_resource(EnterTokenResource, '/enter/token')
api.add_resource(IndexResource, '/index')
teams.append(team)
return {'success': teams}
class AllGames(Resource):
"""AllGames Class is the Resource for fetching all of the game data limited
to 100 response hits from an elasticsearch instance
:extends Resource
:returns: a JSON response
"""
@api_response
def get(self):
query = {"query": {"match_all": {}}, "size": 100}
resp = requests.post(elasticsearch_url + 'nba_games/_search',
json=query)
data = resp.json()
teams = []
for hit in data['hits']['hits']:
team = hit['_source']
team['id'] = hit['_id']
teams.append(team)
return {'success': teams}
# Add resource endpoints here =================================================
api.add_resource(Game, '/game/search')
api.add_resource(AllGames, '/games')
parser = reqparse.RequestParser()
parser.add_argument('roles')
args = parser.parse_args()
user = User.get(User.id == id)
user_roles = [role.name for role in list(user.roles.select())]
roles = args['roles'].strip(",").replace(" ", "").split(",")
for role in roles:
if role not in user_roles:
user_datastore.add_role_to_user(user, role)
for role in user_roles:
if role not in roles:
user_datastore.remove_role_from_user(user, role)
return user
@roles_required("admin")
def delete(self, id):
user = User.get(User.id == id)
user_datastore.delete_user(user)
return "Deleted"
api.add_resource(UserList, '/users/')
api.add_resource(UserDetail, '/user/<int:id>')
from app.api import api from .resources.signin import Signin from .resources.login import Login from .resources.deliveries import Deliveries from .resources.test import Test api.add_resource(Signin,'/signin',endpoint='signin') api.add_resource(Login,'/login',endpoint='login') api.add_resource(Deliveries,'/deliveries',endpoint='deliveries') api.add_resource(Test,'/')
application.logger.error("UnicodeError: " + str(e))
return "Bad Request", 400
except TypeError as e:
application.logger.error("TypeError: " + str(e))
return "Bad Request", 400
except KeyError as e:
application.logger.error("KeyError: " + str(e))
return "Bad Request", 400
except Exception as e:
application.logger.error("Unknow Exception: " + str(e))
return "Bad Request", 400
return save_events(events)
api.add_resource(ReadEventsFromArgument, "/api/events")
@application.route("/events", methods=["POST"])
@auth.login_required
def save_events_from_file():
"""
Api method to receive the events from all the devices
:return: HTML answer
"""
try:
f = request.files["uploaded_file"]
# Uncompress Gzip file
u = gzip.open(f, "rb")
from flask_restful import Resource
from app.api import api
from flask_restful_swagger import swagger
class UsersResource(Resource):
"My USER API"
@swagger.operation(
notes='get a user list',
nickname='get',
# Parameters can be automatically extracted from URLs (e.g. <string:id>)
# but you could also override them here, or add other parameters.
parameters=[
{
"name": "user_id",
"description": "The ID of user",
"required": True,
"allowMultiple": False,
"dataType": 'string',
}
])
def get(self):
users = {
'1' : "User 1",
'2' : "User 2",
'3' : "User 3",
}
return users,200
api.add_resource(UsersResource, '/users')
