def testCacheGetOK(self):
one = [1, 2, 3, 4]
caching.cache_set('ok', value=one, length=2)
two = caching.cache_get('ok')
self.assertEqual(one, two)
time.sleep(5)
try:
three = caching.cache_get('ok')
self.fail('should have raised NotCachedError, got %s' % three)
except caching.NotCachedError:
pass
def testCacheGetOK(self):
one = [1,2,3,4]
caching.cache_set('ok', value=one, length=2)
two = caching.cache_get('ok')
self.assertEqual(one, two)
time.sleep(5)
try:
three = caching.cache_get('ok')
self.fail('should have raised NotCachedError, got %s' % three)
except caching.NotCachedError:
pass
def testDisable(self):
caching.cache_set('disabled', value=False)
v = caching.cache_get('disabled')
self.assertEqual(v, False)
caching.cache_enable(False)
caching.cache_set('disabled', value=True)
try:
caching.cache_get('disabled')
self.fail('should have raised NotCachedError')
except caching.NotCachedError, nce:
key = caching.cache_key('disabled')
self.assertEqual(nce.key, key)
def testDisable(self):
caching.cache_set('disabled', value=False)
v = caching.cache_get('disabled')
self.assertEqual(v, False)
caching.cache_enable(False)
caching.cache_set('disabled', value=True)
try:
caching.cache_get('disabled')
self.fail('should have raised NotCachedError')
except caching.NotCachedError, nce:
key = caching.cache_key('disabled')
self.assertEqual(nce.key, key)
def find_setting(group, key, site=None):
"""Get a setting or longsetting by group and key, cache and return it."""
siteid = _safe_get_siteid(site)
ck = cache_key('Setting', siteid, group, key)
setting = None
try:
setting = cache_get(ck)
except NotCachedError:
if apps.ready:
try:
setting = Setting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except Setting.DoesNotExist:
# maybe it is a "long setting"
try:
setting = LongSetting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except LongSetting.DoesNotExist:
pass
cache_set(ck, value=setting)
if not setting:
raise SettingNotSet(key, cachekey=ck)
return setting
def getCCV(self):
try:
ccv = caching.cache_get(self.encrypted_cc)
except caching.NotCachedError:
ccv = ""
return ccv
def getCCV(self):
try:
ccv = caching.cache_get(self.encrypted_cc)
except caching.NotCachedError:
ccv = ""
return ccv
def testDisable(self):
caching.cache_set("disabled", value=False)
v = caching.cache_get("disabled")
self.assertEqual(v, False)
caching.cache_enable(False)
caching.cache_set("disabled", value=True)
try:
caching.cache_get("disabled")
self.fail("should have raised NotCachedError")
except caching.NotCachedError as nce:
key = caching.cache_key("disabled")
self.assertEqual(nce.key, key)
caching.cache_enable()
v2 = caching.cache_get("disabled")
# should still be False, since the cache was disabled
self.assertEqual(v2, False)
def bestsellers(count):
"""Look up the bestselling products and return in a list"""
cached = False
try:
pks = cache_get('BESTSELLERS', count=count)
pks = [long(pk) for pk in pks.split(',')]
productdict = Product.objects.in_bulk(pks)
#log.debug(productdict)
sellers = []
for pk in pks:
try:
if (int(pk)) in productdict:
key = int(pk)
elif long(pk) in productdict:
key = long(pk)
else:
continue
sellers.append(productdict[key])
except ValueError:
pass
cached = True
log.debug('retrieved bestselling products from cache')
except NotCachedError:
pass
except ValueError:
pass
if not cached:
products = Product.objects.active_by_site()
work = []
for p in products:
ct = p.orderitem_set.count()
if ct>0:
work.append((ct, p))
work.sort()
work = work[-count:]
work.reverse()
sellers = []
pks = []
for p in work:
product = p[1]
pks.append("%i" % product.pk)
sellers.append(product)
pks = ",".join(pks)
log.debug('calculated bestselling %i products, set to cache: %s', count, pks)
cache_set('BESTSELLERS', count=count, value=pks)
return sellers
def testDelete(self):
caching.cache_set('del', value=True)
for x in range(0, 10):
caching.cache_set('del', 'x', x, value=True)
for y in range(0, 5):
caching.cache_set('del', 'x', x, 'y', y, value=True)
# check to make sure all the values are in the cache
self.assert_(caching.cache_get('del', default=False))
for x in range(0, 10):
self.assert_(caching.cache_get('del', 'x', x, default=False))
for y in range(0, 5):
self.assert_(
caching.cache_get('del', 'x', x, 'y', y, default=False))
# try to delete just one
killed = caching.cache_delete('del', 'x', 1)
self.assertEqual([caching.CACHE_PREFIX + "::del::x::1"], killed)
self.assertFalse(caching.cache_get('del', 'x', 1, default=False))
# but the others are still there
self.assert_(caching.cache_get('del', 'x', 2, default=False))
# now kill all of del::x::1
killed = caching.cache_delete('del', 'x', 1, children=True)
for y in range(0, 5):
self.assertFalse(
caching.cache_get('del', 'x', 1, 'y', y, default=False))
# but del::x::2 and children are there
self.assert_(caching.cache_get('del', 'x', 2, 'y', 1, default=False))
# kill the rest
killed = caching.cache_delete('del', children=True)
self.assertFalse(caching.cache_get('del', default=False))
for x in range(0, 10):
self.assertFalse(caching.cache_get('del', 'x', x, default=False))
for y in range(0, 5):
self.assertFalse(
caching.cache_get('del', 'x', x, 'y', y, default=False))
def _find_translation(self, language_code=None, attr="translations"):
"""Look up a translation for an attr.
Ex: self._find_translation(language_code='en-us', attr='translations')
"""
if not language_code:
language_code = get_language()
try:
site = Site.objects.get_current()
trans = caching.cache_get(
"{}-{}".format(self.__class__.__name__, self.id),
site=site,
trans=attr,
lang=language_code,
)
except caching.NotCachedError as nce:
translations = getattr(self, attr)
c = translations.filter(languagecode__exact=language_code)
ct = c.count()
if not c or ct == 0:
pos = language_code.find("-")
if pos > -1:
short_code = language_code[:pos]
# log.debug("%s: Trying to find root language content for: [%s]", self, short_code)
c = translations.filter(languagecode__exact=short_code)
ct = c.count()
if ct > 0:
# log.debug("%s: Found root language content for: [%s]", self, short_code)
pass
if not c or ct == 0:
# log.debug("Trying to find default language content for: %s", self)
c = translations.filter(
languagecode__istartswith=settings.LANGUAGE_CODE
)
ct = c.count()
if not c or ct == 0:
# log.debug("Trying to find *any* language content for: %s", self)
c = translations.all()
ct = c.count()
if ct > 0:
trans = c[0]
else:
trans = None
log.info(nce.key)
caching.cache_set(nce.key, value=trans)
return trans
def find_by_slug(cls, groupkey, slug):
"""A helper function to look up an object by slug"""
ob = None
try:
ob = caching.cache_get(groupkey, slug)
except caching.NotCachedError, e:
try:
ob = cls.objects.get(slug__exact=slug)
caching.cache_set(e.key, value=ob)
except cls.DoesNotExist:
log.debug("No such %s: %s", groupkey, slug)
def find_by_slug(cls, groupkey, slug):
"""A helper function to look up an object by slug"""
ob = None
try:
ob = caching.cache_get(groupkey, slug)
except caching.NotCachedError, e:
try:
ob = cls.objects.get(slug__exact=slug)
caching.cache_set(e.key, value=ob)
except cls.DoesNotExist:
log.debug("No such %s: %s", groupkey, slug)
def testDelete(self):
caching.cache_set("del", value=True)
for x in range(0, 10):
caching.cache_set("del", "x", x, value=True)
for y in range(0, 5):
caching.cache_set("del", "x", x, "y", y, value=True)
# check to make sure all the values are in the cache
self.assertTrue(caching.cache_get("del", default=False))
for x in range(0, 10):
self.assertTrue(caching.cache_get("del", "x", x, default=False))
for y in range(0, 5):
self.assertTrue(caching.cache_get("del", "x", x, "y", y, default=False))
# try to delete just one
killed = caching.cache_delete("del", "x", 1)
self.assertEqual([caching.CACHE_PREFIX + "::del::x::1"], killed)
self.assertFalse(caching.cache_get("del", "x", 1, default=False))
# but the others are still there
self.assertTrue(caching.cache_get("del", "x", 2, default=False))
# now kill all of del::x::1
killed = caching.cache_delete("del", "x", 1, children=True)
for y in range(0, 5):
self.assertFalse(caching.cache_get("del", "x", 1, "y", y, default=False))
# but del::x::2 and children are there
self.assertTrue(caching.cache_get("del", "x", 2, "y", 1, default=False))
# kill the rest
killed = caching.cache_delete("del", children=True)
self.assertFalse(caching.cache_get("del", default=False))
for x in range(0, 10):
self.assertFalse(caching.cache_get("del", "x", x, default=False))
for y in range(0, 5):
self.assertFalse(
caching.cache_get("del", "x", x, "y", y, default=False)
)
def testDelete(self):
caching.cache_set('del', value=True)
for x in range(0,10):
caching.cache_set('del', 'x', x, value=True)
for y in range(0,5):
caching.cache_set('del', 'x', x, 'y', y, value=True)
# check to make sure all the values are in the cache
self.assert_(caching.cache_get('del', default=False))
for x in range(0,10):
self.assert_(caching.cache_get('del', 'x', x, default=False))
for y in range(0,5):
self.assert_(caching.cache_get('del', 'x', x, 'y', y, default=False))
# try to delete just one
killed = caching.cache_delete('del','x',1)
self.assertEqual(["del::x::1"], killed)
self.assertFalse(caching.cache_get('del', 'x', 1, default=False))
# but the others are still there
self.assert_(caching.cache_get('del', 'x', 2, default=False))
# now kill all of del::x::1
killed = caching.cache_delete('del','x', 1, children=True)
for y in range(0,5):
self.assertFalse(caching.cache_get('del', 'x', 1, 'y', y, default=False))
# but del::x::2 and children are there
self.assert_(caching.cache_get('del','x',2,'y',1, default=False))
# kill the rest
killed = caching.cache_delete('del', children=True)
self.assertFalse(caching.cache_get('del',default=False))
for x in range(0,10):
self.assertFalse(caching.cache_get('del', 'x', x, default=False))
for y in range(0,5):
self.assertFalse(caching.cache_get('del', 'x', x, 'y', y, default=False))
def find_by_id(cls, groupkey, objectid, raises=False):
"""A helper function to look up an object by id"""
ob = None
try:
ob = caching.cache_get(groupkey, objectid)
except caching.NotCachedError, e:
try:
ob = cls.objects.get(pk=objectid)
caching.cache_set(e.key, value=ob)
except cls.DoesNotExist:
log.debug("No such %s: %s", groupkey, objectid)
if raises:
raise cls.DoesNotExist
def find_by_key(cls, groupkey, key, raises=False):
"""A helper function to look up an object by key"""
ob = None
try:
ob = caching.cache_get(groupkey, key)
except caching.NotCachedError, e:
try:
ob = cls.objects.get(key__exact=key)
caching.cache_set(e.key, value=ob)
except cls.DoesNotExist:
log.debug("No such %s: %s", groupkey, key)
if raises:
raise
def find_by_key(cls, groupkey, key, raises=False):
"""A helper function to look up an object by key"""
ob = None
try:
ob = caching.cache_get(groupkey, key)
except caching.NotCachedError, e:
try:
ob = cls.objects.get(key__exact=key)
caching.cache_set(e.key, value=ob)
except cls.DoesNotExist:
log.debug("No such %s: %s", groupkey, key)
if raises:
raise
def find_by_id(cls, groupkey, objectid, raises=False):
"""A helper function to look up an object by id"""
ob = None
try:
ob = caching.cache_get(groupkey, objectid)
except caching.NotCachedError, e:
try:
ob = cls.objects.get(pk=objectid)
caching.cache_set(e.key, value=ob)
except cls.DoesNotExist:
log.debug("No such %s: %s", groupkey, objectid)
if raises:
raise cls.DoesNotExist
def _find_translation(self, language_code=None, attr='translations'):
"""Look up a translation for an attr.
Ex: self._find_translation(language_code='en-us', attr='translations')
"""
if not language_code:
language_code = get_language()
try:
site = Site.objects.get_current()
trans = caching.cache_get([self.__class__.__name__, self.id],
site=site,
trans=attr,
lang=language_code)
except caching.NotCachedError, nce:
translations = getattr(self, attr)
c = translations.filter(languagecode__exact=language_code)
ct = c.count()
if not c or ct == 0:
pos = language_code.find('-')
if pos > -1:
short_code = language_code[:pos]
#log.debug("%s: Trying to find root language content for: [%s]", self, short_code)
c = translations.filter(languagecode__exact=short_code)
ct = c.count()
if ct > 0:
#log.debug("%s: Found root language content for: [%s]", self, short_code)
pass
if not c or ct == 0:
#log.debug("Trying to find default language content for: %s", self)
c = translations.filter(
languagecode__istartswith=settings.LANGUAGE_CODE)
ct = c.count()
if not c or ct == 0:
#log.debug("Trying to find *any* language content for: %s", self)
c = translations.all()
ct = c.count()
if ct > 0:
trans = c[0]
else:
trans = None
caching.cache_set(nce.key, value=trans)
def get_current(self, site=None):
"""Convenience method to get the current shop config"""
if not site:
site = Site.objects.get_current()
site = site.id
try:
shop_config = caching.cache_get("Config", site)
except caching.NotCachedError, nce:
try:
shop_config = self.get(site__id__exact=site)
caching.cache_set(nce.key, value=shop_config)
except Config.DoesNotExist:
log.warning("No Shop Config found, using test shop config for site=%s.", site)
shop_config = NullConfig()
def product_count(category, args=''):
"""Get a count of products for the base object.
If `category` is None, then count everything.
If it is a `Category` object then count everything in the category and subcategories.
"""
args, kwargs = get_filter_args(args, boolargs=('variations'))
variations = kwargs.get('variations', False)
try:
ct = caching.cache_get('product_count', category, variations)
except caching.NotCachedError:
if not category:
ct = Product.objects.active_by_site(variations=variations).count()
else:
ct = category.active_products(include_children=True, variations=variations).count()
caching.cache_set('product_count', category, args, value=ct)
return ct
def product_count(category, args=''):
"""Get a count of products for the base object.
If `category` is None, then count everything.
If it is a `Category` object then count everything in the category and subcategories.
"""
args, kwargs = get_filter_args(args, boolargs=('variations'))
variations = kwargs.get('variations', False)
try:
ct = caching.cache_get('product_count', category, variations)
except caching.NotCachedError:
if not category:
ct = Product.objects.active_by_site(variations=variations).count()
else:
ct = category.active_products(include_children=True,
variations=variations).count()
caching.cache_set('product_count', category, args, value=ct)
return ct
def find(cls, group, key):
"""Get a setting from cache, if possible"""
site_id = settings.SITE_ID
ck = cache_key('Setting', site_id, group, key)
try:
setting = cache_get(ck)
except NotCachedError:
if loading.app_cache_ready():
try:
setting = Setting.objects.get(site__id__exact=site_id, key__exact=key, group__exact=group)
setting.cache_set()
except Setting.DoesNotExist:
raise SettingNotSet(key)
else:
raise SettingNotSet("App cache not loaded: %s" % key)
return setting
class TestCacheDisable(TestCase):
def testDisable(self):
caching.cache_set('disabled', value=False)
v = caching.cache_get('disabled')
self.assertEqual(v, False)
caching.cache_enable(False)
caching.cache_set('disabled', value=True)
try:
caching.cache_get('disabled')
self.fail('should have raised NotCachedError')
except caching.NotCachedError, nce:
key = caching.cache_key('disabled')
self.assertEqual(nce.key, key)
caching.cache_enable()
v2 = caching.cache_get('disabled')
# should still be False, since the cache was disabled
self.assertEqual(v2, False)
def highest_rated(count=0, site=None):
"""Get the most highly rated products"""
if site is None:
site = Site.objects.get_current()
site_id = site.id
try:
pks = cache_get("BESTRATED", site=site_id, count=count)
pks = [pk for pk in pks.split(',')]
log.debug('retrieved highest rated products from cache')
except NotCachedError, nce:
# here were are going to do just one lookup for all product comments
comments = Comment.objects.filter(content_type__app_label__exact='product',
content_type__model__exact='product',
site__id__exact=site_id,
productrating__rating__gt=0,
is_public__exact=True).order_by('object_pk')
# then make lists of ratings for each
commentdict = {}
for comment in comments:
if hasattr(comment, 'productrating'):
rating = comment.productrating.rating
if rating>0:
commentdict.setdefault(comment.object_pk, []).append(rating)
# now take the average of each, and make a nice list suitable for sorting
ratelist = [(average(ratings), int(pk)) for pk, ratings in commentdict.items()]
ratelist.sort()
#log.debug(ratelist)
# chop off the highest and reverse so highest is the first
ratelist = ratelist[-count:]
ratelist.reverse()
pks = ["%i" % p[1] for p in ratelist]
pkstring = ",".join(pks)
log.debug('calculated highest rated products, set to cache: %s', pkstring)
cache_set(nce.key, value=pkstring)
def testCacheGetFail(self):
try:
caching.cache_get('x')
self.fail('should have raised NotCachedError')
except caching.NotCachedError:
pass
def testCacheGetDefault(self):
chk = caching.cache_get('default',default='-')
self.assertEqual(chk, '-')
def testCacheGetFail(self):
try:
caching.cache_get("x")
self.fail("should have raised NotCachedError")
except caching.NotCachedError:
pass
def testCacheGetDefault(self):
chk = caching.cache_get("default", default="-")
self.assertEqual(chk, "-")
def testCacheGetFail(self):
try:
caching.cache_get('x')
self.fail('should have raised NotCachedError')
except caching.NotCachedError:
pass
def testCacheGetDefault(self):
chk = caching.cache_get('default', default='-')
self.assertEqual(chk, '-')
def cache_get(self, *args, **kwargs):
key = self.cache_key(*args, **kwargs)
return caching.cache_get(key)
def cache_get(self, *args, **kwargs):
key = self.cache_key(*args, **kwargs)
return caching.cache_get(key)