def get_apply_before_coupons_taxes(conn, id_user, id_shop, id_sale): tax_list = [] try: if id_shop: shop = ujson.loads(get_redis_cli().get(SHOP % id_shop)) from_address = shop['address'] else: sale = ujson.loads(get_redis_cli().get(SALE % id_sale)) from_address = sale['brand']['address'] to_address = get_user_address(conn, id_user, addr_type=ADDR_TYPE.Shipping)[0] taxes = tax_cache_proxy.get() for tax in taxes.values(): if tax['applies_after_promos'] == 'True': continue if tax['country'] != from_address['country']['#text']: continue if tax.get('province') and \ tax['province'] != from_address['country']['@province']: continue if tax['shipping'].get('@country') and \ tax['shipping'].get('@country') != 'None' and \ tax['shipping'].get('@country') != to_address['country']: continue if tax['shipping'].get('@province') and \ tax['shipping'].get('@province') != to_address['province']: continue tax_list.append(tax) except Exception, e: logging.error("Failed to get apply-before-coupons taxes", exc_info=True)
def _refresh_redis(self, version, data, is_entire_result, **kw): # save version self._set_to_redis(ROUTES_VERSION, version) brand_id = kw.get('brand') if brand_id: get_redis_cli().set(ROUTES_FOR_BRAND % brand_id, ujson.dumps(data))
def reset_pwd(self, req, resp, conn): email = req.get_param('email') key = req.get_param('key') or '' redis_key = RESET_PASSWORD_REDIS_KEY % key if not key or not email \ or get_redis_cli().get(redis_key) != email.lower(): raise ValidationError('INVALID_REQUEST') new_pwd = self.get_password(req) self._update_password(conn, email.lower(), new_pwd) get_redis_cli().delete(redis_key) return {'res': RESP_RESULT.S}
def _get_from_redis(self, **kw): brand_id = kw.get('seller') types_id = get_redis_cli().lrange(TYPES_FOR_BRAND % brand_id, 0, -1) if not types_id: raise NoRedisData() types = {} for t_id in types_id: _type = get_redis_cli().get(TYPE % t_id) if _type: types[t_id] = ujson.loads(_type) return types
def __up_session(_sid): cli = get_redis_cli(ping=True) if not cli: return name = 'SID:%s' % _sid if not cli.get(name) and self.users_id: __remote_log(_sid) __set(_sid)
def _rem_diff_objs(self, key, current_objs): pre_objs = get_redis_cli().lrange(key % ALL, 0, -1) diff = set(pre_objs).difference(set(current_objs)) for obj_id in diff: self._rem_attrs_for_obj(obj_id) objs_name = [self.obj_key % id for id in diff] self._del_objs(*objs_name)
def _get_from_redis(self, **kw): g_settings = get_redis_cli().get(self.obj_key % ('', 'ALL')) if not g_settings: raise NoRedisData() g_settings = ujson.loads(g_settings) brand_id = kw.get('brand') return self._filter_settings(g_settings, brand_id)
def get_from_redis(self, query): query_key = self._get_query_key(query) cli = get_redis_cli() if not cli.exists(query_key): raise NotExistError('Query cache not exist for: %s' % query_key) sales_id = cli.get(query_key) return ujson.loads(sales_id)
def _save_objs_to_redis(self, data_list): if not data_list: return pipe = get_redis_cli().pipeline() for data in data_list: name = self.obj_key % (data['@brand'], data['@name']) pipe.set(name, data['#text']) pipe.execute()
def _get_from_redis(self, **kw): # do filters. groups_id = set(get_redis_cli().lrange(GROUPS_ALL % ALL, 0, -1)) groups_id = self._filter_interact(GROUPS_FOR_BRAND, kw.get('seller'), groups_id) groups_id = self._filter_interact(GROUPS_FOR_SHOP, kw.get('shop'), groups_id) groups = {} for g_id in groups_id: group = get_redis_cli().get(GROUP % g_id) if group: groups[g_id] = ujson.loads(group) return groups
def _get_from_redis(self, **kw): # do filters. shops_id = set(get_redis_cli().lrange(SHOPS_ALL % ALL, 0, -1)) shops_id = self._filter_interact(SHOPS_FOR_BRAND, kw.get('seller'), shops_id) shops_id = self._filter_interact(SHOPS_FOR_CITY, kw.get('city'), shops_id) shops = {} for s_id in shops_id: shop = get_redis_cli().get(SHOP % s_id) if shop: shop = ujson.loads(shop) shops[s_id] = shop return shops
def _filter_interact(self, key, id, pre_ids): if id is None: return pre_ids assert isinstance(pre_ids, set) name = key % id filter_ids = set(get_redis_cli().lrange(name, 0, -1)) return pre_ids.intersection(filter_ids)
def get_shop(upc_shop=None, id_shop=None): assert upc_shop or id_shop cli = get_redis_cli() if upc_shop: id_shop = get_shop_id(upc_shop) key = SHOP % id_shop shop = cli.get(key) return shop, key
def _refresh_cats_redis(self, cats, **kw): if not cats: return pipe = get_redis_cli().pipeline() for cat in cats: id_cat = cat['@id'] cat_str = ujson.dumps(cat) name = CATEGORY % id_cat pipe.set(name, cat_str) pipe.execute() brand_id = kw.get('seller') if brand_id: pipe = get_redis_cli().pipeline() for cat in cats: if cat['@default'] == 'False' and cat['@valid'] == 'True': pipe.rpush(CATEGORY_FOR_BRAND % brand_id, cat['@id']) pipe.execute()
def reset_pwd_request(self, req, resp, conn): email = req.get_param('email') if email: email = email.lower() result = db_utils.select(conn, "users", columns=("id", ), where={'email': email}, limit=1) sql = """select users.id, first_name from users left join users_profile on (users.id=users_profile.users_id) where users.email=%s limit 1""" result = db_utils.query(conn, sql, (email, )) if result and len(result) == 1: user_name = result[0][1] random_key = hashfn(HASH_ALGORITHM.SHA256, str(uuid.uuid4())) get_redis_cli().setex(RESET_PASSWORD_REDIS_KEY % random_key, email, settings.RESET_PASSWORD_REQUEST_EXPIRES) reset_link_args = urllib.urlencode({ 'user_name': user_name, 'email': email, 'key': random_key }) reset_link = '%s?%s' % (settings.FRONT_RESET_PASSWORD_URL, reset_link_args) data = { 'base_url': settings.FRONT_ROOT_URI, 'user_name': user_name, 'reset_link': reset_link, 'reset_link_args': reset_link_args, } email_content = render_content('reset_pwd_email.html', **to_unicode(data)) gevent.spawn(send_html_email, email, settings.RESET_PASSWORD_EMAIL_SUBJECT, email_content) return {'res': RESP_RESULT.S}
def _refresh_redis(self, version, types, is_entire_result, **kw): # save version self._set_to_redis(TYPES_VERSION, version) brand_id = kw.get('seller') if brand_id: pipe = get_redis_cli().pipeline() for _type in types: pipe.rpush(TYPES_FOR_BRAND % brand_id, _type['@id']) pipe.expire(TYPES_FOR_BRAND % brand_id, settings.DEFAULT_REDIS_CACHE_TTL) pipe.execute() self._save_objs_to_redis(types)
def _rem_attrs_for_obj(self, id): cli = get_redis_cli() group = cli.get(GROUP % id) if not group: cli.lrem(GROUPS_ALL % ALL, id, 0) return group = ujson.loads(group) pipe = cli.pipeline() pipe.lrem(GROUPS_FOR_BRAND % group['brand']['@id'], id, 0) pipe.lrem(GROUPS_FOR_SHOP % group['shop']['@id'], id, 0) pipe.lrem(GROUPS_ALL % ALL, id, 0) pipe.execute()
def _rem_attrs_for_obj(self, id): cli = get_redis_cli() shop = cli.get(SHOP % id) if not shop: cli.lrem(SHOPS_ALL % ALL, id, 0) return shop = ujson.loads(shop) pipe = cli.pipeline() pipe.lrem(SHOPS_FOR_BRAND % shop['brand']['@id'], id, 0) pipe.lrem(SHOPS_FOR_CITY % shop['address']['city'], id, 0) pipe.lrem(SHOPS_ALL % ALL, id, 0) pipe.delete(SHOP_WITH_BARCODE% id) pipe.execute()
def __set(_sid): _exp = __gen_session_expiry() session = "sid@%s&exp@%s" % (_sid, _exp) set_cookie(resp, SESSION_COOKIE_NAME, session) name = 'SID:%s' % _sid cli = get_redis_cli(ping=True) if not cli: return cli.setex(name, self.users_id or "", settings.SESSION_EXP_TIME)
def _save_objs_to_redis(self, data_list): """ save parsed xml data list into redis. data_list: OrderedDict list. dict in the list must contain key '@id'. """ if not data_list: return pipe = get_redis_cli().pipeline() for data in data_list: data_id = data['@id'] data_str = ujson.dumps(data) name = self.obj_key % data_id self._rem_attrs_for_obj(data_id) pipe.set(name, data_str) pipe.execute()
def _get_from_redis(self, **kw): # do filters. sales_id = set(get_redis_cli().lrange(SALES_ALL % ALL, 0, -1)) sales_id = self._filter_interact(SALES_FOR_CATEGORY, kw.get('category'), sales_id) sales_id = self._filter_interact(SALES_FOR_SHOP, kw.get('shop'), sales_id) sales_id = self._filter_interact(SALES_FOR_BRAND, kw.get('brand'), sales_id) sales_id = self._filter_interact(SALES_FOR_TYPE, kw.get('type'), sales_id) sales = {} for s_id in sales_id: sale = get_redis_cli().get(SALE % s_id) if sale: sale = ujson.loads(sale) sales[s_id] = sale return sales
def clear_basket(req, resp, basket_key, basket_data): # called after the order placed successfully redis_cli = get_redis_cli() if basket_key == get_cookie_value(req, USER_BASKET_COOKIE_NAME): redis_cli.set(basket_key, ujson.dumps({})) elif basket_key == get_cookie_value(req, CURR_USER_BASKET_COOKIE_NAME): redis_cli.delete(basket_key) prev_basket_key, prev_basket_data = get_basket(req, resp, USER_BASKET_COOKIE_NAME) [prev_basket_data.pop(item) for item in basket_data if item in prev_basket_data] redis_cli.set(prev_basket_key, ujson.dumps(prev_basket_data)) set_cookie(resp, CURR_USER_BASKET_COOKIE_NAME, "")
def _save_attrs_to_redis(self, key, data): """ Save attribute related info into redis to make the query easier. key: one option of SALES_FOR_TYPE, SALES_FOR_CATEGORY, SALES_FOR_SHOP, SALES_FOR_BRAND, SHOPS_FOR_BRAND, SHOPS_FOR_CITY data: a list dict, key is the attribute id, value is a id list to be pushed into redis. """ assert isinstance(data, dict) pipe = get_redis_cli().pipeline() for id, values in data.iteritems(): if not id: continue for v in values: pipe.rpush(key % id, v) pipe.execute()
def _del_cached_query(self, obj_id, del_all): cli = get_redis_cli() pipe = cli.pipeline() if del_all: invalid_cached_query = cli.keys(SALE_CACHED_QUERY % '*') invalid_query = cli.keys(SALES_QUERY % '*') for key in invalid_cached_query + invalid_query: pipe.delete(key) else: key = SALE_CACHED_QUERY % obj_id query_list = cli.lrange(key, 0, -1) for query in query_list: s_id_list = ujson.loads(cli.get(query)) for s_id in s_id_list: pipe.lrem(SALE_CACHED_QUERY % s_id, query, 0) for q in query_list: pipe.delete(q) pipe.delete(key) pipe.execute()
def watching_invalidate_cache_list(pid): redis_down = False redis_cli = get_redis_cli() key = INVALIDATE_CACHE_LIST % settings.BRAND_ID while True: try: cache = None if redis_cli.exists(key): cache = redis_cli.blpop(key, 0) else: gevent.sleep(5) except: logging.warn("Redis is down ???") redis_down = True gevent.sleep(5) else: if redis_down or cache and cache[1] == INVALIDATE_CACHE_OBJ.ROUTES: send_reload_signal(pid) redis_down = False
def data_access(api_name, req=None, resp=None, **kwargs): if 'seller' not in kwargs \ and 'brand' not in kwargs \ and 'brand_id' not in kwargs: kwargs['brand'] = settings.BRAND_ID resp_dict = {} pri_key_path = settings.PRIVATE_KEY_PATH usr_pub_key_uri = settings.SERVER_APIKEY_URI_MAP[SERVICES.USR] if api_name in cache_proxy: resp_dict = cache_proxy[api_name](get_redis_cli(), settings.USR_ROOT_URI, pri_key_path, usr_pub_key_uri).get(**kwargs) elif api_name in USR_API_SETTINGS: resp_dict = remote_call(settings.USR_ROOT_URI, api_name, pri_key_path, usr_pub_key_uri, req, resp, **kwargs) else: pass return unicode2utf8(resp_dict)
def _refresh_redis(self, version, groups, is_entire_result): # save version self._set_to_redis(GROUPS_VERSION, version) # save groups info into redis self._save_objs_to_redis(groups) pipe = get_redis_cli().pipeline() for group in groups: group_id = group['@id'] brand_id = group['brand']['@id'] shop_id = group['shop']['@id'] pipe.rpush(GROUPS_FOR_BRAND % brand_id, group_id) pipe.rpush(GROUPS_FOR_SHOP % shop_id, group_id) pipe.rpush(GROUPS_ALL % ALL, group_id) pipe.execute() if is_entire_result: self._rem_diff_objs(GROUPS_ALL, [s['@id'] for s in groups])
def _set_basket_data(self, req, resp, users_id): redis_cli = get_redis_cli() old_basket_key = redis_cli.get(LOGIN_USER_BASKET_KEY % users_id) old_basket_data = redis_cli.get( old_basket_key) if old_basket_key else None old_basket_data = ujson.loads( old_basket_data) if old_basket_data else {} basket_key = get_cookie_value(req, USER_BASKET_COOKIE_NAME) basket_data = redis_cli.get(basket_key) if basket_key else None basket_data = ujson.loads(basket_data) if basket_data else {} if old_basket_key: if basket_key and basket_key != old_basket_key: old_basket_data.update(basket_data) redis_cli.set(old_basket_key, ujson.dumps(old_basket_data)) set_cookie(resp, USER_BASKET_COOKIE_NAME, old_basket_key) elif basket_key: redis_cli.set(LOGIN_USER_BASKET_KEY % users_id, basket_key) else: pass
def _refresh_redis(self, version, shops, is_entire_result): # save version self._set_to_redis(SHOPS_VERSION, version) # save shops info into redis self._save_objs_to_redis(shops) pipe = get_redis_cli().pipeline() for shop in shops: shop_id = shop['@id'] city = shop['address']['city'] brand_id = shop['brand']['@id'] pipe.rpush(SHOPS_FOR_CITY % city, shop_id) pipe.rpush(SHOPS_FOR_BRAND % brand_id, shop_id) pipe.rpush(SHOPS_ALL % ALL, shop_id) pipe.set(SHOP_WITH_BARCODE % shop['upc'], shop_id) pipe.execute() if is_entire_result: self._rem_diff_objs(SHOPS_ALL, [s['@id'] for s in shops])
def get_basket(req, resp, cookie_name=None): basket_key = None basket_data = None if cookie_name: iternames = [cookie_name] else: iternames = [CURR_USER_BASKET_COOKIE_NAME, USER_BASKET_COOKIE_NAME] for c_name in iternames: basket_key = get_cookie_value(req, c_name) try: if basket_key: basket_data = get_redis_cli().get(basket_key) if basket_data: break except: pass if not basket_key: basket_key = USER_BASKET % generate_random_key() set_cookie(resp, USER_BASKET_COOKIE_NAME, basket_key) basket_data = ujson.loads(basket_data) if basket_data else {} return basket_key, basket_data