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