def basic_auth_error():
return error_response(401)
def token_auth_error():
'''用于在 Token Auth 认证失败的情况下返回错误响应'''
return error_response(401)
def token_auth_error():
return error_response(401)
def basic_auth_error(status):
return error_response(status)
def basic_auth_error():
return error_response(401)
def basic_auth_error():
"""用于在认证失败的情况下返回错误响应"""
return error_response(401)
def get_user_recived_posts_likes(id):
'''返回该用户收到的文章喜欢'''
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['POSTS_PER_PAGE'],
type=int), 100)
# 用户哪些文章被喜欢/收藏了，分页
posts = user.posts.join(posts_likes).paginate(page, per_page)
# 喜欢记录
records = {
'items': [],
'_meta': {
'page': page,
'per_page': per_page,
'total_pages': posts.pages,
'total_items': posts.total
},
'_links': {
'self':
url_for('api.get_user_recived_posts_likes',
page=page,
per_page=per_page,
id=id),
'next':
url_for('api.get_user_recived_posts_likes',
page=page + 1,
per_page=per_page,
id=id) if posts.has_next else None,
'prev':
url_for('api.get_user_recived_posts_likes',
page=page - 1,
per_page=per_page,
id=id) if posts.has_prev else None
}
}
for p in posts.items:
# 重组数据，变成: (谁) (什么时间) 喜欢了你的 (哪篇文章)
for u in p.likers:
if u != user: # 用户自己喜欢自己的文章不需要被通知
data = {}
data['user'] = u.to_dict()
data['post'] = p.to_dict()
# 获取喜欢时间
res = db.engine.execute(
"select * from posts_likes where user_id={} and post_id={}"
.format(u.id, p.id))
data['timestamp'] = datetime.strptime(
list(res)[0][2], '%Y-%m-%d %H:%M:%S.%f')
# 标记本条喜欢记录是否为新的
last_read_time = user.last_posts_likes_read_time or datetime(
1900, 1, 1)
if data['timestamp'] > last_read_time:
data['is_new'] = True
records['items'].append(data)
# 按 timestamp 排序一个字典列表(倒序，最新喜欢的人在最前面)
records['items'] = sorted(records['items'],
key=itemgetter('timestamp'),
reverse=True)
# 更新 last_posts_likes_read_time 属性值
user.last_posts_likes_read_time = datetime.utcnow()
# 将新喜欢通知的计数归零
user.add_notification('unread_posts_likes_count', 0)
db.session.commit()
return jsonify(records)
def basic_auth_error():
'''when failure of auth check'''
return error_response(401)
def get_course_distributions_no_subject(campus, subject):
result = [row.to_dict() for row in CDist.query.filter_by(campus=campus, subject=subject).all()]
return jsonify(result) if result != [] else error_response(404, "Not Found")
def token_auth_error():
'''用于在token auth 认证失败的情况下返回错误相应'''
return error_response(401)
def get_notifications(id):
notification = Notification.query.get_or_404(id)
if g.current_user != notification.user:
return error_response(403)
data = notification.to_dict()
return jsonify(data)
def token_auth_error(status):
"""错误指向"""
return error_response(status)
def delete_product(id):
return error_response(501)
def update_product(id):
return error_response(501)
def create_product():
return error_response(501)
def get_professors(campus, subject, course):
result = [row.to_dict() for row in Educator.query.filter_by(campus=campus, subject=subject, course=g.course, detail=g.detail).all()]
return jsonify(result) if result != [] else error_response(404, "Not Found")
def token_auth_error():
'''
Called when token auth fails
'''
return error_response(401) # Unauthorized
def get_professors_no_subject(campus, subject):
result = [row.to_dict() for row in Educator.query.filter_by(campus=campus, subject=subject).all()]
return jsonify(result) if result != [] else error_response(404, "Not Found")
def token_auth_error():
"""用于在 Token Auth 认证失败的情况下返回错误响应"""
return error_response(401)
def get_average_history(campus, subject, course):
result = CourseAverageHistory.query.filter_by(campus=campus, subject=subject, course=g.course, detail=g.detail).one_or_none()
return jsonify(result.to_dict()) if result is not None else error_response(404, "Not Found")
def decorated_function(*args, **kwargs):
if not g.current_user.can(
permission
): # 用户通过了Basic Auth认证后，就会在当前会话中附带 g.current_user
return error_response(403)
return f(*args, **kwargs)
def get_average_history_no_subject(campus, subject):
result = [row.to_dict() for row in CourseAverageHistory.query.filter_by(campus=campus, subject=subject).all()]
return jsonify(result) if result != [] else error_response(404, "Not Found")
def auth_error():
"""Sends authentication error back to client."""
return error_response(401)
def get_tower_settings(tower_id):
tower = TowerDB.query.get_or_404(tower_id)
if not current_user.check_permissions(tower_id, 'creator'):
return error_response(403)
return jsonify(tower.to_dict())
def get_user_recived_likes(id):
'''返回该用户收到的赞和喜欢'''
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['COMMENTS_PER_PAGE'],
type=int), 100)
# 用户哪些评论被点赞了，分页
comments = user.comments.join(comments_likes).paginate(page, per_page)
# 点赞记录
records = {
'items': [],
'_meta': {
'page': page,
'per_page': per_page,
'total_pages': comments.pages,
'total_items': comments.total
},
'_links': {
'self':
url_for('api.get_user_recived_likes',
page=page,
per_page=per_page,
id=id),
'next':
url_for('api.get_user_recived_likes',
page=page + 1,
per_page=per_page,
id=id) if comments.has_next else None,
'prev':
url_for('api.get_user_recived_likes',
page=page - 1,
per_page=per_page,
id=id) if comments.has_prev else None
}
}
for c in comments.items:
# 重组数据，变成: (谁) (什么时间) 点赞了你的 (哪条评论)
for u in c.likers:
data = {}
data['user'] = u.to_dict()
data['comment'] = c.to_dict()
# 获取点赞时间
res = db.engine.execute(
"select * from comments_likes where user_id={} and comment_id={}"
.format(u.id, c.id))
data['timestamp'] = datetime.strptime(
list(res)[0][2], '%Y-%m-%d %H:%M:%S.%f')
# 标记本条点赞记录是否为新的
last_read_time = user.last_likes_read_time or datetime(1900, 1, 1)
if data['timestamp'] > last_read_time:
data['is_new'] = True
records['items'].append(data)
# 按 timestamp 排序一个字典列表(倒序，最新关注的人在最前面)
records['items'] = sorted(records['items'],
key=itemgetter('timestamp'),
reverse=True)
# 还需要考虑分页的问题，比如新点赞有25条，默认分页是每页10条，
# 如果用户请求第一页时就更新 last_likes_read_time，那么后15条就被认为不是新点赞了，这是不对的
if records['_meta']['page'] * records['_meta'][
'per_page'] >= user.new_likes():
# 更新 last_likes_read_time 属性值
user.last_likes_read_time = datetime.utcnow()
# 将新点赞通知的计数归零
user.add_notification('unread_likes_count', 0)
else:
# 用户剩余未查看的新点赞数
n = user.new_likes(
) - records['_meta']['page'] * records['_meta']['per_page']
# 将新点赞通知的计数更新为未读数
user.add_notification('unread_likes_count', n)
db.session.commit()
return jsonify(records)
def token_auth_error(status):
return error_response(status)
def basic_auth_error():
# 401 is HTTP Unauthorized error.
return error_response(401)
def test_dca(wellName):
supported_modes = ["cumulative", "exponential", "harmonic", "hyperbolic"]
try:
options = request.get_json()
except Exception as ex:
print(ex)
return error_response(400,
"One or more required parameters are missing")
try:
feedDf = pd.read_sql(
"select readdate, oilrate, waterrate, gasrate from casedata where user='******' and well='{}'"
.format(g.current_user.username, wellName),
con=db.engine)
except:
return error_response(400, "reading from table failed")
try:
date_fmt = "%m/%d/%Y"
date_arr = []
for i in range(len(feedDf)):
dt = datetime.datetime.strptime(feedDf['readdate'][i], date_fmt)
date_arr.append(dt)
feedDf['date'] = date_arr
feedDf.sort_values(by=['date'], ascending=True, inplace=True)
feedDf.drop(columns=['readdate'], inplace=True)
except:
return error_response(500, "error reading date field")
output = []
try:
for idx, opt in enumerate(options):
ref = opt.get("ref", idx)
try:
mode = opt.get("mode", None)
if (mode is None):
raise ValueError("required parameter mode is not supplied")
if (not (mode in supported_modes)):
raise ValueError("mode {} is not supported".format(mode))
datasource = opt.get("datasource", None)
if (datasource is not None
and datasource not in feedDf.columns):
raise ValueError(
"datasource {} could not be found".format(datasource))
qiOverride = opt.get("qi", None)
if (qiOverride is None and datasource is None):
raise ValueError(
"either qi or datasource must be supplied")
t = opt.get("tSpan", None)
if (t is None and datasource is None):
raise ValueError(
"tSpan cannot be empty when datasource is not supplied"
)
if (t is not None and t < 1):
raise ValueError("value of t must be greater than 0")
if (datasource is not None and len(feedDf) == 0):
raise ValueError(
"no data is available for the supplied criteria")
tStep = opt.get("tStep", 1)
if (tStep <= 0):
raise ValueError("value of tStep must be greater than 0")
a = opt.get("a", None)
n = opt.get("n", None)
dca_result = []
qiOverride = qiOverride if qiOverride is not None else feedDf[
datasource][0]
outputDf = pd.DataFrame()
outputDf["time"] = feedDf[
"date"] if datasource is not None else np.arange(
1, t, tStep)
inputDf = pd.DataFrame()
if (datasource is not None):
inputDf["time"] = feedDf["date"]
inputDf["value"] = feedDf[datasource]
pearsonr = 0.0
tIntervals = len(outputDf)
if (mode == "cumulative"):
if (datasource is None):
raise ValueError(
"required parameter datasource is not supplied")
dca_result = dca.cumulative(feedDf[datasource])
else:
dca_result = dca.calc(qiOverride,
tIntervals,
mode,
a=a,
n=n)
pearsonr = dca.r2(
feedDf[datasource],
dca_result) if datasource is not None else pearsonr
outputDf["value"] = dca_result
output_dict = outputDf.to_dict('records')
input_dict = inputDf.to_dict('records')
result = {}
if (mode == "cumulative"):
result = dcaVMs.cumulative_resp_model(
mode=mode,
wellName=wellName,
datasource=datasource,
input=input_dict,
output=output_dict,
ref=ref)
if (mode == "exponential"):
result = dcaVMs.exponential_resp_model(
mode=mode,
wellName=wellName,
datasource=datasource,
input=input_dict,
output=output_dict,
qi=qiOverride,
a=a,
t=t,
tStep=tStep,
pearsonr=pearsonr,
ref=ref)
if (mode == "harmonic"):
result = dcaVMs.exponential_resp_model(
mode=mode,
wellName=wellName,
datasource=datasource,
input=input_dict,
output=output_dict,
qi=qiOverride,
a=a,
t=t,
tStep=tStep,
pearsonr=pearsonr,
ref=ref)
if (mode == "hyperbolic"):
result = dcaVMs.exponential_resp_model(
mode=mode,
wellName=wellName,
datasource=datasource,
input=input_dict,
output=output_dict,
qi=qiOverride,
a=a,
t=t,
n=n,
tStep=tStep,
pearsonr=pearsonr,
ref=ref)
output.append(result)
except ValueError as ve:
print(ve)
result = {"ref": ref, "error": {"message": str(ve)}}
output.append(result)
except Exception as ex:
print(ex)
return error_response(500, str(ex))
response = jsonify(output)
response.headers.set("Content-Type", "application/json")
return response
def basic_auth_error():
'''用于在认证失败的情况下返回错误响应'''
return error_response(401)
def basic_auth_error():
'''
Called when authentication fails
'''
return error_response(401) # Unauthorized
def token_auth_error():
return error_response(401)
def product(id):
product = Product.query.get(id)
if not product:
return error_response(404)
return product_schema.dump(product)
