def download_page(self, item):
"""
获取下一页的网页地址等
根据当前状态标记新的状态
0：初始页面
1：全局列表页面
2: 抽取下载连接
"""
item = MyDict(item)
try:
print(f" download_page info: {item.url}")
logger.info("开始下载网页！{}。类型：{}".format(item.url, item.type))
# current_app.logger.info("开始下载网页！{}。类型：{}".format(item.url, item.type))
old_type = item.type
if item.url != "None" and not cache.get(item.url):
# if item.url != "None":
html_obj = requests.get(item.url, headers=self.headers)
html_str = html_obj.content.decode("gbk")
item.content = html_str
print(len(html_str))
# 请求结果存入redis数据库
cache.set(item.url, html_str)
cache.expire(item.url, self.redis_key_timeout)
# item.xpath_obj = lxml.html.fromstring(html_str)
logger.info("下载前类型：{}， 下载后类型：{}".format(old_type, item.type))
self.push_item_in_redis_list(self.message_b, item)
except Exception as e:
logger.error("download_page: {}".format(e))
def submit_data():
form = symptomForm(request.form)
if request.method == 'POST':
if form.validate():
# All code below is to coerce submitted data to required schema
my_data = {}
for key, value in form.allFields.data.items():
if type(value) == dict:
my_data.update(value)
# get rid of the csrf token
del my_data["csrf_token"]
# Properly structure the data
for x in ["calendar", "diagnosis"]:
my_data[x] = {}
for key, value in my_data.items():
if x in key and type(value) == str:
new_key = key.split("_")[-1]
my_data[x].update({new_key: value})
# Set the values for symptoms
all_symptoms = my_data.get("symptoms")
my_data["symptoms"] = {y: True for y in all_symptoms}
# save data to cache
cache.set("my_data", my_data)
return redirect('/submit-data-success/')
else:
return render_template('submit-data.html',
title='Submit Data',
form=form)
def search_iphone():
# 购买者的信息，每次循环实时获取最新的购买者信息
buyers_info = get_buyers_info()
availability = r.get(current_config['IPHONE_MODELS_URL']).json()
if availability['stores']:
# 遍历意向购买的商店和意向购买的商品
for store, models in buyers_info.items():
# 遍历意向购买的型号和对应的购买人
for model_number, buyers in models.items():
# 获取商品型号在店内的库存
stock = availability['stores'][store][model_number]
if stock['availability']['unlocked'] is True:
for buyer in buyers:
key = '{}{}{}'.format(buyer['idcard'], store,
model_number)
if cache.get(key) is None:
buyer['store'] = store
# with rabbit as mq:
# mq.send_message(exchange_name='iphone', queue_name='buyers', messages=buyer)
# 日志记录及微信消息发送
msg = '发现有效库存，商店【{0}】， 型号【{1}】，时间【{2}】。'.format(
get_store_name(store),
get_model_name(model_number),
datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
r.get(
' http://sc.ftqq.com/{}.send?text=您关注的iPhone已有库存&desp={}'
.format(current_config.SEC_KEY, msg))
logging.info(msg)
logging.info('买家信息：{}'.format(buyer))
logging.info('[猎鹰] 已将目标设备和买家信息发送给猎手')
# 已经发送过的购买者信息，5分钟内不再发送
cache.set(key=key, val='已发送', time=180)
else:
logging.info('[猎鹰] 没有发现有效库存')
def submit_data_json():
form = jsonForm(request.form)
if request.method == 'POST':
if form.validate():
my_data = form.allFields.data.get("jsonData")
my_data = json.loads(my_data)
# Properly structure the data
for x in ["calendar", "diagnosis"]:
my_data[x] = {}
for key, value in my_data.items():
if x in key and type(value) == str:
new_key = key.split("_")[-1]
my_data[x].update({new_key: value})
cache.set("my_data", my_data)
else:
my_errors = {
k: v
for k, v in form.errors.get("allFields", {}).items()
}
cache.set("errors", my_errors)
# Now send data along
return redirect('/submit-data-success/')
else:
return render_template('submit-data-json.html',
title='Submit Data (Json)',
form=form)
def cart_add():
cart = cache.get('cart%d' % current_user.id)
c_id = int(request.args.get('id'))
if cart is None:
data = []
else:
data = cart
if c_id in data:
return jsonify({'status': False, 'msg': '您已添加过该产品,不可重复添加'})
data.append(c_id)
data = list(set(data))
cache.set('cart%d' % current_user.id, data)
return jsonify({'status': True, 'msg': '添加成功'})
def create_tokens(user_id: str):
config = current_app.config
access_expires = config.get('JWT_ACCESS_TOKEN_EXPIRES')
refresh_expires = config.get('JWT_REFRESH_TOKEN_EXPIRES')
access_token = create_access_token(identity=user_id)
refresh_token = create_refresh_token(identity=user_id)
access_jti = get_jti(encoded_token=access_token)
refresh_jti = get_jti(encoded_token=refresh_token)
cache.set(access_jti, refresh_jti,
int(access_expires.total_seconds() * 1.2))
cache.set(refresh_jti, access_jti,
int(refresh_expires.total_seconds() * 1.2))
tokens = {'access_token': access_token, 'refresh_token': refresh_token}
return tokens
def code_sign_in_service(code: str):
user_id = cache.get(code)
if not user_id:
return None
user = mongo.db.users.find_one({'_id': ObjectId(user_id)})
if not user:
return None
tokens = create_tokens(user_id=user_id)
cache.set(user_id, user.get('roles'))
return tokens
def index():
if request.method == 'POST':
value = request.form.get('indexValue')
bar = cache.get(value)
if bar:
return jsonify({'cached_result': bar})
else:
r = requests.post('http://api:4000', json={'value': value})
result = r.json() #得到的其实使dict
cache.set(value, result.get('result'), timeout=50)
history.insert({
"requested time": datetime.now(),
"requested index": value,
"calculated value": result.get('result', '')
})
return jsonify(result)
return render_template('index.html')
def request_code_service(email: str):
user = mongo.db.users.find_one({'email': email})
if user:
code = generate_code()
cache.set(code, str(user.get('_id')), timeout=1800)
# TODO I would do it would celery, but I don't see the point of doing it in a test task
sent_email_thread = Thread(target=send_email,
args=[
current_app._get_current_object(),
user.get('email'), '*****@*****.**',
'Auth code', code
])
sent_email_thread.start()
return {'status': True, 'message': 'Email sent'}
return None
def sign_in_service(email: str, password: str):
user = mongo.db.users.find_one({'email': email})
if not user:
return None
user_password = user.get('password')
if not user_password:
return None
is_correct_password = check_password_hash(user_password, password)
if not is_correct_password:
return None
user_id = str(user.get('_id'))
tokens = create_tokens(user_id=user_id)
cache.set(user_id, user.get('roles'))
return tokens
def set(cls, attr):
cache.set('Field::ID::%s' % attr.attr_id, attr)
cache.set('Field::Name::%s' % attr.attr_name, attr)
cache.set('Field::Alias::%s' % attr.attr_alias, attr)
def set(cls, ct):
cache.set("CITypeSPEC::ID::%d" % ct.type_id, ct)
def set(cls, key, values):
citype = CITypeCache.get(key)
if citype is not None:
cache.set("CITypeAttribute::ID::%s" % citype.type_id, values)
cache.set("CITypeAttribute::Name::%s" % citype.type_name, values)
def set(cls, role):
cache.set("Role::rid::%s" % role.rid, role)
cache.set("Role::role_name::%s" % role.role_name, role)
def set(cls, user):
cache.set("User::uid::%s" % user.uid, user)
cache.set("User::username::%s" % user.username, user)
cache.set("User::nickname::%s" % user.nickname, user)
def set(cls, ct):
cache.set("CIType::Name::%s" % ct.type_name, ct)
cache.set("CIType::ID::%d" % ct.type_id, ct)
def save_sms(apple_id, sms_list):
# 将验证码写入缓存，30分钟超时
cache.set(apple_id, sms_list, time=1750)
if cache.get(apple_id) is None:
raise RuntimeError
def set(cls, uid):
cache.set("SpecialPermission::uid::%s" % uid, "Y", timeout=60 * 60 * 2)
