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 add(task_dict):
"""
task_dict: {
'owner_token' : str(64) -> person.token,
'due': datetime.datetime,
'title': str(),
'body': str(),
'important': bool(),
'done': bool()
}
"""
p = Person.get(task_dict['owner_token'])
if not p:
raise Exception('Owner does not exist!')
try:
t = Task(
owner_id= p.id,
due= task_dict['due'],
title= task_dict['title'],
body= task_dict['body'],
important= task_dict['important'],
done= task_dict['done'],
token=token_urlsafe(32)
)
except:
raise Exception('Problem in request dict')
redis_client.delete(Person.get_id(t.owner_id).token + '-tasks')
db.session.add(t)
db.session.commit()
redis_client.set(t.token, json.dumps(t.to_dict()), ex=1800)
return t
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 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 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 post_email_auth():
"""
POST Email auth
---
responses:
200:
description: schedule task for sending auth code to user's email
"""
content = request.get_json()
# TODO: implement validation data
email = content.get('email')
if not email or email is None:
return jsonify({"result": {"message": "no email provided"}}), 400
# get user_id from mongo
# if user_id is None: return 404
user = User.objects(email=email).first()
if user is None:
return jsonify({"result": {"message": "not found"}}), 404
ttl = 300 # 5 minutes
sess_token = SessToken()
resp = make_response(jsonify({"result": {"message": "ok"}}), 200)
redis_client.set(name=f'sess_token_{sess_token.value}',
value=user.id,
ex=ttl)
resp.set_cookie('sess_token', sess_token.value, max_age=ttl)
auth_code_task.delay(email, sess_token.value)
return resp
def register():
exist_user = User.query.filter_by(
username=request.json.get("username")).first()
if exist_user:
return generate_response(code_msg=Code.USER_EXIST)
else:
try:
new_user = User(username=request.json.get("username"),
password=request.json.get("password"),
realname=request.json.get("realname"),
email=request.json.get("email"))
# role = Role.query.filter_by(name="normal").first()
# new_user.roles.append(role)
db.session.add(new_user)
db.session.commit()
new_user_dump = user_schema.dump(new_user)
access_token = create_access_token(identity=new_user.id)
new_user_dump["permissions"] = get_permissions_from_redis(
new_user.id)
new_user_dump["roles"] = get_roles_from_redis(new_user)
redis_client.set("user_token_expired_{id}".format(id=new_user.id),
'false',
ex=current_app.config['JWT_ACCESS_TOKEN_EXPIRES'])
new_user_dump["access_token"] = access_token
return generate_response(data=new_user_dump)
except Exception as e:
current_app.logger.error(str(e))
db.session.rollback()
return generate_response(code_msg=Code.REGISTER_FAILED)
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 do_send(app, msg, code, to):
with app.app_context():
try:
mail.send(msg)
key = "note:email:{}".format(to)
redis_client.set(key, code, current_app.config['EXPIRE'])
except Exception as e:
pass
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 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 save_image_to_redis(image_file):
"""
Change the filename of the uploaded image and save it temporary to redis.
"""
_, file_extension = os.path.splitext(image_file.filename)
new_filename = uuid.uuid4().__str__()[:8] + file_extension
redis_client.set(new_filename, image_file.read())
return new_filename
def derp_it():
print("Derping it")
is_derp = {"derp": True}
derp_json = json.dumps(is_derp)
for key_value in KeyValue.query.all():
key_value.value = is_derp
redis_client.set(key_value.key_id, derp_json)
db.session.commit()
print("Derp done")
def logout():
user_id = get_raw_jwt()['identity']
# revoked token
redis_client.set("user_token_expired_{user_id}".format(user_id=user_id),
'true',
ex=current_app.config['JWT_ACCESS_TOKEN_EXPIRES'])
# remove permissions roles
redis_client.hdel("user_{user_id}".format(user_id=user_id), "permissions")
redis_client.hdel("user_{user_id}".format(user_id=user_id), "roles")
return generate_response()
def get(self, mobile):
# 生成短信验证码
sms_code = '%06d' % random.randint(0, 999999)
# 手机号:验证码的形式保存到redis数据库
key = f'{mobile}'
from app import redis_client
from common.utils.constants import SMS_CODE_EXPIRE
redis_client.set(key, sms_code, ex=SMS_CODE_EXPIRE)
print(f'mobile:{mobile},sms_code:{sms_code}')
return {'mobile': mobile}
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 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 toggle_done(_token):
t = Task.query.filter_by(token=_token).first()
if not t:
raise Exception('Task does not exist!')
else:
t.done = not t.done
db.session.commit()
redis_client.delete(Person.get_id(t.owner_id).token + '-tasks')
redis_client.delete(t.token)
redis_client.set(t.token, json.dumps(t.to_dict), ex=1800)
return t.to_dict()
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 get(self, mobile):
# 生成短信验证码
rand_num = '%06d' % random.randint(0, 999999)
# 保存验证码
key = 'app:code:{}'.format(mobile)
redis_client.set(key, rand_num, ex=SMS_CODE_EXPIRE)
# 发送短信，可以借助第三平台celery
print('短信验证码:"mobile":{},"code":{}'.format(mobile, rand_num))
return {'mobile': 'mobile'}
def __decorated(*args, **kwargs):
print(redis_key)
response = redis_client.get(redis_key)
# NOTE: This is a very hard cache. It doesn't look at any of the request params
if response:
return json.loads(response)
else:
response = f(*args, **kwargs)
redis_client.set(redis_key, json.dumps(response))
redis_client.expire(redis_key, 60)
return response
def get(self, mobile):
# 1生成短信验证码
# rand_num = '%06d' % random.randint(0, 999999)
rand_num = 123456
# 2.保存验证码(redis) app:(:相当于下划线)code：18838118792 123456
key = 'app:code:{}'.format(mobile)
redis_client.set(key, rand_num, ex=SMS_CODE_EXPIRE)
# 3.发送短信 第三方短信平台 celery
# print('短信验证码："mobile":{},"code":{}'.format(mobile, rand_num))
print(f'短信验证码："mobile":{mobile},"code":{rand_num}')
# 3.返回json给前段
return {'mobile': mobile}
def caching_report(user_id):
try:
bytes(user_id)
except TypeError:
return 'Invalid redis key type'
user = User.query.get(user_id)
action_obj = ActionObject()
actions_list = []
for link in user.links:
for action in link.actions:
actions_list.append(action_obj.dump(action))
redis_client.set(user_id, json.dumps(actions_list))
def move(index: int):
game_state = json.loads(redis_client.get('game_state').decode())
moved = False
# Обработаем перемещение только если игра не закончена
if not game_state['finish_time']:
values = game_state['values']
empty_index = values.index('')
# Сформируем набор перемещаемых индексов
movable_indexes = {
empty_index - 4,
empty_index + 4,
}
if (empty_index + 1) % 4:
movable_indexes.add(empty_index + 1)
if (empty_index - 1) % 4 != 3:
movable_indexes.add(empty_index - 1)
# Поменяем значения местами, если это возможно
if index in movable_indexes:
values[empty_index] = values[index]
values[index] = ''
game_state['values'] = values
moved = True
game_state['move_count'] += 1
# Проверим на факт победы
if values[-1] == '':
last_value = values[0]
win = True
for value in values[1:-1]:
if value < last_value:
win = False
break
last_value = value
# В случае победы сохраним затраченное время, и посчитаем очки
if win:
finish_time = datetime.datetime.now(tz=pytz.UTC)
game_state['finish_time'] = finish_time.isoformat()
elapsed_time = (finish_time -
datetime.datetime.fromisoformat(
game_state['start_time'])).seconds
result = Results(finish_time=finish_time,
elapsed_time=elapsed_time,
score=round(game_state['move_count'] /
elapsed_time))
db.session.add(result)
db.session.commit()
game_state = json.dumps(game_state)
if moved:
redis_client.set('game_state', game_state)
return game_state
def set_redis_cache(key, value, time=600):
"""
:param key: 键
:param value: 值
:param time: 缓存时间
:return:
"""
import json
result = True
try:
redis_client.set(key, value, time)
except Exception as ex:
result = False
return result
def get(self, mobile):
# 1生成随机6位数短信验证码
sms_code = "06%d" % (random.randint(0, 999999))
# 保存验证码（code） app:code:13112341234 123456
sms_code = "123456"
# 2.存储到redis数据库 设置过期时长【5分钟】
key = "app:code:{}".format(mobile)
redis_client.set(key, sms_code, ex=SMS_CODE_EXPIRE)
# 3发送短信验证码
# TODO 调用第三方平台发送短信验证码
# print('短信验证码: "mobile": {}, "code": {}'.format(mobile, sms_code))
# 4返回响应
return {"smscode": sms_code, "mobile": mobile}
def __token(self):
token = redis_client.get("wc_token")
app.logger.info(token)
if token is None:
content = requests.get(
f"https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential"
f"&appid={self.app_id}&secret={self.secret}").content
app.logger.info(content)
content_obj = json.loads(content)
if 'errcode' not in content_obj or content_obj['errcode'] == 0:
token = content_obj['access_token']
redis_client.set("wc_token", token, content_obj['expires_in'])
else:
return None
else:
token = str(token, "utf-8")
return token
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 update_password(user_id):
claims = get_jwt_claims()
if user_id != claims['id']:
return generate_response(code_msg=Code.PERMISSION_DENIED), 403
user = User.query.filter_by(id=user_id).first()
if user and user.password == request.json.get("old_password"):
user.password = request.json.get("new_password")
try:
db.session.add(user)
db.session.commit()
redis_client.set("user_token_expired_{id}".format(id=user_id),
'true',
ex=current_app.config['JWT_ACCESS_TOKEN_EXPIRES'])
return generate_response()
except Exception as e:
current_app.logger.error(str(e))
db.session.rollback()
return generate_response(code_msg=Code.PASSWORD_NOT_CORRECT)
