app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db' db = SQLAlchemy(app) # db.create_all() #Only one time #Designing Modal class VideoModel(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), nullable=False) views = db.Column(db.Integer, nullable=False) likes = db.Column(db.Integer, nullable=False) def __repr__(self): return f"Video(name = {name}, views = {views}, likes = {likes})" #Parsing request data video_put_args = reqparse.RequestParser() #returns object video_put_args.add_argument("name", type=str, help="Name of the video is required", required=True) video_put_args.add_argument("views", type=int, help="Views of the video is required", required=True) video_put_args.add_argument("likes", type=int, help="Likes on the video is required", required=True) video_update_args = reqparse.RequestParser() #returns object video_update_args.add_argument("name", type=str, help="Name of the video") video_update_args.add_argument("views", type=int, help="Views of the video") video_update_args.add_argument("likes", type=int, help="Likes on the video") resource_fields = { "id": fields.Integer, "name": fields.String, "views": fields.Integer, "likes": fields.Integer }
from flask_restful import Resource, reqparse from flask_jwt_extended import jwt_required from textanalysis.sentiments import engine as eng # parser args _text_parser = reqparse.RequestParser() _text_parser.add_argument('textBody', type=str, required=True, help="This field cannot be blank.") _text_parser.add_argument('islarge', type=str, required=True, help="This field cannot be blank.") class TextAnalysisResource(Resource): @jwt_required def get(self): data = _text_parser.parse_args() textBody = data["textBody"] if data["islarge"] == "1": response = eng.SentimentAnalysis.analzeLargeBody(textBody) return {"response": response}, 200 response = eng.SentimentAnalysis.analyzesSmallBody(textBody) return {"response": response}, 200
"num_of_steps": 1, "step": 1 }, "resource_id": "resource_id-1f178974-684d-417e-a3f4-878708b7382b", "status": "finished", "time_delta": 0.5580840110778809, "timestamp": 1525257403.6778474, "urls": { "resources": [], "status": "http://localhost:8080/resources/user/resource_id-1f178974-684d-417e-a3f4-878708b7382b" }, "user_id": "user" } recursive_parser = reqparse.RequestParser() recursive_parser.add_argument('recursive', type=bool, help='Set True to recursively remove ' 'the STRDS and all registred raster ' 'map layer', location='args') class STRDSCreationModel(Schema): """Schema for STRDS creation """ description = "Information required to create a new STRDS" type = 'object' properties = { 'title': { 'type': 'string', 'description': 'The title of the STRDS', },
class VersionChecker(Resource): api_path = "/api/v1/version_checker" query_params = "ver_1=<version_number_1>&ver_2=<version_number_2>" str_map = {-1: "before", 0: "equal to", 1: "after"} parser = reqparse.RequestParser() parser.add_argument( "ver_1", type=str, required=True, help="ver_1 (Version Number 1) is Required as query parameter", ) parser.add_argument( "ver_2", type=str, required=True, help="ver_2 (Version Number 2) is Required as query parameter", ) def _check_versions(self, version_1: str, version_2: str) -> int: """Checks if 1st version number is "before", "equal" or "after" the 2nd version number :param version_1: Version Number 1 :type version_1: str :param version_2: Version Number 2 :type version_2: str :return: -1 for "before" or 0 for "equal" or 1 for "after" :rtype: int """ ver_1_list = [int(c) for c in version_1.split(".") if c.isdigit()] ver_2_list = [int(c) for c in version_2.split(".") if c.isdigit()] v1_len = len(ver_1_list) v2_len = len(ver_2_list) n = min(v1_len, v2_len) res = 0 for i in range(n): if ver_1_list[i] == ver_2_list[i]: res = 0 elif ver_1_list[i] > ver_2_list[i]: res = 1 break else: res = -1 break if res == 0: if v2_len > v1_len and any(ver_2_list[v1_len:]): res = -1 elif v1_len > v2_len and any(ver_1_list[v2_len:]): res = 1 return res def get(self): """Handles the GET request to version_checker""" args = self.parser.parse_args() ver_1 = args.get("ver_1") ver_2 = args.get("ver_2") if VERSION_REGEX.match(ver_1) and VERSION_REGEX.match(ver_2): key = self._check_versions(ver_1, ver_2) return {"result": f"{ver_1} is {self.str_map.get(key)} {ver_2}"} abort(400, message="Invalid Version Number Format")
class Food(Resource): parser = reqparse.RequestParser() parser.add_argument('price', type=float, required=True, help="This field cannot be left blank!") parser.add_argument('category', type=str, required=True, help="This field cannot be left blank!") @jwt_required #fresh or non-fresh def get(self, name): claims = get_jwt_claims() if not claims['is_admin']: return {'message': 'Admin privilege required.'}, 401 food = FoodModel.find_by_name(name) if food: return food.json() return {'message': 'Food not found'}, 404 @jwt_required def post(self, name): claims = get_jwt_claims() if not claims['is_admin']: return {'message': 'Admin privilege required.'}, 401 if FoodModel.find_by_name(name): return { 'message': "A food with name '{}' already exists.".format(name) }, 400 data = Food.parser.parse_args() print(data) food = FoodModel(name, **data) try: food.save_to_db() except: return {"message": "An error occurred inserting the food."}, 500 return food.json(), 201 @jwt_required def delete(self, name): claims = get_jwt_claims() if not claims['is_admin']: return {'message': 'Admin privilege required.'}, 401 food = FoodModel.find_by_name(name) if food: food.delete_from_db() return {'message': 'Food deleted.'} return {'message': 'Food not found.'}, 404 @jwt_required def put(self, name): claims = get_jwt_claims() if not claims['is_admin']: return {'message': 'Admin privilege required.'}, 401 data = Food.parser.parse_args() food = FoodModel.find_by_name(name) if food: food.price = data['price'] else: food = FoodModel(name, **data) food.save_to_db() return food.json()
from flask_cors import CORS import uuid import json import os env_dist = os.environ import sys sys.path.append("..") from web_backend.common.util import * project_parser = reqparse.RequestParser() project_parser.add_argument('path', type=str) project_parser.add_argument('projectname', type=str) project_parser.add_argument('tag', type=str) project_json = mark_parser.project_json def load_project(): if not os.path.exists(project_json): f = open(project_json, 'w') f.write("{}") f.close() with open(project_json, 'r') as load_f: mpconfigs = json.load(load_f)
class Item(Resource): parser = reqparse.RequestParser() # allows to select the information parser.add_argument( 'price', type=float, required=True, #be sure no request can come through with no price! help="This field cannot be left blank!") parser.add_argument( 'store_id', type=int, required=True, #be sure no request can come through with no price! help="Every item needs a store id.") @jwt_required() #better to put it before all functions def get(self, name): item = ItemModel.find_by_name(name) if item: return item.json() return {'message': "Item not found"}, 404 def post( self, name ): #if called 10 times, 10 items, different from put where there will be only have one # first, deal with errors! if ItemModel.find_by_name(name): return { 'message': "An item with name '{}' already exists".format(name) }, 400 # 400: bad request, syntaxe requete erronee data = Item.parser.parse_args() item = ItemModel(name, **data) # **data == data["price"], data["store_id"] try: item.save_to_db() except: return { "message": "An error occured inserting the item" }, 500 #500: internat server error return item.json( ), 201 # requete traitee avec succes et creation du doc def delete(self, name): item = ItemModel.find_by_name(name) if item: item.delete_from_db() return {"message": "Item deleted"} def put(self, name): data = Item.parser.parse_args() item = ItemModel.find_by_name(name) if item is None: item = ItemModel(name, **data) else: item.price = data["price"] item.store_id = data["store_id"] item.save_to_db() return item.json()
class Transaction(Resource): parser = reqparse.RequestParser() parser.add_argument('transaction_id', type=int, required=False) parser.add_argument('amount', type=float, required=False ) parser.add_argument('is_expense', type=bool, required=True, help="This field cannot be left blank!") parser.add_argument('description', type=str, required=True, help="This field cannot be left blank!" ) parser.add_argument('date', type=str, required=False) parser.add_argument('category_id', type=int, required=True, help="This field cannot be left blank!") parser.add_argument('sale_id', type=int, required=False) parser.add_argument('method', type=str, required=False) parser.add_argument('exchange', type=str, required=True, help="This field cannot be left blank!" ) parser.add_argument('currency_id', type=str, required=True, help="This field cannot be left blank!" ) @jwt_required def post(self): data = Transaction.parser.parse_args() transaction = TransactionModel(**data) try: transaction.save_to_db() except: return {"message": "An error occurred creating the transaction"}, 500 return transaction.json(), 201 @jwt_required def put(self): data = Transaction.parser.parse_args() transaction = TransactionModel(**data) try: transaction.update_to_db() except: return {"message": "An error occurred updating the transaction"}, 500 return transaction.json(), 200
def post(self): ''' +----------------------+----------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +----------------------+----------+------+-----+---------+----------------+ | id | int(11) | NO | PRI | NULL | auto_increment | | atmospheric_pressure | int(11) | NO | | NULL | | | wind | int(11) | NO | | NULL | | | temp | int(11) | NO | | NULL | | | relative_humidity | int(11) | NO | | NULL | | | last_update | text | YES | | NULL | | | weather | text | NO | | NULL | | | locality_id | int(11) | NO | MUL | NULL | | | date_time | datetime | NO | | NULL | | +----------------------+----------+------+-----+---------+----------------+ ''' post_parser = reqparse.RequestParser() post_parser.add_argument( 'atmospheric_pressure', dest='atmospheric_pressure', type=int, required=True, help='required field <atmospheric_pressure> not informed.', ) post_parser.add_argument( 'wind', dest='wind', type=int, required=True, help='required field <wind> not informed', ) post_parser.add_argument( 'temp', dest='temp', type=int, required=True, help='required field <temp> not informed', ) post_parser.add_argument( 'relative_humidity', dest='relative_humidity', type=int, required=True, help='required field <relative_humidity> not informed', ) post_parser.add_argument('last_update', dest='last_update', type=str, default=None) post_parser.add_argument( 'weather', dest='weather', type=str, required=True, help='required field <weather> not informed', ) post_parser.add_argument( 'locality_id', dest='locality_id', type=int, required=True, help='required field <locality_id> not informed', ) post_parser.add_argument( 'date_time', dest='date_time', type=str, required=True, help='required field <date_time> not informed', ) data = dict() args = post_parser.parse_args() if not locality_query.consult_locality_byid(args.locality_id): body = { 'success': False, 'message': 'locality id ' + str(args.locality_id) + ' not found in database' } return body, 409 data['atmospheric_pressure'] = args.atmospheric_pressure data['wind'] = args.wind data['temp'] = args.temp data['relative_humidity'] = args.relative_humidity data['last_update'] = args.last_update data['weather'] = args.weather data['locality_id'] = args.locality_id data['date_time'] = args.date_time if wfhour_query.create_wfhour(data): body = { 'success': True, 'message': 'created with successfully!', } return body, 201 body = {'success': False, 'message': 'error to create'} return body, 500
---------------------------------- @File : Users.py @CreateTime : 2020/4/19 8:56 下午 @Software : PyCharm @Description : """ from flask import Flask from flask_restful import Api, reqparse, Resource from flask_httpauth import HTTPTokenAuth # Flask 相关变量声明 app = Flask(__name__) api = Api(app) # RESTfulAPI的参数解析 -- put /post 参加解析 parser_put = reqparse.RequestParser() parser_put.add_argument("user", type=str, required=True, help="need user data") parser_put.add_argument("pwd", type=str, required=True, help="need pwd data") # 功能方法部分案例 def to_do(arg1, args2): return str(arg1) + str(args2) # 操作(post / get) 资源列表 class TodoList(Resource): def post(self): args = parser_put.parse_args() # 构建新参数
class Item(Resource): # inherits Resource # first use reqparse to check if the keys exist as per requirement parser = reqparse.RequestParser() parser.add_argument('price', type=float, required=True, help="This field cannot be left blank!") parser.add_argument('store_id', type=int, required=True, help="Every item needs a store id") @jwt_required def get(self, name): item = ItemModel.find_by_name(name) if item: return item.json() return {'message': 'Item not found'}, 404 # always requires a fresh access token ie the first token after login. # tokens received after calling the TokenRefresh Api will not work @fresh_jwt_required def post(self, name): if ItemModel.find_by_name(name): return { 'message': "An Item with name '{}' already exists".format(name) }, 400 # Bad request data = Item.parser.parse_args() item = ItemModel(name, data['price'], data['store_id']) try: item.save_to_db() except: return { 'message': 'An error occured inserting the item' }, 500 # internal server error return item.json(), 201 @jwt_required def delete(self, name): print('IDENTITY') claims = get_jwt_claims() if not claims['is_admin']: return {'message': 'Admin privilege required'}, 401 item = ItemModel.find_by_name(name) if item: item.delete_from_db() return {'message': 'Item deleted successfully'} def put(self, name): data = Item.parser.parse_args() item = ItemModel.find_by_name(name) if item is None: item = ItemModel(name, data['price'], data['store_id']) else: item.price = data['price'] item.save_to_db() return item.json()
from src.app import db from src.exceptions.no_data import NoData from src.messages.marshalling_objects import SimpleMessage from src.messages.messages import INTERNAL_SERVER_ERROR, COMMUNIY_WITH_THIS_CAR_ALREADY_EXISTS, COMMUNIY_DOESNT_EXIST, \ COMMUNIY_DELETED, COMMUNIY_INVITATION_SENT, UNAUTHORIZED_TO_ACCEPT_COMMUNITY_INVITATION, \ COMMUNITY_INVITATION_ALREADY_ACCEPTED, COMMUNITY_INVITATION_DOESNT_EXIST, COMMUNITY_INVITATION_ACCEPTED, \ CAR_DOESNT_EXIST, USER_DOESNT_EXIST, USER_ALREADY_INVITED, NOT_AUTHORIZED_TO_REMOVE_USER_FROM_COMMUNITY, \ COMMUNIY_LEFT_SUCCESSFULLY, COMMUNITY_INVITATION_DECLINED, UNAUTHORIZED, CANNOT_CREATE_COMMUNITY_WITH_FOREIGN_CAR, \ COMMUNIY_LEFT_AND_DELETED, COMMUNITY_MARKED_AS_FAVOURITE, NO_FAVOURITE_COMMUNITY_FOUND from src.models.car import CarModel from src.models.community import CommunityModel from src.models.community_user_link import CommunityUserLinkModel from src.models.user import UserModel post_parser = reqparse.RequestParser() post_parser.add_argument('car', help='This field cannot be blank', required=True, type=int) post_parser.add_argument('name', help='This field cannot be blank', required=True, type=str) put_parser = reqparse.RequestParser() put_parser.add_argument('name', help='This field cannot be blank', required=True, type=str)
from flask_restful import Resource, reqparse from models.usuario import UserModel from flask_jwt_extended import create_access_token, jwt_required, get_raw_jwt from werkzeug.security import safe_str_cmp from blacklist import BLACKLIST atributos = reqparse.RequestParser() atributos.add_argument('login', type=str, required=True, help="The field 'login' cannot be left blank.") atributos.add_argument('senha', type=str, required=True, help="The field 'senha' cannot be left blank.") class User(Resource): # /usuarios/{user_id} def get(self, user_id): user = UserModel.find_user(user_id) if user: return user.json() return {'message': 'User not found.'}, 404 @jwt_required def delete(self, user_id): user = UserModel.find_user(user_id) if user: user.delete_user() return {'message': 'User deleted.'} return {'message': 'User not found.'}, 404 class UserRegister(Resource): # /cadastro def post(self): dados = atributos.parse_args()
class NganhHoc_List(Resource): parser = reqparse.RequestParser() parser.add_argument('mo_ta', type=str, required=False, help='Mo ta co ban ve Nganh') parser.add_argument('khoa', type=str, required=False, help='Nganh thuoc Khoa') parser.add_argument('website', type=str, required=False, help='Website của Khoa') parser.add_argument('ma', type=str, required=False, help='Ma Nganh') parser.add_argument('chi_tieu', type=int, required=False, help='Chi tieu của Nganh') parser.add_argument('to_hop_xet_tuyen', type=str, required=False, help='To hop xet tuyen cua Nganh') parser.add_argument('diem_2015', type=str, required=False, help='Diem san 2015 cua Nganh') parser.add_argument('diem_2016', type=str, required=False, help='Diem san 2016 cua Nganh') parser.add_argument('diem_2017', type=str, required=False, help='Diem san 2017 cua Nganh') parser.add_argument('diem_2018', type=str, required=False, help='Diem san 2018 cua Nganh') parser.add_argument('chuong_trinh', type=str, required=False, help='Chuong trinh dao tao cua Nganh') parser.add_argument('so_tin', type=int, required=False, help='Tong so tin chi cua Nganh') parser.add_argument('co_hoi_nn', type=str, required=False, help='Co hoi nghe nghiep cua Nganh') def get(self, nganh): item = NganhHoc.find_by_name(nganh) if item: return item.json() return {'Message': 'Nganh hoc khong ton tai.'} def post(self, nganh): if NganhHoc.find_by_name(nganh): return {'Message': '{} da ton tai.'.format(nganh)} args = NganhHoc_List.parser.parse_args() item = NganhHoc(nganh, args['mo_ta'], args['khoa'], args['website'], args['ma'], args['chi_tieu'], args['to_hop_xet_tuyen'], args['diem_2015'], args['diem_2016'], args['diem_2017'], args['diem_2018'], args['chuong_trinh'], args['so_tin'], args['co_hoi_nn']) item.save_to() return item.json() def put(self, nganh): args = NganhHoc_List.parser.parse_args() item = NganhHoc.find_by_name(nganh) if item: item.mo_ta = args['mo_ta'] item.khoa = args['khoa'] item.website = args['website'] item.ma = args['ma'] item.chi_tieu = args['chi_tieu'] item.to_hop_xet_tuyen = args['to_hop_xet_tuyen'] item.diem_2015 = args['diem_2015'] item.diem_2016 = args['diem_2016'] item.diem_2017 = args['diem_2017'] item.diem_2018 = args['diem_2018'] item.chuong_trinh = args['chuong_trinh'] item.so_tin = args['so_tin'] item.co_hoi_nn = args['co_hoi_nn'] item.save_to() return {'Nganh': item.json()} item = NganhHoc(nganh, args['mo_ta'], args['khoa'], args['website'], args['ma'], args['chi_tieu'], args['to_hop_xet_tuyen'], args['diem_2015'], args['diem_2016'], args['diem_2017'], args['diem_2018'], args['chuong_trinh'], args['so_tin'], args['co_hoi_nn']) item.save_to() return item.json() def delete(self, nganh): item = NganhHoc.find_by_name(nganh) if item: item.delete_() return {'Message': '{} da duoc xoa.'.format(nganh)} return {'Message': '{} khong ton tai'.format(nganh)}
# The third (query_parser) parses incoming GET requests to get the parameters # for sorting and filtering the list of help tickets. # Helper function new_helpticket_parser. Raises an error if the string x # is empty (has zero length). def nonempty_string(x): s = str(x) if len(x) == 0: raise ValueError('string is empty') return s # Specify the data necessary to create a new help ticket. # "from", "title", and "description" are all required values. new_helpticket_parser = reqparse.RequestParser() for arg in ['from', 'title', 'description']: new_helpticket_parser.add_argument( arg, type=nonempty_string, required=True, help="'{}' is a required value".format(arg)) # Specify the data necessary to update an existing help ticket. # Only the priority and comments can be updated. update_helpticket_parser = reqparse.RequestParser() update_helpticket_parser.add_argument('priority', type=int, default=PRIORITIES.index('normal')) update_helpticket_parser.add_argument('comment', type=str, default='')
def __init__(self): self.reqparse = reqparse.RequestParser() super(NotificationsList, self).__init__()
class Item(Resource): parser = reqparse.RequestParser() parser.add_argument('price', type=float, required=True, help="This field cannot be left blank!" ) @jwt_required() def get(self, name): item = self.find_by_name(name) if item: return item return {'message': 'Item not found'}, 404 @classmethod def find_by_name(cls, name): connection = sqlite3.connect('data.db') cursor = connection.cursor() query = "SELECT * FROM items WHERE name=?" result = cursor.execute(query, (name,)) row = result.fetchone() connection.close() if row: return {'item': {'name': row[0], 'price': row[1]}} def post(self, name): if self.find_by_name(name): return {'message': 'An item with name "{}" already exists'.format(name)}, 400 # Something Wrong With The Request data = Item.parser.parse_args() item = {'name': name, 'price': data['price']} try: self.insert(item) except: return {"message": "An Error occurred inserting the item."}, 500 # Internal Server Error return item, 201 @classmethod def insert(cls, item): connection = sqlite3.connect('data.db') cursor = connection.cursor() query = "INSERT INTO items VALUES (?, ?)" cursor.execute(query, (item['name'], item['price'])) connection.commit() connection.close() def delete(self, name): connection = sqlite3.connect('data.db') cursor = connection.cursor() query = "DELETE FROM items WHERE name=?" cursor.execute(query, (name,)) connection.commit() connection.close() return {'message': 'Item deleted'} def put(self, name): data = Item.parser.parse_args() item = self.find_by_name(name) updated_item = {'name': name, 'price': data['price']} if item is None: try: self.insert(updated_item) except: return {"message": "An error occurred inserting the item."}, 500 else: try: self.update(updated_item) except: return {"message": "An error occurred updating the item."}, 500 return updated_item @classmethod def update(cls, item): connection = sqlite3.connect('data.db') cursor = connection.cursor() query = "UPDATE items SET price=? WHERE name=?" cursor.execute(query, (item['price'], item['name'])) connection.commit() connection.close()
'datetime': fields.DateTime(attribute='create_time'), 'love_num': fields.Integer, 'replys': fields.List(fields.Nested(reply_fields)) } # 新闻详情格式 news_detail_fields = { 'id': fields.Integer, 'title': fields.String, 'content': fields.String, 'datetime': fields.String(attribute='create_time'), 'author': AuthorName(attribute='author'), 'comments': fields.List(fields.Nested(comment_fields)) } newslist_parser = reqparse.RequestParser() newslist_parser.add_argument('typeid', type=int, required=True) newslist_parser.add_argument('page', type=int) # 新闻列表 class NewsListApi(Resource): # 获取某个分类的新闻 def get(self): args = newslist_parser.parse_args() typeid = args.get('typeid') page = args.get('page', 1) pagination = New.query.filter(New.type_id == typeid).paginate( page=page, per_page=8) data = {
if sys.getdefaultencoding() != defaultencoding: reload(sys) sys.setdefaultencoding(defaultencoding) from flask import Flask, request, json from flask_restful import abort, Api, Resource, reqparse app = Flask(__name__) api = Api(app) INFOS = { "user1": { "name": "12345" }, } #用SQL替代 parser = reqparse.RequestParser(bundle_errors=True) parser.add_argument("name", required=True, action='append', type=str) class Id(Resource): def post(self, info): if info in INFOS: abort(404, message="user {} already exist".format(info)) args = parser.parse_args() new = {"name": args["name"]} INFOS[info] = new return new, 201 def get(self, info): if info in INFOS: abort(404, message="user {} already exist".format(info))
def get_arguments(self): parser = reqparse.RequestParser() parser.add_argument("date", default=datetime.datetime.now()) return parser.parse_args()
class MealAPI(Resource): parser_get = reqparse.RequestParser() parser_get.add_argument('begin', type=str, required=False, help='Inital date') parser_get.add_argument('end', type=str, required=False, help='End date') parser_get.add_argument('location', type=str, required=False, help='Location') parser_get.add_argument('meal_type', type=str, required=False, help='Type of the meal') parser_del = reqparse.RequestParser() parser_del.add_argument('date', type=str, required=True, help='Date') parser_del.add_argument('location', type=str, required=True, help='Localtion') parser_del.add_argument('meal_type', type=str, required=True, help='Type of the meal') @user_required def get(self): import datetime args = MealAPI.parser_get.parse_args() try: begin = datetime.date.today( ) if args['begin'] == None else datetime.date.fromisoformat( args['begin']) end = begin + datetime.timedelta(weeks=1) if args[ 'end'] == None else datetime.date.fromisoformat(args['end']) except: return error_message( "Invalid date format (ISO Date format required)!"), 400 if begin > end: return error_message("begin bigger than end!"), 400 try: id_meal_type = None if args['meal_type'] != None: id_meal_type = MealType.get_by_name( args['meal_type']).id_meal_type id_location = None if args['location'] != None: id_location = Location.get_by_name( args['location']).id_location if id_location != None or id_meal_type != None: print("here") return { "meals": [ m.to_json() for m in Meal.get_between( begin, end, id_meal_type, id_location) ] }, 200 except ErrorCodeException as ec: return error_code(ec), 400 #print("or here here") return { "meals": [m.to_json() for m in Meal.get_between(begin, end)] }, 200 @content_provider_required def post(self): import datetime body = request.json if not body: return {"error": "No json body found on request"} # Request body argument validation date = None try: date = datetime.date.fromisoformat(body['date']) except: return error_message( "Invalid date format (ISO Date format required)!"), 400 try: id_meal_type = MealType.get_by_name(body['meal_type']).id_meal_type id_location = Location.get_by_name(body['location']).id_location try: Meal.add_meal( Meal(date, id_location, id_meal_type, body['soup'], body['main_dish'], body['description'])) return success() except KeyError: return error_message("Missing arguments!"), 400 #except MySQLdb._exceptions.DataError: # return error_message("Invalid argument length!") , 400 except Exception as e: return error_message("Something unexpected occured!"), 500 except ErrorCodeException as ec: return error_code(ec), 400 @content_provider_required def delete(self): args = MealAPI.parser_del.parse_args() date = args['date'] location = args['location'] meal_type = args['meal_type'] if not (date and meal_type and location): return error_message("Arguments required"), 400 try: id_location = Location.get_by_name(location).id_location id_meal_type = MealType.get_by_name(meal_type).id_meal_type Meal.delete(date, id_location, id_meal_type) return success() except ErrorCodeException as ec: return error_code(ec), 400
from flask_restful import Resource, reqparse from models.autor import AutorModel serialazer = reqparse.RequestParser() serialazer.add_argument('autor_nombre', type=str, required=True, help='Falta el autor_nombre') class AutoresController(Resource): def post(self): informacion = serialazer.parse_args() "INSERT INTO T_AUTOR (AUTOR_NOMBRE) VALUES (INFORMACION['AUTOR_NOMBRE'])" nuevoAutor = AutorModel(informacion['autor_nombre']) nuevoAutor.save() print(nuevoAutor) return { 'success': True, 'content': nuevoAutor.json(), 'message': 'Autor creado exitosamente' }, 201 def get(self): # SELECT * FROM T_AUTOR lista_autores = AutorModel.query.all() resultado = [] for autor in lista_autores: resultado.append(autor.json()) print(autor.json())
def post(self, room_num): TAG = "Check_perm:" module = Module() database = Database() start_time = time.time() booking_key = "booking_number" one_id_key = "one_id" guest_req = "guest_req" parser = reqparse.RequestParser() parser.add_argument(booking_key) parser.add_argument(one_id_key) parser.add_argument(guest_req) args = parser.parse_args() if (not (module.isQueryStr(args, one_id_key) or module.isQueryStr(args, booking_key))): print(TAG, "bad req") return module.wrongAPImsg() booking_number = args.get(booking_key) one_id = args.get(one_id_key) query_cmd = """ SELECT IF((CURRENT_TIMESTAMP>bookings.meeting_start) AND (CURRENT_TIMESTAMP<bookings.meeting_end), true, false) as time_to_meet FROM bookings WHERE booking_number=%s AND one_email='%s' AND room_num='%s' """ % ( booking_number, one_id, room_num) if (module.isQueryStr(args, guest_req)): print(TAG, "guest_req received") query_cmd = """SELECT IF((CURRENT_TIMESTAMP>bookings.meeting_start) AND (CURRENT_TIMESTAMP<bookings.meeting_end), true, false) as time_to_meet FROM bookings LEFT JOIN guests ON bookings.booking_number=guests.booking_number WHERE bookings.booking_number=%s AND guests.guest_email='%s' AND room_num='%s' LIMIT 1""" % (booking_number, one_id, room_num) # check with database print(TAG, "query_cmd=", query_cmd) response = database.getData(query_cmd) print(TAG, "result=", response) # check error if (response[1] != 200): return response # user not found if (len(response[0]['result']) == 0): print(TAG, "booking not found!") return module.measurementNotFound() result = response[0]['result'] access_perm = result[0]["time_to_meet"] elapsed_time = (time.time() - start_time) * 1000 print(TAG, "times=", elapsed_time, "ms") return { 'type': True, 'message': "success", 'elapsed_time_ms': elapsed_time, 'len': len(result), 'result': result, }, 200
def __init__ (self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('email_address', type=str, required=True,help = "Enter email email_address") self.reqparse.add_argument('password', type=str, required=True, help= "Enter password") super(LoginUser, self).__init__()
def __parseArgs(self, argsList): parser = reqparse.RequestParser() for argExp in argsList: parser.add_argument(argExp[0], type=argExp[1]) return parser.parse_args()
def __init__ (self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('email_address', type=str, required=True, help = "Enter email") super(CheckUserEmail, self).__init__()
import config import json import jwt import os import hashlib from flask_restful import Resource, reqparse from models import User, Admin import requests from auth import requires_auth, requires_auth_admin parser = reqparse.RequestParser() parser.add_argument('id_token', type=str) class GoogleAuth(Resource): def get(self): try: args = parser.parse_args() id_token = str(args['id_token']) res = requests.get( "https://www.googleapis.com/oauth2/v3/tokeninfo?id_token={}". format(id_token)).json() if res.get('error_description'): return {"message": "An error ocurred"}, 401 u = User.objects(email=res['email']) if not u: user_obj = User(email=res['email'], name=res['name'], photo=res['picture']) user_obj.save()
def __init__(self): self.reqparse = reqparse.RequestParser() super(ProfileActions, self).__init__()
class EventsMixin(object): req_parser = reqparse.RequestParser() req_parser.add_argument('event_id', type=int, required=True)
class Item(Resource): # we want to make sure that our json payload (which is the data that the client sends to us # while making a put request) is correct and has the fields that we desire (in this case, the field # 'price') # thus we use the parser parser = reqparse.RequestParser() parser.add_argument('price', type=float, required=True, help="This field cannot be left blank!") # we only added the argument 'price' here so if any other field is given by client when making the request, # it will be ignored parser.add_argument('store_id', type=int, required=True, help="Every item needs a store id") @jwt_required() def get(self, name): try: item = ItemModel.find_by_name(name) except: return {"message": "An error occurred while inserting item"}, 500 if item: return item.json() return {"message": "item not found"}, 404 def post(self, name): # post method should have the exact same signature as the get method # our app does not allow duplication of name of items, that is why below piece of codes if ItemModel.find_by_name(name): return {"message": "An item with name '{}' already exists.".format(name)}, 400 # 400 bcs asking to create a new resource that already exists is a bad request # using parser below: data = Item.parser.parse_args() item = ItemModel(name, data['price'], data['store_id']) try: item.save_to_db() except: return {"message": "An error occurred while inserting item"}, 500 # 500 means internal server error and is usually given to indicate to the user that they are not at fault return item.json(), 201 # to let our client know that our method worked def delete(self, name): item = ItemModel.find_by_name(name) if item: item.delete_from_db() return {'message': 'Item deleted'} def put(self, name): # allowing the 'price' data into our codes, and also that it should be of type float and is reqd data = Item.parser.parse_args() item = ItemModel.find_by_name(name) if item is None: # item doesnt exist already item = ItemModel(name, data['price'], data['store_id']) try: item.insert() except: return {"message": "An error occurred while inserting item"}, 500 else: item.price = data['price'] item.save_to_db() return item.json()