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)