def labeler_task():
"""
标注员任务界面
:return:
"""
page = request.args.get('page')
rows = request.args.get('pagerows')
user = request.args.get('nickname')
# 先查找是否有返工数据，如果有的话，不查询redis缓存
if redis_client.get('task_list_%s_%s_%s' % (user, page, rows)):
return redis_client.get('task_list_%s_%s_%s' % (user, page, rows))
print('获取新的任务列表')
# 任务数量
tasks = Task.get_undone_task(page, rows)
undone_task_count = Task.get_undone_task_count()
labeler_task = LabelTaskCollection()
now_time = int(time.time())
today_start_time = now_time - (now_time - time.timezone) % 86400
rework_data = True if Rework().get_rework_data(user) else ''
labeler_task.fill(undone_task_count, tasks, user, today_start_time,
rework_data)
# task.get('already_count') =Ta a
# labeltaskviewmodel = LabelTaskViewModel()
# 此处还差已完成数量、当前用户标注量、当前用户框数三个信息。
redis_client.set('task_list_%s_%s_%s' % (user, page, rows),
json.dumps(labeler_task, default=lambda o: o.__dict__))
return json.dumps(labeler_task, default=lambda o: o.__dict__)
def validate_auth_code():
"""
POST Auth code validation
---
responses:
200:
description: Returns result of code verification
"""
sess_token = request.cookies.get('sess_token')
if not sess_token or sess_token is None:
return redirect(url_for('api.v1.post_email_auth'), code=302)
content = request.get_json()
auth_code = content.get('code')
if not auth_code or auth_code is None:
return jsonify({"result": {"message": "no code provided"}}), 400
if auth_code != redis_client.get(f'authcode_{sess_token}'):
return jsonify({"result": {"message": "wrong code"}}), 400
resp = make_response(jsonify({"result": {"message": "ok"}}), 200)
user_id = redis_client.get(f'sess_token_{sess_token}')
ttl = 60 * 60 * 24 * 31 # 31 days
sess_id = SessToken()
redis_client.set(name=f'sessid_{sess_id.value}', value=user_id, ex=ttl)
redis_client.delete(f'authcode_{sess_token}')
redis_client.delete(f'sess_token_{sess_token}')
session['sessid'] = sess_id.value
return resp
def login():
error = None
WAIT_TIME = (16)
hint_list = [
"HINT: the surface on Mars",
"HINT: What is the surface material on Mars called?",
"HINT: Look on the surface of Mars",
"HINT: Look closely, the definition is inscribed here"
]
if request.method == 'POST':
if (request.form['password']).casefold() != "regolith":
hint = int(session['hint'])
error = 'Invalid Credentials. Please try again.'
attempts = int(session['failed_attempts'])
attempts += 1
if attempts == 2:
flash(hint_list[hint])
session['hint_timer'] = time.time()
session['hint'] = 1
if attempts > 2:
elapsed_time = (time.time() - session['hint_timer'])
if hint < 3:
if elapsed_time <= WAIT_TIME:
error = "Invalid Credentials. Hint available in {}.".format(
format_min_sec(WAIT_TIME - elapsed_time))
else:
session['hint_timer'] = time.time()
session['hint'] = hint + 1
flash(hint_list[session['hint']])
if hint > 1:
flash(hint_list[1])
else:
flash(hint_list[3])
flash(hint_list[1])
session['failed_attempts'] = attempts
print("print working")
else:
answers = None
session['answers'] = answers
print(session.get("scenario_time"), "scen",
session.get("starttime"), "start")
session['starttime'] = float(redis_client.get("starttime"))
session['scenario_time'] = int(redis_client.get('scenariotime'))
print(session.get("scenario_time"), "scen",
session.get("starttime"), "start")
##convert startime to timevalue
return redirect(url_for('overview'))
else:
#GET request initialize variables
session['failed_attempts'] = 0
session['hint'] = 0
return render_template('login.html', error=error)
def register():
form = RegisterForm().validate_for_api()
if request.method == 'POST' and form.validate():
# 判断code是否正确
key = "note:email:{}".format(form.email.data)
if redis_client.get(key) and int(
redis_client.get(key)) != form.code.data:
raise ParameterException(msg='code码不正确,要重新获取喽', error_code=1012)
with db.auto_commit():
user = User()
user.set_attrs(form.data)
db.session.add(user)
return Success()
def post(self):
# 创建请求解析器对象
parser = RequestParser()
# 添加参数规则
parser.add_argument('mobile', location='json', required=True)
parser.add_argument('code', location='json', required=True)
# 执行解析
args = parser.parse_args()
# 获取参数
mobile = args.mobile
code = args.code
from app import redis_client
key = f'{mobile}'
# 从redis数据库获取验证码
r_code = redis_client.get(key)
# 如果验证码不存在或验证码不相等
if not r_code or r_code != code:
return {'message': 'failure', 'data': None}
user = User.query.options(load_only(User.mobile)).filter(User.mobile == mobile).first()
# 如果用户存在记录最后一次登陆时间
if user:
user.last_login = datetime.now()
# 如果不存在注册新用户,用户名字为手机号
else:
user = User(mobile=mobile, name=mobile, last_login=datetime.now())
db.session.add(user)
db.session.commit()
token = generate_jwt({'user_id': user.id},
expiry=datetime.utcnow() + timedelta(days=current_app.config['JWT_EXPIRE_DAYS']))
return {'token': token}
def find_user_by_verificatino_code(self, verification_code):
dumped_user_data = redis_client.get(verification_code)
if dumped_user_data is None:
abort(404, "Verification code not found.")
return pickle.loads(dumped_user_data)
def get_access_token(wx):
"""
获取微信access_token
:param wx: [dict]
:return:
"""
app_id, app_secret = map(wx.get, ('app_id', 'app_secret'))
if not (app_id and app_secret):
return
key = 'wx:%s:access_token' % app_id
access_token = redis_client.get(key)
if access_token:
return access_token
wx_url = 'https://api.weixin.qq.com/cgi-bin/token'
params = {
'grant_type': 'client_credential',
'appid': app_id,
'secret': app_secret
}
resp_json = requests.get(wx_url, params=params).json()
access_token, expires_in = map(resp_json.get,
('access_token', 'expires_in'))
if not (access_token and expires_in):
return
redis_client.set(key, access_token)
redis_client.expire(key, int(expires_in) - 600) # 提前10分钟更新access_token
return access_token
def queue_count():
geo = redis_client.get("geometry")
if geo:
geo = geo.decode()
else:
geo = {}
return Response(geo, mimetype="application/json")
def get_stats(self):
key = 'stats'
data = redis_client.get(key)
if data:
data = json.loads(data)
return self.response(data)
def get_jsapi_ticket(wx):
"""
获取微信jsapi_ticket
:param wx: [dict]
:return:
"""
app_id, app_secret = map(wx.get, ('app_id', 'app_secret'))
if not (app_id and app_secret):
return
key = 'wx:%s:jsapi_ticket' % app_id
jsapi_ticket = redis_client.get(key)
if jsapi_ticket:
return jsapi_ticket
access_token = get_access_token(wx)
if not access_token:
return
wx_url = 'https://api.weixin.qq.com/cgi-bin/ticket/getticket'
params = {'access_token': access_token, 'type': 'jsapi'}
resp_json = requests.get(wx_url, params=params).json()
jsapi_ticket, expires_in = map(resp_json.get, ('ticket', 'expires_in'))
if not (jsapi_ticket and expires_in):
return
redis_client.set(key, jsapi_ticket)
redis_client.expire(key, int(expires_in) - 600) # 提前10分钟更新jsapi_ticket
return jsapi_ticket
def get_product():
start = request.args.get('start')
end = request.args.get('end')
data = redis_client.get("order:amount")
print(data)
return jsonify(code=1, data=ast.literal_eval(data))
def get_endpoint_specific_json(num):
page = request.args.get('page', 1, type=int)
# creating unique redis key for product id & page number
cached_response_redis_key = f"result_{num}_{page}"
# REDIS cache used
# Trying to get data from cache with unique redis key
result = redis_client.get(cached_response_redis_key)
if result is None:
print(
"Could not find GET result in cache, REST API response served from PostgreSQL db"
)
# Getting data from the PostgreSQL db
result = get_paginated_list(Products,
'/get-endpoint-json/' + str(num),
page=request.args.get('page', 1, type=int),
per_page=app.config['REVIEWS_PER_PAGE'],
limit=app.config['REVIEWS_MAX'],
id=num)
# Saving data to cache with unique identifier for product id & page number
redis_client.set(cached_response_redis_key, json.dumps(result))
redis_client.expire(cached_response_redis_key, timedelta(seconds=10))
else:
print("Found cached GET response, serving data from REDIS")
result = json.loads(result)
return jsonify(result) # does not keep order, but beautified
def get_product_details():
from app import redis_client
args = request.args
sellerID = args["SellerID"]
print("SELLER ID: ", args["SellerID"])
data = {"success": False}
if check_redis_for_response(sellerID, redis_client):
return json.loads(redis_client.get(sellerID))
scrape_amazon_products(sellerID)
output_data = []
output_data = db['products'].find({"_id": sellerID})
print(output_data.count())
if output_data.count() != 0:
output_data = list(output_data)[0]
print('output_data', output_data)
formatted_product_info = format_scrapped_data(output_data,
'product_title')
formatted_price_info = format_scrapped_data(output_data,
'product_price')
formatted_product_image_link = format_scrapped_data(
output_data, 'product_image_link')
formatted_product_link = format_scrapped_data(output_data,
'product_link')
formatted_product_reviews_url = format_scrapped_data(
output_data, 'product_reviews_url')
formatted_asin = format_scrapped_data(output_data, 'asin')
d = {}
d["productTitle"] = formatted_product_info
d["ProductPrices"] = formatted_price_info
d["ProductImageLink"] = formatted_product_image_link
d["ProductLink"] = formatted_product_link
d["ASIN"] = formatted_asin
d["ProductReviewsUrl"] = formatted_product_reviews_url
print('length', len(d["productTitle"]), len(d["ProductPrices"]),
len(d["ProductImageLink"]), len(d["ProductLink"]),
len(d["ProductReviewsUrl"]), len(d["ASIN"]))
output = format_response_list(d, len(formatted_product_info))
data = {
"success": True,
"sellerName": output_data['seller_name'][0],
"product_count": len(d["ASIN"]),
"seller_rating": output_data['seller_ratings'],
"seller_review": output_data['seller_reviews'],
"items": output
}
response = flask.jsonify(data)
redis_client.set(sellerID, json.dumps(data), 86400)
return response
else:
return ('<h1>There was a problem scraping product details</h1>')
def get(self, where=None): ## 'where' can be 'lobby' or 'playing' or None
users = loads(redis_client.get(self._key) or '{}')
if where == 'lobby':
return [u for u in users if u.game_id is None]
elif where == 'playing':
return [u for u in users if u.game_id is not None]
else:
return users
def get(self, id):
abort_if_todo_doesnt_exist(id)
from app import redis_client
response = redis_client.get(id)
response = {
"source": response
}
return BaseResp(200, 0, '成功', response)
def index():
a = redis_client.get('potato')
resp = Response(
json.dumps("HELLO"),
status=200,
mimetype='application/json'
)
return resp
def home_order_messages_cache():
key = 'home_order_messages'
val = redis_client.get(key)
if val:
data = JSONDecoder().decode(val)
else:
data = None
return data
def home_info_cache():
key = 'home_info'
val = redis_client.get(key)
if val:
data = JSONDecoder().decode(val)
else:
data = None
return data
def oauth_code_cache(code):
key = str('OAUTH_' + code)
val = redis_client.get(key)
if not val:
redis_client.set(key, code, 10)
return False
else:
return True
def find_register_data_by_verification_code(verification_code):
AccountService.validate_verification_code(verification_code)
register_data = redis_client.get(verification_code)
if register_data is None:
abort(404, "Verification code not found.")
return json.loads(register_data.decode("utf-8"))
def cache_qrcode_code(card_id, card_code):
val = '%s-%s' % (card_id, card_code)
old_code = redis_client.get(val)
old_code and redis_client.delete(old_code)
code = random_digit(20)
redis_client.set(code, val, 70) # 每分钟刷新
redis_client.set(val, code, 70) # 每分钟刷新
return code
def get_cache_order(order_id):
val = redis_client.get('order-%s' % order_id)
if not val:
return None
tmp = JSONDecoder().decode(val)
order = Order(order_id=tmp['order_id'], card_id=tmp['card_id'], customer_id=tmp['customer_id'],
face_amount=tmp['face_amount'], card_count=tmp['card_count'], pay_amount=tmp['pay_amount'],
order_type=tmp['order_type'], paid=tmp['paid'])
return order
def order_id_increment(max_len=5):
global_order_id = redis_client.get('order_max_id')
global_order_current_date = redis_client.get('order_current_date')
if global_order_id:
global_order_id = int(global_order_id)
now_date = time.strftime('%Y%m%d')
if global_order_current_date != now_date:
global_order_id = 1
global_order_current_date = now_date
redis_client.set('order_current_date', global_order_current_date)
else:
global_order_id += 1
redis_client.set('order_max_id', global_order_id)
format_str = '{:0>%s}' % max_len
val = format_str.format(str(global_order_id))
result = '%s%s' % (now_date, val)
return result
def photo(task_id, photo_id):
task = File.query.get(task_id)
folder_name, files = pickle.loads(redis_client.get(task.filename))
print(folder_name, files)
print(files[photo_id - 1])
return render_template("single_task.html",
photo_id=str(photo_id),
folder_name=str(folder_name),
files=files)
def get(_token):
t_redis = redis_client.get(_token)
if t_redis:
return Task.from_dict(json.loads(t_redis))
else:
t = Task.query.filter_by(token=_token).first()
if not t:
raise Exception('Task does not exist!')
else:
redis_client.set(_token, json.dumps(t.to_dict()), ex=1800)
return t
def pop_cache_card_id(card_id, openid):
val = redis_client.get('%s_%s_card' % (card_id, openid))
if not val:
return None
tmp = JSONDecoder().decode(val)
if len(tmp) == 0:
return None
gid = tmp.pop()
val = JSONEncoder().encode(tmp)
redis_client.set('%s_%s_card' % (card_id, openid), val, 120)
return gid
def get(self, mobile):
rend_num = '%06d' % random.randint(0, 999999)
key = 'app:code:{}'.format(mobile)
redis_client.set(key, rend_num, ex=SMS_CODE_EXPIRE)
code = redis_client.get(key)
print(key)
print(code)
data = {}
data['mobile'] = mobile
data['code'] = rend_num
return data
def get_all(_token):
p_redis = redis_client.get(_token)
if p_redis:
p = Person.from_dict(json.loads(p_redis))
else:
p = Person.get(_token)
if not p:
raise Exception('Owner does not exist!')
tasks_redis = redis_client.get(_token + '-tasks')
if tasks_redis:
tasks = json.loads(tasks_redis)
else:
tasks = list(Task.query.filter_by(owner_id=p.id))
res = []
for t in tasks:
res.append(t.to_dict())
tasks = res
print(tasks, tasks_redis)
if not tasks_redis:
redis_client.set(_token + "-tasks", json.dumps(tasks), ex=1800)
return tasks
def post(self):
# 1.获取参数 -- post请求体以json格式传递参数
# 1.1 mobile 手机号码
# 1.2 code 用户填写的短信验证码
# 2.参数校验--RequestParser参数提取和参数校验
# 构建解析对象
parser = RequestParser()
parser.add_argument("mobile",
required=True,
location="json",
type=regex(r'^1[3-9]\d{9}$'))
parser.add_argument("code",
required=True,
location="json",
type=regex(r'\d{6}'))
param_ret = parser.parse_args()
mobile = param_ret['mobile']
sms_code = param_ret['sms_code']
# 3业务逻辑处理
key = "app:code:{}".format(mobile)
real_smscode = redis_client.get(key)
redis_client.delete(key)
if real_smscode is None:
return {"message": "短信验证码为空"}
if sms_code != real_smscode:
return {"message": "短信验证码错误"}
# 3.3 短信验证码通过
# 3.4 根据手机号码作为查询条件，查询用户对象是否存在
# select * from xxxx where xx
# 优化查询：options(load_only(User.id))
user = User.query.options(load_only(
User.id)).filter(User.mobile == mobile).first()
if user is None:
user = User(mobile=mobile, name=mobile, last_login=datetime.now())
db.session.add(user)
else:
user.last_login = datetime.now()
try:
db.session.commit()
except Exception as e:
db.session.rollback()
return {"message": f"数据库提交异常{e}"}, 507
# 3.8 生成2小时有效的登录token和14天有效的刷新token
login_token, refresh_token = self.get_token(user_id=user.id)
# 4返回值处理
return {"login_token": login_token, "refresh_token": refresh_token}
def post(self):
parser = RequestParser()
parser.add_argument('mobile',
required=True,
location='json',
type=mobile_type)
parser.add_argument('code',
required=True,
location='json',
type=regex(r'^\d{6}$'))
args = parser.parse_args()
mobile = args.mobile
code = args.code
# 验证验证码是否存在和正确:
key = 'app:code:{}'.format(mobile)
test_code = redis_client.get(key)
print(mobile)
print(code)
print(key)
print(test_code)
if not test_code or test_code != code:
return {'message': 'Invalid Code', 'data': None}, 400
# redis_client.delete(key)
# 验证成功，从数据库查找用户
conn = self.User.user
result = conn.find_one({'mobile': mobile})
if result is None or result == []:
user_data = {
'name': mobile,
'mobile': mobile,
'last_login': datetime.now(),
'age': random.randint(15, 35)
}
conn.insert_one(user_data)
result = conn.find_one({'mobile': mobile})
else:
conn.update({'mobile': mobile},
{'$set': {
'last_login': datetime.now()
}},
upsert=True)
print(result)
# 生成token
token = generate_jwt(
{'userid': str(result['_id'])},
expiry=datetime.utcnow() +
timedelta(days=current_app.config['JWT_EXPIRE_DAYS']))
return {'token': token}, 201
def check_authorization(*args, **kwargs):
if os.environ.get("ENVIRONMENT", "DEBUG") == "DEBUG":
return func(*args, **kwargs)
else:
auth_key = request.headers.get("Authorization", "")
if redis_client.get(auth_key):
return func(*args, **kwargs)
else:
return jsonify(
{
"sucess": False,
"reason": 'Invalid token. Send token as "Authorization" header',
}
), 401
