def post(self, name):
user_auth = request.headers['Authorization']
parser = RequestParser()
parser.add_argument('message', type=str, required=True)
message = parser.parse_args()['message']
server = get_instance()
server.handle_message(user_auth, name, message)
def post(self):
"""Adds in a new youtube video for processing."""
parser = RequestParser()
parser.add_argument('url', required=True)
args = parser.parse_args()
logging.info('Enqueing {url:s}', args)
# parse youtube url in the form of http://youtube.com/watch?v=<VIDEO_ID>
# parse the extracted query to get the first available 'v' param
parsed = parse.urlparse(args['url'])
video_id = parse.parse_qs(parsed.query).get('v')[0]
logging.debug('Found video_id {0}', video_id)
if not video_id:
msg = "Could not extract video_id (found '{0}') from {1}".format(
video_id, args['url'])
logging.warn(msg)
return abort(400, message=msg)
res = chain(
tasks.captions.youtube_captions_from_video.s(video_id),
tasks.captions.annotate_events_in_captions.s(video_id),
tasks.captions.event_dates_from_timeml_annotated_captions.s(),
tasks.wikitext.wikipedia_events_from_dates.s(),
tasks.wikitext.event_entities_from_wikitext.s(),
tasks.wikitext.match_event_via_entities.s(),
tasks.wikitext.resolve_match_link_topics.s(),
# tasks.requests.send_url_payload(app.config['WIKITEXT_PAYLOAD_DEST_URL']),
).apply_async()
return {
'url': args['url'],
'video_id': video_id,
'task_id': res.id
}
def post(self):
parser = RequestParser()
parser.add_argument('name', type=str, required=True)
args = parser.parse_args()
server = get_instance()
args['user_auth'] = request.headers['Authorization']
server.join_room(**args)
def test_parse_required(self):
app = Flask(__name__)
with app.app_context():
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", required=True, location='values')
message = ''
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, ({'foo': 'Missing required parameter in '
'the post body or the query '
'string'}))
parser = RequestParser()
parser.add_argument("bar", required=True, location=['values', 'cookies'])
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, ({'bar': 'Missing required parameter in '
'the post body or the query '
'string or the request\'s '
'cookies'}))
def test_parse_foo_operators_four_hunderd(self):
app = Flask(__name__)
with app.app_context():
parser = RequestParser()
parser.add_argument("foo", type=int),
self.assertRaises(exceptions.BadRequest, lambda: parser.parse_args(Request.from_values("/bubble?foo=bar")))
def test_parse_choices_sensitive(self):
req = Request.from_values("/bubble?foo=BAT")
parser = RequestParser()
parser.add_argument("foo", choices=["bat"], case_sensitive=True),
self.assertRaises(exceptions.BadRequest, lambda: parser.parse_args(req))
def bad_choice():
parser = RequestParser()
parser.add_argument('foo', choices=['one', 'two'])
req = Mock(['values'])
req.values = MultiDict([('foo', 'three')])
parser.parse_args(req)
abort.assert_called_with(400, message='three is not a valid choice')
def test_parse_choices(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument("foo", choices=["bat"]),
self.assertRaises(exceptions.BadRequest, lambda: parser.parse_args(req))
def test_parse_required(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", required=True)
self.assertRaises(exceptions.BadRequest, lambda: parser.parse_args(req))
def test_parse_unicode(self):
req = Request.from_values("/bubble?foo=barß")
parser = RequestParser()
parser.add_argument("foo")
args = parser.parse_args(req)
self.assertEquals(args['foo'], u"barß")
def test_parse_lte(self):
req = Request.from_values("/bubble?foo<=bar")
parser = RequestParser()
parser.add_argument("foo", operators=["<="])
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bar")
def bad_choice():
parser = RequestParser()
parser.add_argument("foo", choices=["one", "two"])
req = Mock(["values"])
req.values = MultiDict([("foo", "three")])
parser.parse_args(req)
abort.assert_called_with(400, message="three is not a valid choice")
def test_passing_arguments_object(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument(Argument("foo", type=str))
args = parser.parse_args(req)
self.assertEquals(args['foo'], u"bar")
def test_parse_required(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", required=True, location='values')
message = ''
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, (u'Missing required parameter foo in the '
'post body or the query string'))
parser = RequestParser()
parser.add_argument("bar", required=True, location=['values', 'cookies'])
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, (u"Missing required parameter bar in the "
"post body or the query string or the "
"request's cookies"))
def test_parse_ignore(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument("foo", type=int, ignore=True),
args = parser.parse_args(req)
self.assertEquals(args['foo'], None)
def test_parse_store_missing(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", store_missing=False)
args = parser.parse_args(req)
self.assertFalse('foo' in args)
def test_parse_gte_lte_eq(self):
req = Request.from_values("/bubble?foo>=bar&foo<=bat&foo=foo")
parser = RequestParser()
parser.add_argument("foo", operators=[">=", "<=", "="], action="append"),
args = parser.parse_args(req)
self.assertEquals(args['foo'], ["bar", "bat", "foo"])
def test_parse(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument("foo"),
args = parser.parse_args(req)
self.assertEquals(args["foo"], "bar")
def test_parse_append_single(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument("foo", action="append"),
args = parser.parse_args(req)
self.assertEquals(args['foo'], ["bar"])
def test_parse_default(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", default="bar", store_missing=True)
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bar")
def test_type_callable(self):
req = Request.from_values("/bubble?foo=1")
parser = RequestParser()
parser.add_argument("foo", type=lambda x: x, required=False),
args = parser.parse_args(req)
self.assertEquals(args['foo'], "1")
def test_parse_dest(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument("foo", dest="bat")
args = parser.parse_args(req)
self.assertEquals(args['bat'], "bar")
def test_help(self, abort):
from werkzeug.datastructures import MultiDict
parser = RequestParser()
parser.add_argument('foo', choices=['one', 'two'], help='Bad choice')
req = Mock(['values'])
req.values = MultiDict([('foo', 'three')])
parser.parse_args(req)
abort.assert_called_with(400, message='Bad choice')
def test_parse_choices_insensitive(self):
req = Request.from_values("/bubble?foo=BAT")
parser = RequestParser()
parser.add_argument("foo", choices=["bat"], case_sensitive=False),
args = parser.parse_args(req)
self.assertEquals('bat', args.get('foo'))
def test_parse_callable_default(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", default=lambda: "bar")
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bar")
def test_parse_append_ignore(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument("foo", ignore=True, type=int, action="append"),
args = parser.parse_args(req)
self.assertEquals(args["foo"], None)
def test_parse_none(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo")
args = parser.parse_args(req)
self.assertEquals(args['foo'], None)
def test_parse_default_append(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", default="bar", action="append")
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bar")
def test_parse_choices_correct(self):
req = Request.from_values("/bubble?foo=bat")
parser = RequestParser()
parser.add_argument("foo", choices=["bat"]),
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bat")
def test_parse_append_default(self):
req = Request.from_values("/bubble?")
parser = RequestParser()
parser.add_argument("foo", action="append"),
args = parser.parse_args(req)
self.assertEquals(args['foo'], None)
def get(self):
"""
获取文章列表
/v1_1/articles?channel_id×tamp
"""
qs_parser = RequestParser()
qs_parser.add_argument('channel_id',
type=parser.channel_id,
required=True,
location='args')
qs_parser.add_argument('timestamp',
type=inputs.positive,
required=True,
location='args')
qs_parser.add_argument('with_top',
type=inputs.boolean,
required=True,
location='args')
args = qs_parser.parse_args()
channel_id = args.channel_id
timestamp = args.timestamp
with_top = args.with_top
per_page = constants.DEFAULT_ARTICLE_PER_PAGE_MIN
try:
feed_time = time.strftime('%Y-%m-%dT%H:%M:%S',
time.localtime(timestamp / 1000))
except Exception:
return {'message': 'timestamp param error'}, 400
results = []
now = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
if with_top:
# 包含置顶
top_article_id_li = cache_article.ChannelTopArticlesStorage(
channel_id).get()
for article_id in top_article_id_li:
article = cache_article.ArticleInfoCache(article_id).get()
if article:
article['pubdate'] = now
results.append(article)
# 获取推荐文章列表
feeds, pre_timestamp = self._feed_articles(channel_id, timestamp,
per_page)
# 查询文章
for feed in feeds:
article = cache_article.ArticleInfoCache(feed.article_id).get()
if article:
article['pubdate'] = feed_time
article['trace'] = {
'click': feed.params.click,
'collect': feed.params.collect,
'share': feed.params.share,
'read': feed.params.read
}
results.append(article)
return {'pre_timestamp': pre_timestamp, 'results': results}
def post(self):
"""Add todo
### request
```json
{"name": "xx", "type": "code"}
```
### return
```json
{"code": xxxx, "msg": "xxx", "data": null}
```
"""
parser = RequestParser()
# fmt: off
parser.add_argument(
"name",
location="json",
type=str,
required=True,
help="todo name",
)
parser.add_argument(
"type",
location="json",
type=str,
required=True,
default="life",
help="todo type",
)
parser.add_argument()
# fmt: on
return {"todo": "post todo"}
def post(self):
parser = RequestParser()
parser.add_argument('user', type=str, required=True)
parser.add_argument('name', type=str, required=True)
parser.add_argument('parent_name', type=str)
parser.add_argument('description', type=str, required=False)
args = parser.parse_args()
# Get a SQL Alchemy query object
q = db.session.query
# Create a new goal
user = q(m.User).filter_by(name=args.user).one()
# Find parent goal by name
if args.parent_name:
parent = q(m.Goal).filter_by(name=args.parent_name).one()
else:
parent = None
goal = m.Goal(user=user,
parent=parent,
name=args.name,
description=args.description)
db.session.add(goal)
db.session.commit()
def post(self):
parser = RequestParser()
parser.add_argument('sesskey',required=True,location='json')
parser.add_argument('roundkey',required=True,location='json')
args = parser.parse_args()
sesskey = args.sesskey
roundkey = args.roundkey
name = ["张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋","张三盗窃电动⻋"]
bamj = ["邹⼩⻥","邹⼩⻥","邹⼩⻥","邹⼩⻥","邹⼩⻥","邹⼩⻥","邹⼩⻥","邹⼩⻥","邹⼩⻥","邹⼩⻥"]
ajxz = ["盗窃案","盗窃案","盗窃案","盗窃案","盗窃案","盗窃案","盗窃案","盗窃案","盗窃案","盗窃案"]
place = ["深圳市南⼭区粤海街道科苑路23号讯美科技⼴场3栋23A","深圳市南⼭区粤海街道科苑路23号讯美科技⼴场3栋23A","深圳市南⼭区粤海街道科苑路23号讯美科技⼴场3栋23A","深圳市南⼭区粤海街道科苑路23号"]
people = ["张⼩⾬","张⼩⾬","张⼩⾬","张⼩⾬","张⼩⾬","张⼩⾬","张⼩⾬","张⼩⾬","张⼩⾬","张⼩⾬"]
table = {"案件ID":["A83","B45","A32","A79","B98","C23","A24","A25","A26","B78"],
"案件名称":name,
"案发时间":["2018.07.02 14:23","2018.07.02 14:23","2018.07.02 14:23","2018.07.02 14:23","2018.07.02 14:23","2018.07.02 14:23","2018.07.02 14:23","2018.07.02 14:23","2018.07.02 23:34"],
"案发地点":place,
"办案⺠警":bamj,
"案件性质":ajxz,
"报警⼈":people,
"联系电话":["13522511892","13522511892","13522511892","13522511892","13522511892","13522511892","13522511892","13522511892","13522511892","13522511892"]
}
datasource = ["本地","浙江省"]
Rcondic = {"F1":"查询主类：案件","F2":"案发时间：2020-02-19","F3":"案件地址：南山区"}
return {
"RoundID":"R1",
"query": "查⼀下深圳这三个⽉的犯罪记录",
"RoundName": "案件筛选",
"qtime": "2020021801",
"roundKey": "user20200109s1r1",
"Rcondic": Rcondic,
"datasource": datasource,
"tablelLen": "10",
"tableName":"案件信息表",
"table":table
}
def post(self, movie_id):
parser = RequestParser()
parser.add_argument('token',
type=str,
location='headers',
required=True)
parser.add_argument('movie_comment_content', type=str, required=True)
parser.add_argument('movie_comment_title', type=str, required=True)
args = parser.parse_args(strict=True)
token = args.get('token')
user_id = verify_token(token)
if user_id is None:
return {'message': 'Illegal token.'}, 403
movie_com = args.get('movie_comment_content')
movie_com_t = args.get('movie_comment_title')
cursor.execute(
"INSERT into Movie_Comments(Movie_comment_title, Movie_comment_approve, Movie_comment_disapprove, \
Movie_comment_content, User_id, Movie_id) \
values('%s','%d','%d','%s','%d','%d')" %
(movie_com_t, 0, 0, movie_com, user_id, movie_id))
connection.commit()
cursor.execute("SELECT LAST_INSERT_ID()")
connection.commit()
result = cursor.fetchone()['LAST_INSERT_ID()']
cursor.execute(
"SELECT * FROM Movie_Comments where Movie_comment_id = '%d'" %
result)
result = cursor.fetchone()
result['Create_time'] = str(result['Create_time'])
connection.commit()
return {'result': result}
def post(self):
"""
@@@
## 用户登录
### args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| username | false | string | 用户名 |
| password | false | string | 密码 |
### return
- #### data
> | 字段 | 可能不存在 | 类型 | 备注 |
|--------|--------|--------|--------|
| token | false | string | 用于验证身份的token |
@@@
"""
parser = RequestParser()
parser.add_argument('username', type=str, required=True)
parser.add_argument("password", type=str, required=True)
req = parser.parse_args()
username = req.get('username')
password = req.get('password')
users = db.collection('user')
user = users.document(username).get()
if not user.exists:
return{
'success': False,
'message': '用户名或密码错误'}, 403
pwhash = user.to_dict()['password']
if check_password_hash(pwhash, password):
data = {'token': create_token(username)}
return{
'success': True,
'data': data},
else:
return{
'success': False,
'message': '用户名或密码错误'}, 403
def add_pet():
parser = RequestParser()
parser.add_argument("name", type=str, required=True)
parser.add_argument("id", type=int, required = True)
parser.add_argument("photoUrls", required=True)
parser.add_argument("status", type=str,
choices=["available", "pending", "sold"], required=True,
help="Invalid. Status is either available, pending, or sold.")
args = parser.parse_args()
#if id isn't unique
for pet in pets:
if (pet["id"] == args["id"]):
return "invalid input", 405
new_pet = {
"id": args["id"],
"category": {
"id": args["id"],
"name": args["name"]
},
"name": args["name"],
"photoUrls": [
args["photoUrls"]
],
"status": args["status"]
}
pets.append(new_pet)
return jsonify(new_pet), 201
def post():
json_parser = RequestParser()
json_parser.add_argument('categories',
type=int,
required=True,
location='json')
json_parser.add_argument('content',
type=str,
required=True,
location='json')
json_parser.add_argument('title',
type=str,
required=True,
location='json')
args = json_parser.parse_args()
try:
content = Content(title=args.title,
content=args.content,
category_id=args.categories)
db.session.add(content)
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
db.session.commit()
return {"message": 'add error'}, 405
return "ok"
def get(self):
# parse inputs
parser = RequestParser(bundle_errors=True)
date_format = '%d-%m-%Y'
date_type = lambda x: datetime.strptime(x, date_format)
order_options = ('ups', 'comments')
parser.add_argument(
'order',
choices=order_options,
help='{error_msg}. Possible values for parameter are: %s' %
(str(order_options)),
required=True)
parser.add_argument('start', required=True, type=date_type)
parser.add_argument('end', required=True, type=date_type)
args = parser.parse_args()
if args['start'] > args['end']:
return {
'message':
"The 'start' param must be a date prior to the date 'end' param"
}, 400
# get data
request = ListPostsRequest(args['order'], args['start'], args['end'])
uc = ListPostsUseCase()
response = uc.execute(request)
# internal errors during execution
if response.has_errors:
return response.errors, 500
posts = [p.to_dict() for p in response.data]
return posts
class IntegratedLookupResource(ExtResource):
"""
Endpoint in charge of doing the integrated lookup between Mendeley and
Crossref
"""
def __init__(self):
self.parser = RequestParser()
self.parser.add_argument('ref',
type=str,
required=True,
location='values')
self.parser.add_argument('getall',
type=bool,
required=False,
location='values')
self.parser.add_argument('getboth',
type=bool,
required=False,
location='values')
def get(self):
data = self.parser.parse_args()
ref = unquote(data['ref']).strip()
get_all = data.get('getall', False)
get_both = data.get('getboth', False)
return integrated_lookup(ref, return_all=get_all, return_both=get_both)
def post(self):
return self.get()
def post(self):
"""
@@@
## 取消订阅项目
### header args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| token | false | string | token |
### args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| fund_id | false | string | 订阅的项目id |
### return
无data
@@@
"""
parser = RequestParser()
parser.add_argument('token',
type=str,
required=True,
location='headers')
parser.add_argument('fund_id', type=str, required=True)
req = parser.parse_args()
token = req.get('token')
fund_id = req.get('fund_id')
username = verify_token(token)
if username == None:
return {'success': False, 'message': 'token无效'}, 403
subscribes = db.collection('subscribe').where(u'username', u'==',
username).where(
u'fund_id', u'==',
fund_id).get()
for subscribe in subscribes:
db.collection('subscribe').document(subscribe.id).delete()
return {'success': True, 'message': '取消订阅成功'}
return {'success': False, 'message': '您未订阅该项目'}, 403
def validate(self):
valid = RequestParser(bundle_errors=True)
valid.add_argument("entity", required=True)
valid.add_argument("query", required=True)
valid.add_argument("body", required=True)
return valid.parse_args()
def get(self):
"""
获取关注的用户列表
"""
qs_parser = RequestParser()
qs_parser.add_argument('page',
type=inputs.positive,
required=False,
location='args')
qs_parser.add_argument(
'per_page',
type=inputs.int_range(
constants.DEFAULT_USER_FOLLOWINGS_PER_PAGE_MIN,
constants.DEFAULT_USER_FOLLOWINGS_PER_PAGE_MAX, 'per_page'),
required=False,
location='args')
args = qs_parser.parse_args()
page = 1 if args.page is None else args.page
per_page = args.per_page if args.per_page else constants.DEFAULT_USER_FOLLOWINGS_PER_PAGE_MIN
results = []
followings = cache_user.UserFollowingCache(g.user_id).get()
followers = cache_user.UserFollowersCache(g.user_id).get()
total_count = len(followings)
req_followings = followings[(page - 1) * per_page:page * per_page]
for following_user_id in req_followings:
user = cache_user.UserProfileCache(following_user_id).get()
results.append(
dict(id=following_user_id,
name=user['name'],
photo=user['photo'],
fans_count=user['fans_count'],
mutual_follow=following_user_id in followers))
return {
'total_count': total_count,
'page': page,
'per_page': per_page,
'results': results
}
def post(self):
"""
@@@
## 申诉被冒领的作者
### header args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| token | false | string | |
### args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| author_id | false | string | 认领的作者id |
| description | false | string | 申诉理由 |
### return
- #### data
> 返回创建的申诉
@@@
"""
parser = RequestParser()
parser.add_argument('token', type=str,
required=True, location='headers')
parser.add_argument('author_id', type=str, required=True)
parser.add_argument('description', type=str, required=True)
req = parser.parse_args()
token = req.get('token')
author_id = req.get('author_id')
description = req.get('description')
username = verify_token(token)
if username == None:
return{
'success': False,
'message': 'token无效'}, 403
author_ref = db.collection('author').document(author_id)
author = author_ref.get()
if not author.exists:
return{
'success': False,
'message': '作者不存在'}, 403
if not 'bind_user' in author.to_dict():
return{
'success': False,
'message': '作者未被认领'}, 403
data = {
'author_id': author_id,
'username': username,
'description': description,
'status': 0,
}
t = time.time()
r_id = str(int(round(t * 1000)))
db.collection('report').document(r_id).set(data)
data['author'] = author.to_dict()
return{
'success': True,
'data': data}
def put(self):
"""
批量通过/驳回
"""
json_parser = RequestParser()
json_parser.add_argument('legalize_ids',
action='append',
type=inputs.positive,
required=True,
location='json')
json_parser.add_argument('status',
type=inputs.int_range(2, 3),
required=True,
location='json')
json_parser.add_argument('reject_reason', location='json')
args = json_parser.parse_args()
legalizes = LegalizeLog.query.filter(
LegalizeLog.id.in_(args.legalize_ids))
user_ids = [legal.user_id for legal in legalizes.all()]
count = legalizes.update({'status': args.status},
synchronize_session=False)
if args.status == LegalizeLog.STATUS.REJECT:
legalizes.update(
{'reject_reason': args.reject_reason or '资料不通过，驳回'},
synchronize_session=False)
User.query.filter(User.id.in_(user_ids)).update(
{'is_media': False}, synchronize_session=False)
elif args.status == LegalizeLog.STATUS.APPROVED:
User.query.filter(User.id.in_(user_ids)).update(
{'is_media': True}, synchronize_session=False)
db.session.commit()
return {'count': count}, 201
def put(self, target):
"""
修改频道
"""
json_parser = RequestParser()
json_parser.add_argument('name', required=True, location='json')
json_parser.add_argument('is_visible', type=inputs.int_range(0, 1), required=True, location='json')
json_parser.add_argument('sequence', type=inputs.positive, location='json')
args = json_parser.parse_args()
channel = Channel.query.filter_by(id=target).first()
if not channel:
return {'message': 'Invalid channel id.'}, 400
if args.name is not None and args.name != channel.name:
if Channel.query.filter_by(name=args.name).first():
return {'message': '{} already exists'.format(args.name)}, 403
channel.name = args.name
if args.is_visible is not None:
channel.is_visible = args.is_visible
if args.sequence is not None:
channel.sequence = args.sequence
db.session.add(channel)
db.session.commit()
return marshal(channel, ChannelListResource.channel_fields), 201
def post(self):
"""
用户点赞
"""
json_parser = RequestParser()
json_parser.add_argument('target',
type=parser.article_id,
required=True,
location='json')
json_parser.add_argument('type',
type=self._report_type,
required=True,
location='json')
json_parser.add_argument('remark',
type=str,
required=False,
location='json')
args = json_parser.parse_args()
try:
report = Report(user_id=g.user_id,
article_id=args.target,
type=args.type)
if args.type == Report.TYPE.OTHER and args.remark:
report.remark = args.remark
db.session.add(report)
db.session.commit()
except IntegrityError:
return {'message': 'User has reported this article.'}, 409
return {'target': args.target, 'type': args.type}, 201
def post(self):
auth_parser = RequestParser()
auth_parser.add_argument('user_email',
type=parser.email,
required=True,
location='json')
auth_parser.add_argument('password', required=True, location='json')
auth_parser.add_argument('user_name', required=True, location='json')
args = auth_parser.parse_args()
user_email = args.user_email
password = args.password
user_name = args.user_name
user_target = User.query.filter_by(email=user_email).first()
if user_target is None:
# snowflake
user_id = current_app.snowflake.get_id()
salt = gensalt()
password = password.encode('utf-8')
password = hashpw(password, salt)
user = User(id=user_id,
email=user_email,
password=password,
name=user_name,
last_login=datetime.now())
db.session.add(user)
db.session.commit()
token, refresh_token = self._generate_tokens(user_id, user_name)
return {'token': token, 'refresh_token': refresh_token}, 201
else:
return {'message': 'User exist'}, 400
def get(self):
"""
@@@
# 根据机构获取作者
# args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| org | false | string | 机构名称 |
| start_after | true | string | 偏移游标 |
# return
- #### data
> | 字段 | 可能不存在 | 类型 | 备注 |
|--------|--------|--------|--------|
| \ | false | list | 属于该机构的作者 |
@@@
"""
parser = RequestParser()
parser.add_argument("org", type=str, location="args", required=True)
parser.add_argument("start_after",
type=str,
location="args",
required=False)
req = parser.parse_args()
org = req.get("org")
start_after = req.get("start_after")
authors = []
ref = db.collection('author').where(u'orgs', u'==', org)
start_after = db.collection('author').document(start_after).get()
if start_after.exists:
ref = ref.start_after(start_after).limit(20).get()
else:
ref = ref.limit(20).get()
for author in ref:
a_id = author.id
author = author.to_dict()
author['id'] = a_id
authors.append(author)
return {'success': True, 'data': authors}
def update_pet(pet_id):
#give error if id is invalid
try:
int(pet_id)
except ValueError:
return "invalid id supplied", 400
for pet in pets:
if (pet_id == str(pet["id"])):
parser = RequestParser()
parser.add_argument("name", type=str)
parser.add_argument("photoUrls", type=str)
parser.add_argument("status", type=str)
#parser.add_argument("category", type = json.loads)
args = parser.parse_args()
if args["name"] is not None:
pet["name"]= args["name"]
pet["category"]["name"] = args["name"]
if args["photoUrls"] is not None:
pet["photoUrls"]= args["photoUrls"]
if args["status"] is not None:
pet["status"]= args["status"]
#pet["category"].update(args["category"].my_dict)
return jsonify(pet), 200
#id doesn't match
return "pet not found", 404
def post(self):
"""
用户收藏文章
"""
req_parser = RequestParser()
req_parser.add_argument('target',
type=parser.article_id,
required=True,
location='json')
req_parser.add_argument('Trace',
type=inputs.regex(r'^.+$'),
required=False,
location='headers')
args = req_parser.parse_args()
target = args.target
# 记录埋点日志
if args.Trace:
article = cache_article.ArticleInfoCache(target).get()
write_trace_log(args.Trace, channel_id=article['ch_id'])
ret = 1
try:
collection = Collection(user_id=g.user_id, article_id=target)
db.session.add(collection)
db.session.commit()
except IntegrityError:
db.session.rollback()
ret = Collection.query.filter_by(user_id=g.user_id, article_id=target, is_deleted=True) \
.update({'is_deleted': False})
db.session.commit()
if ret > 0:
cache_user.UserArticleCollectionsCache(g.user_id).clear()
cache_statistic.ArticleCollectingCountStorage.incr(target)
cache_statistic.UserArticleCollectingCountStorage.incr(g.user_id)
return {'target': target}, 201
def get(self):
# 获取请求参数
parser = RequestParser()
parser.add_argument('channel_id', location='args')
parser.add_argument('timestamp', location='args')
args = parser.parse_args()
channel_id = args.channel_id
timestamp = args.timestamp
from app import db
article_list = db.session. \
query(User.name, Article.user_id, Article.id, Article.comment_count, Article.title, Article.cover,
Article.ctime). \
join(Article, User.id == Article.user_id). \
filter(Article.channel_id == channel_id, Article.status == Article.STATUS.APPROVED,
Article.ctime < timestamp).all()
results_list = []
for article in article_list:
article_dict = {
'art_id': article.id,
'title': article.title,
'aut_id': article.user_id,
'pubdate': article.ctime.isoformat(),
'aut_name': article.name,
'comm_count': article.comment_count,
'cover': article.cover,
}
results_list.append(article_dict)
# articles = [
# {
# 'art_id': item.id,
# 'title': item.title,
# 'aut_id': item.user_id,
# 'pubdate': item.ctime.isoformat(),
# 'aut_name': item.name,
# 'comm_count': item.comment_count,
# 'cover': item.cover
# }
# for item in article_list]
return {'pre_timestamp': timestamp, 'results': results_list}
def put(self, id):
parser = RequestParser(trim=True)
parser.add_argument('remark', type=str)
args = parser.parse_args(strict=True)
member = Member.query.get(id)
if not member:
abort(400)
try:
memberInfo = MemberPersonalInfo.query.get(id)
if memberInfo:
MemberPersonalInfo.query.filter(MemberPersonalInfo.id == id).update(args)
else:
args['id'] = id
memberInfo = MemberPersonalInfo(**args)
db.session.add(memberInfo)
db.session.commit()
except:
db.session.rollback()
db.session.remove()
abort(500)
return make_response([])
class ValidFBResource(Resource):
"""
验证FB登陆
"""
def __init__(self):
self.parser = RequestParser()
def post(self):
self.parser.add_argument("accessToken",
type=str,
required=True,
location="json",
help='accessToken format is incorrect')
self.parser.add_argument("userID",
type=str,
required=True,
location="json",
help='userID format is incorrect')
self.parser.add_argument("inviterId",
type=str,
location="json",
help='inviterId format is incorrect')
args = self.parser.parse_args()
url = "https://graph.facebook.com/debug_token?access_token=" + config.APP_ID + "%7C" + config.APP_Secret + "&input_token=" + args.accessToken
result = requests.get(url)
result = json.loads(result.content)
if result.get("data").get("is_valid"):
url = "https://graph.facebook.com/" + args.userID + "?fields=name,email,gender,hometown&access_token=" + args.accessToken
result = requests.get(url)
result = json.loads(result.content)
MallUserEmailInfo = MallUsersModel.query.filter_by(
email=result.get("email")).all()
if not MallUserEmailInfo:
avatar = 'https://graph.facebook.com/' + args.userID + '/picture'
mallUser = MallUsersModel(email=result.get("email"),
username=result.get("name").replace(
' ', ''),
facebook=args.userID,
avatar=avatar,
point=config.Inviter_Point,
registered_on=int(time.time()))
MallUsersModel.add(MallUsersModel, mallUser)
if args.inviterId:
inviteEmail = base64.b64decode(args.inviterId)
inviter = InvitersModel(invite=inviteEmail,
invited=result.get("email"))
InvitersModel.add(InvitersModel, inviter)
userInfo = InvitersModel.query.filter_by(
email=inviteEmail).first()
userInfo.point = config.Inviter_Point
InvitersModel.update(userInfo)
# if not user.id:
# return pretty_result(code.ERROR, msg='Login fail by Facebook.')
return AuthorizationResource.post(AuthorizationResource,
username=args.userID,
type="fb")
# return pretty_result(code.OK, data=result, msg='Facebook login successful.')
else:
return pretty_result(code.ERROR, msg='Facebook is not valid.')
def get(self):
parser = RequestParser(trim=True)
parser.add_argument('memberUsername', type=str)
parser.add_argument('timeLower', type=int)
parser.add_argument('timeUpper', type=int)
args = parser.parse_args(strict=True)
criterion = set()
if args['memberUsername']:
criterion.add(
RebateDetail.memberUsername == args['memberUsername'])
if args['timeLower']:
criterion.add(RebateDetail.time > args['timeLower'])
if args['timeUpper']:
criterion.add(
RebateDetail.time < args['timeUpper'] + SECONDS_PER_DAY)
details = RebateDetail.query.filter(*criterion).all()
total_rebate_amount = 0
for detail in details:
total_rebate_amount += detail.rebateAmount
return make_response(details, totalRebateAmount=total_rebate_amount)
def post(self) -> JsonResponse:
parser = RequestParser()
parser.add_argument('image',
type=FileStorage,
required=True,
help="image missing in post body",
location='files')
args = parser.parse_args()
image = args['image']
filename = secure_filename(image.filename)
mimetype = image.mimetype or guess_type(filename)[0]
if mimetype not in ALLOWED_MIMETYPES:
return {'error_msg': ERROR_BAD_IMAGE_FORMAT},\
HTTPStatus.BAD_REQUEST.value
img_id = str(uuid4())
image_type = mimetype.split('/')[1]
image_filename = '{}.{}'.format(img_id, image_type)
domain.upload_image(image.stream, img_id, image_filename)
return {'img_id': img_id}
class Order(ApiResource):
def __init__(self):
self.parser = RequestParser()
self.parser.add_argument('order_id', type=str)
self.parser.add_argument('operation', type=str)
# @orders.route('/get_order', methods=['POST'])
# @login_required
def get(self):
data = self.parser.parse_args()
order_id = data['order_id']
order = order_controller.get_order(order_id)
return jsonify(order)
# @orders.route('/<string:order_id>/close', methods=['POST'])
# @login_required
# @orders.route('/<string:order_id>/checkout', methods=['POST'])
# @login_required
def post(self):
data = self.parser.parse_args()
operation = data['operation']
order_id = data['order_id']
if operation == 'close':
try:
order = order_controller.close_order(order_id)
except Exception as e:
traceback.print_exc()
return str(e), 409
return jsonify(order)
elif operation == 'checkout':
try:
order = order_controller.checkout_order(order_id)
except Exception as e:
traceback.print_exc()
return str(e), 409
return jsonify(order)
else:
return '', 404
class DeleteCourseFromEnrollment(Resource):
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument('course_id', type=str, required= True, help="Course ID (crn) is required to delete course from enrollment schedule", location='json')
super(DeleteCourseFromEnrollment, self).__init__()
def delete(self):
args = self.reqparse.parse_args()
if 'username' in session:
username = session['username']
course_id = args['course_id']
enrollmentRepository = EnrollmentRepository()
enrollmentRepository.delete_by_username_and_course_id(username, course_id)
enrollmentRepository.save_changes()
return {
"message": "Course has been deleted successfully.",
"username": username,
"crn": course_id
}
else:
return {"error": "There is no currently logged in account."}, 401
class UserLogin(Resource):
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument('username', type=str, required= True, help="GaTech Username is required to login", location='json')
self.reqparse.add_argument('password', type=str, required= True, help="Password is required to login", location='json')
super(UserLogin, self).__init__()
def post(self):
args = self.reqparse.parse_args()
username = args['username']
password = args['password']
userRepository = UserRepository()
if userRepository.check_username_and_password(username, password): #true if correct, false if bad credentials
accountType = userRepository.get_account_type(username)
session['username'] = username
return {
"message": "User has been logged in successfully.",
"username": username,
"accountType": accountType
}
return {"error": "This username and password combination is not valid."}, 401
def wrapped(*args, **kwargs):
parser = RequestParser()
parser.add_argument('event_id',
type=str,
location='json',
help='This field cannot be blank',
required=True)
parser.add_argument('bestshots',
type=list,
location='json',
help='This field cannot be blank',
required=True)
g.data = data = parser.parse_args()
json = request.json
# check event_id
if not data['event_id'].isdigit():
return {'message': 'event_id field should be int'}, 400
# check if group json or bestshots list are empty
if not json['bestshots'] \
or not isinstance(json['bestshots'], list) \
or any(map(lambda x: not isinstance(x, str), json['bestshots'])):
return {
'message':
'bestshots field should not be empty and its elements are str'
}, 400
# check if event exists
event_id = int(data['event_id'])
event = EventModel.query.get(event_id)
if not event:
return {
'message': 'Event id {} does not exist'.format(event_id)
}, 404
return fn(*args, **kwargs)
