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
