def delete_navbar_cache():
# delete navbar cache from base.html
for user in UserProfile.objects.all():
key = make_template_fragment_key('navbar', [user.username, 'de'])
cache.delete(key)
key = make_template_fragment_key('navbar', [user.username, 'en'])
cache.delete(key)
def post_update(sender, instance, **kwargs):
cache.delete_many([
make_template_fragment_key('post_summary', (instance.id,)),
make_template_fragment_key('post_content', (instance.id,)),
'blog_slug:%d' % instance.id,
'blog_feed:%d' % instance.id,
])
def delete_navbar_cache_for_users(users):
# delete navbar cache from base.html
for user in users:
key = make_template_fragment_key('navbar', [user.username, 'de'])
cache.delete(key)
key = make_template_fragment_key('navbar', [user.username, 'en'])
cache.delete(key)
def profile_update(sender, instance, **kwargs):
if hasattr(instance, '_updating_stats_only'):
return
cache.delete_many([make_template_fragment_key('user_about', (instance.id,))] +
[make_template_fragment_key('org_member_count', (org_id,))
for org_id in instance.organizations.values_list('id', flat=True)])
def post_update(sender, instance, **kwargs):
cache.delete_many([
make_template_fragment_key('post_summary', (instance.id,)),
'blog_slug:%d' % instance.id,
'blog_feed:%d' % instance.id,
])
cache.delete_many([make_template_fragment_key('post_content', (instance.id, engine))
for engine in EFFECTIVE_MATH_ENGINES])
def handle(self, request, org, profile):
if profile.organization_id is not None:
return generic_message(request, 'Joining organization', 'You are already in an organization.')
profile.organization = org
profile.organization_join_time = timezone.now()
profile.save()
cache.delete(make_template_fragment_key('org_member_count', (org.id,)))
def test_index_cache_key(self):
key = make_template_fragment_key('index_page', [1])
self.authorized_client.get(reverse('index'))
self.assertTrue(bool(cache.get(key)),
'no cache under key "index_page"')
cache.clear()
self.assertFalse(bool(cache.get(key)), 'cache not cleaned')
def app_nav(context):
"""Renders the main nav, topnav on desktop, sidenav on mobile"""
url_name = get_url_name(context)
namespace = get_namespace(context)
cache_id = "{}:{}x".format(context['request'].user.username, context.request.path)
cache_key = make_template_fragment_key('app_nav', [cache_id])
context['app_nav_cache_id'] = cache_id
# Only bother doing this work if we don't have a cached template render
if not cache.get(cache_key):
# Build an app list for the page and user
app_list = []
for app in APP_LIST:
# Check we have access
if app['access'](context.request.user):
# Set active flag if namespace matches
app['active'] = (app['app'] == namespace)
# Add to returned list
app_list.append(app)
context['app_list'] = app_list
context['app'] = namespace
if namespace:
context['page_title'] = get_page_title(get_module_nav_list(namespace, url_name, context.request.user), context)
return context
def render(self, context):
try:
expire_time = self.expire_time_var.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError(
'"cache" tag got an unknown variable: %r' %
self.expire_time_var.var)
if expire_time is not None:
try:
expire_time = int(expire_time)
except (ValueError, TypeError):
raise TemplateSyntaxError(
'"cache" tag got a non-integer timeout value: %r' %
expire_time)
fragment_cache = cache
vary_on = [var.resolve(context) for var in self.vary_on]
cache_key = make_template_fragment_key(self.fragment_name, vary_on)
global_cache = fragment_cache.get('home_page_caches', [])
global_cache.append(cache_key)
fragment_cache.set('home_page_caches', global_cache, None)
value = fragment_cache.get(cache_key)
if value is None:
value = self.nodelist.render(context)
fragment_cache.set(cache_key, value, expire_time)
return value
def post(self, request, *args, **kwargs):
self.object = organization = self.get_object()
self.formset = formset = OrganizationRequestFormSet(request.POST, request.FILES)
if formset.is_valid():
if organization.slots is not None:
deleted_set = set(formset.deleted_forms)
to_approve = sum(form.cleaned_data['state'] == 'A' for form in formset.forms if form not in deleted_set)
can_add = organization.slots - organization.members.count()
if to_approve > can_add:
messages.error(request, _('Your organization can only receive %d more members. '
'You cannot approve %d users.') % (can_add, to_approve))
return self.render_to_response(self.get_context_data(object=organization))
approved, rejected = 0, 0
for obj in formset.save():
if obj.state == 'A':
obj.user.organizations.add(obj.organization)
approved += 1
elif obj.state == 'R':
rejected += 1
messages.success(request,
ungettext('Approved %d user.', 'Approved %d users.', approved) % approved + '\n' +
ungettext('Rejected %d user.', 'Rejected %d users.', rejected) % rejected)
cache.delete(make_template_fragment_key('org_member_count', (organization.id,)))
return HttpResponseRedirect(request.get_full_path())
return self.render_to_response(self.get_context_data(object=organization))
def update_angular_template_hash(sender, **kwargs):
"""Listen for compress events. If the angular templates
have been re-compressed, also clear them from the Django
cache backend. This is important to allow deployers to
change a template file, re-compress, and not accidentally
serve the old Django cached version of that content to
clients.
"""
context = kwargs['context'] # context the compressor is working with
compressed = context['compressed'] # the compressed content
compressed_name = compressed['name'] # name of the compressed content
if compressed_name == 'angular_template_cache_preloads':
# The compressor has modified the angular template cache preloads
# which are cached in the 'default' Django cache. Fetch that cache.
cache = caches['default']
# generate the same key as used in _scripts.html when caching the
# preloads
theme = context['THEME'] # current theme being compressed
key = make_template_fragment_key("angular",
['template_cache_preloads', theme])
# if template preloads have been cached, clear them
if cache.get(key):
cache.delete(key)
def show_course_toc(course, current=None):
material_list = course.material_set.all().values("id", "title", "body")
key = make_template_fragment_key("course_toc", [course.pk])
result = cache.get(key)
# if not cached, regenerate the course's toc
if result is None:
# attach toc to material
for material in material_list:
toc_url = reverse(
"courses:material_detail",
kwargs={
"slug": course.slug,
"pk": material["id"]
},
)
material["toc"] = generate_rich_content(material["body"],
toc_url=toc_url)["toc"]
context = {
"material_list": material_list,
"course": course,
"current": current,
}
return context
def render_tag(self, context, fragment_name, vary_on, var_name):
key = make_template_fragment_key(fragment_name, vary_on)
result = cache.get(key)
if var_name:
context[var_name] = result
return ''
return result
def save(self, *args, **kwargs):
"""Create a template fragment key.
Then delete the key."""
key = make_template_fragment_key("blog_post_preview", [self.id])
cache.delete(key)
return super().save(*args, **kwargs)
def edit(request, id=None):
if id:
task = Task.objects.get(pk=id)
form_post = reverse('task_edit', args=[id])
if not request.user.has_perm('contest.edit_task', task):
raise PermissionDenied
else:
task = Task()
form_post = reverse('task_new')
if not request.user.has_perm('contest.add_task'):
raise PermissionDenied
if request.method == "POST":
form = TaskForm(request.POST, instance=task)
else:
form = TaskForm(instance=task)
if form.is_valid():
new_task = form.save(commit=False)
if id is None:
new_task.author_id = request.user.pk
new_task.save()
assign_perm('contest.edit_task', request.user, new_task)
assign_perm('contest.view_task', request.user, new_task)
cache_key = make_template_fragment_key('task_description',
[new_task.pk])
cache.delete(cache_key)
return HttpResponseRedirect(reverse('task_details',
args=[new_task.pk]))
return render(request, 'contest/task_new.html',
{ 'form': form,
'form_post': form_post })
def render_tag(self, context, nested, kwargs, pre_node, node, post_node):
current = None
categories = None
if 'current' in kwargs:
current = kwargs.pop('current')
cache_key = False
output = None
if template_cache is not None and template_cache.supports_tags():
cache_key = make_template_fragment_key(
'categories', [
nested, current, str(pre_node + node + post_node)
]
)
output = template_cache.get(cache_key)
if output is None:
# Query categories
if nested:
categories = Category.objects.all()
else:
categories = Category.objects.root_nodes().flat_ordered()
if nested:
categories = cache_tree_children(categories)
output = self._render_categories(
context, nested, categories, current, pre_node, node, post_node
)
if cache_key:
template_cache.set(cache_key, output, tags=['categories'])
return output
def post(self, request, *args, **kwargs):
key = utils.make_template_fragment_key(
"{}.{}.{}".format(self.request.user.id, self.model_name, 'list')
)
cache.delete(key)
data = request.POST.copy()
clean_data = dict(
list_display=data.getlist('list_display'),
list_only_date=data.get('list_only_date', 1)
)
content = json.dumps(clean_data)
config = Configure.objects.filter(
content_type=get_content_type_for_model(self.model),
onidc_id=self.onidc_id, creator=self.request.user, mark='list'
).order_by('-pk')
if config.exists():
config = config.update(content=content)
else:
config = Configure.objects.create(
content_type=get_content_type_for_model(self.model),
onidc_id=self.onidc_id, creator=self.request.user,
mark='list', content=content
)
redirect_to = reverse_lazy('idcops:list', args=[self.model_name])
messages.success(request, "您的{}自定义列表配置完成".format(self.verbose_name))
return HttpResponseRedirect(redirect_to)
def form_valid(self, form):
from django.core.cache import cache
from django.core.cache.utils import make_template_fragment_key
key = make_template_fragment_key('meetplan_teacher_name_and_department', [self.request.user.id])
cache.delete(key)
form.instance.user = self.request.user
return super().form_valid(form)
def change_profile(request):
profile, _ = UserProfile.objects.get_or_create(user=request.user)
if request.POST:
form = ProfileForm(request.POST)
profile_form = UserProfileForm(request.POST,
request.FILES,
instance=profile)
if form.is_valid() and profile_form.is_valid():
request.user.email = form.cleaned_data['email']
if form.cleaned_data['passwd1']:
request.user.set_password(form.cleaned_data['passwd1'])
with transaction.atomic():
request.user.save()
profile_form.save()
# Invalidate userlist.html template cache fragment.
for group in request.user.groups.all():
key = make_template_fragment_key('dev-tu-profiles',
[group.name])
cache.delete(key)
return HttpResponseRedirect('/devel/')
else:
form = ProfileForm(initial={'email': request.user.email})
profile_form = UserProfileForm(instance=profile)
return render(request, 'devel/profile.html', {
'form': form,
'profile_form': profile_form
})
def handle(self, request, org, profile):
if not profile.organizations.filter(id=org.id).exists():
return generic_message(request, _('Leaving organization'),
_('You are not in "%s".') % org.short_name)
profile.organizations.remove(org)
cache.delete(make_template_fragment_key('org_member_count',
(org.id, )))
def clear_cache(self):
"""Clear the template cache for this project"""
key = make_template_fragment_key(
'project_detail_objects',
[self.pk],
)
cache.delete(key)
def delete_sidebar_cache(username):
from django.core.cache.utils import make_template_fragment_key
from blog.models import LINK_SHOW_TYPE
keys = (make_template_fragment_key('sidebar', [username + x[0]]) for x in LINK_SHOW_TYPE)
for k in keys:
logger.info('delete sidebar key:' + k)
cache.delete(k)
def edit(request, id=None):
if id:
contest = Contest.objects.get(pk=id)
form_post = reverse('contest_edit', args=[id])
if not request.user.has_perm('contest.manage',contest):
raise PermissionDenied
else:
contest = Contest()
form_post = reverse('contest_new')
if not request.user.has_perm('contest.add_contest'):
raise PermissionDenied
if request.method == 'POST':
form = ContestForm(request.POST, instance=contest)
else:
form = ContestForm(instance=contest)
if form.is_valid():
new_contest = form.save(commit=False)
new_contest.slug = slugify(new_contest.name)
if id is None:
new_contest.creator_id = request.user.pk
new_contest.save()
assign_perm('contest.manage', request.user, new_contest)
assign_perm('contest.view', request.user, new_contest)
cache_key = make_template_fragment_key('contest_description', [new_contest.pk])
cache.delete(cache_key)
return HttpResponseRedirect(reverse('contest_details', args=[new_contest.pk]))
return render(request, 'contest/contest_new.html', { 'form': form, 'form_post': form_post })
def post(self, request, *args, **kwargs):
self.object = organization = self.get_object()
self.formset = formset = OrganizationRequestFormSet(request.POST, request.FILES)
if formset.is_valid():
if organization.slots is not None:
deleted_set = set(formset.deleted_forms)
to_approve = sum(form.cleaned_data['state'] == 'A' for form in formset.forms if form not in deleted_set)
can_add = organization.slots - organization.members.count()
if to_approve > can_add:
messages.error(request, _('Your organization can only receive %d more members. '
'You cannot approve %d users.') % (can_add, to_approve))
return self.render_to_response(self.get_context_data(object=organization))
approved, rejected = 0, 0
for obj in formset.save():
if obj.state == 'A':
obj.user.organizations.add(obj.organization)
approved += 1
elif obj.state == 'R':
rejected += 1
messages.success(request,
ungettext('Approved %d user.', 'Approved %d users.', approved) % approved + '\n' +
ungettext('Rejected %d user.', 'Rejected %d users.', rejected) % rejected)
cache.delete(make_template_fragment_key('org_member_count', (organization.id,)))
return HttpResponseRedirect(request.get_full_path())
return self.render_to_response(self.get_context_data(object=organization))
def reset_cache_results(self):
for lang_key, lang_name in settings.LANGUAGES:
for distance in self.competition.get_distances():
cache_key = make_template_fragment_key('results_team_by_teamname', [lang_key, self.competition, distance])
cache.delete(cache_key)
for distance in self.competition.get_distances():
cache.delete('team_results_by_name_%i_%i' % (self.competition.id, distance.id))
def get(self, request, *args, **kwargs):
"""
Method that handles the GET requests for this view. Sets all other ``DataProduct``s to unfeatured in the
database, and sets the specified ``DataProduct`` to featured. Caches the featured image. Deletes previously
featured images from the cache.
"""
product_id = kwargs.get('pk', None)
product = DataProduct.objects.get(pk=product_id)
try:
current_featured = DataProduct.objects.filter(
featured=True,
data_product_type=product.data_product_type,
target=product.target)
for featured_image in current_featured:
featured_image.featured = False
featured_image.save()
featured_image_cache_key = make_template_fragment_key(
'featured_image', str(featured_image.target.id))
cache.delete(featured_image_cache_key)
except DataProduct.DoesNotExist:
pass
product.featured = True
product.save()
return redirect(
reverse('tom_targets:detail',
kwargs={'pk': request.GET.get('target_id')}))
def save(self, *args, **kwargs):
"""Invalidate this partner's pandoc-rendered html from cache"""
super(Partner, self).save(*args, **kwargs)
for code in RESOURCE_LANGUAGE_CODES:
short_description_cache_key = make_template_fragment_key(
'partner_short_description', [code, self.pk]
)
description_cache_key = make_template_fragment_key(
'partner_description', [code, self.pk]
)
send_instructions_cache_key = make_template_fragment_key(
'partner_send_instructions', [code, self.pk]
)
cache.delete(short_description_cache_key)
cache.delete(description_cache_key)
cache.delete(send_instructions_cache_key)
def save(self, *args, **kwargs):
"""Invalidate the rendered html stream description from cache"""
super(Stream, self).save(*args, **kwargs)
for code in RESOURCE_LANGUAGE_CODES:
cache_key = make_template_fragment_key('stream_description',
[code, self.pk])
cache.delete(cache_key)
def render(self, context):
try:
expire_time = self.expire_time_var.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError('"cache" tag got an unknown variable: %r' % self.expire_time_var.var)
if expire_time is not None:
try:
expire_time = int(expire_time)
except (ValueError, TypeError):
raise TemplateSyntaxError('"cache" tag got a non-integer timeout value: %r' % expire_time)
try:
fragment_cache = caches['template_fragments']
except InvalidCacheBackendError:
fragment_cache = caches['default']
page_obj, block_obj = self.page.resolve(context), self.block.resolve(context)
if getattr(context.request, 'is_preview', False):
# preview mode, do not pull from cache
return self.nodelist.render(context)
else:
vary_on = extract_block(block_obj)
fragment_name = '%s.%s' % (
block_obj.block.__class__.__module__,
block_obj.block.__class__.__name__,
)
cache_key = make_template_fragment_key(fragment_name, vary_on)
value = fragment_cache.get(cache_key)
if value is None:
value = self.nodelist.render(context)
fragment_cache.set(cache_key, value, expire_time)
return value
def contest_update(sender, instance, **kwargs):
if hasattr(instance, '_updating_stats_only'):
return
cache.delete_many(['generated-meta-contest:%d' % instance.id] +
[make_template_fragment_key('contest_html', (instance.id, engine))
for engine in EFFECTIVE_MATH_ENGINES])
def get_common_objects(self):
super().get_common_objects()
lang = "_" + get_language().lower()
key = make_template_fragment_key('accessibility_statement', [lang])
accessibility_statement = cache.get(key)
# TODO: refactor to a helper function
if not accessibility_statement:
local_template_name = "institution_accessibility_text{}.html"
local_template = try_get_template(local_template_name.format(lang))
if not local_template and len(lang) > 3:
local_template = try_get_template(local_template_name.format(lang[:3]))
if not local_template:
logger.warning("No localized accessibility statement for language %s", lang)
local_template = try_get_template(local_template_name.format(''))
if not local_template:
logger.error("No local accessibility content at all!")
local_accessibility_statement = local_template.render() if local_template else gettext("No local accessibility statement. Please notify the site's owner!")
system_template_name = "accessibility_issues{}.html"
system_template = try_get_template(system_template_name.format(lang))
if not system_template and len(lang) > 3:
system_template = try_get_template(system_template_name.format(lang[:3]))
if not system_template:
logger.warning("No localized system accessibility content for language %s", lang)
system_template = try_get_template(system_template_name.format(''))
if not system_template:
logger.error("No system accessibility content at all!")
system_accessibility_statement = system_template.render() if system_template else gettext("No system-wide accessibility statement found.")
accessibility_statement = local_accessibility_statement + system_accessibility_statement
cache.set(key, accessibility_statement)
self.accessibility_statement = accessibility_statement
self.note("accessibility_statement")
def _cache_support(self, expire_time, fragm_name, vary_on, lineno,
cache_name, caller):
try:
expire_time = int(expire_time)
except (ValueError, TypeError):
raise TemplateSyntaxError(
'"%s" tag got a non-integer timeout '
'value: %r' % (list(self.tags)[0], expire_time), lineno)
if cache_name:
try:
cache = get_cache(cahe_name)
except InvalidCacheBackendError:
raise TemplateSyntaxError(
'Invalid cache name specified for cache tag: {}'.format(
cache_name))
else:
try:
cache = get_cache('template_fragments')
except InvalidCacheBackendError:
cache = get_cache('default')
cache_key = make_template_fragment_key(fragm_name, vary_on)
value = cache.get(cache_key)
if value is None:
value = caller()
cache.set(cache_key, force_text(value), expire_time)
return value
def _cache_support(self, expire_time, fragm_name, vary_on, lineno, cache_name, caller):
try:
expire_time = int(expire_time)
except (ValueError, TypeError):
raise TemplateSyntaxError('"%s" tag got a non-integer timeout '
'value: %r' % (list(self.tags)[0], expire_time), lineno)
if cache_name:
try:
cache = get_cache(cahe_name)
except InvalidCacheBackendError:
raise TemplateSyntaxError('Invalid cache name specified for cache tag: {}'.format(cache_name))
else:
try:
cache = get_cache('template_fragments')
except InvalidCacheBackendError:
cache = get_cache('default')
cache_key = make_template_fragment_key(fragm_name, vary_on)
value = cache.get(cache_key)
if value is None:
value = caller()
cache.set(cache_key, force_text(value), expire_time)
return value
def update_angular_template_hash(sender, **kwargs):
"""Listen for compress events. If the angular templates
have been re-compressed, also clear them from the Django
cache backend. This is important to allow deployers to
change a template file, re-compress, and not accidentally
serve the old Django cached version of that content to
clients.
"""
context = kwargs['context'] # context the compressor is working with
compressed = context['compressed'] # the compressed content
compressed_name = compressed['name'] # name of the compressed content
if compressed_name == 'angular_template_cache_preloads':
# The compressor has modified the angular template cache preloads
# which are cached in the 'default' Django cache. Fetch that cache.
cache = caches['default']
# generate the same key as used in _scripts.html when caching the
# preloads
theme = context['THEME'] # current theme being compressed
key = make_template_fragment_key(
"angular",
['template_cache_preloads', theme]
)
# if template preloads have been cached, clear them
if cache.get(key):
cache.delete(key)
def render(self, context):
try:
expire_time = self.expire_time_var.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError('"cache" tag got an unknown variable: %r' % self.expire_time_var.var)
try:
expire_time = int(expire_time)
except (ValueError, TypeError):
raise TemplateSyntaxError('"cache" tag got a non-integer timeout value: %r' % expire_time)
if self.cache_name:
try:
cache_name = self.cache_name.resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError('"cache" tag got an unknown variable: %r' % self.cache_name.var)
try:
fragment_cache = caches[cache_name]
except InvalidCacheBackendError:
raise TemplateSyntaxError('Invalid cache name specified for cache tag: %r' % cache_name)
else:
try:
fragment_cache = caches['template_fragments']
except InvalidCacheBackendError:
fragment_cache = caches['default']
vary_on = [var.resolve(context) for var in self.vary_on]
cache_key = make_template_fragment_key(self.fragment_name, vary_on)
value = fragment_cache.get(cache_key)
if value is None:
value = self.nodelist.render(context)
fragment_cache.set(cache_key, value, expire_time)
return value
def handle(self, request, org, profile):
if org.id != profile.organization_id:
return generic_message(request, 'Leaving organization', 'You are not in "%s".' % org.key)
profile.organization = None
profile.organization_join_time = None
profile.save()
cache.delete(make_template_fragment_key('org_member_count', (org.id,)))
def reset_cache_results(self):
for lang_key, lang_name in settings.LANGUAGES:
for distance in self.competition.get_distances():
cache_key = make_template_fragment_key('results_team_by_teamname', [lang_key, self.competition, distance])
cache.delete(cache_key)
for distance in self.competition.get_distances():
cache.delete('team_results_by_name_%i_%i' % (self.competition.id, distance.id))
def edit(request, id=None):
if id:
test_env = TestEnvironment.objects.get(pk=id)
form_post = reverse('test_environment_edit', args=[id])
if not request.user.has_perm('checker.edit_test_environment',
test_env):
raise PermissionDenied
else:
test_env = TestEnvironment(maintainer=request.user)
form_post = reverse('test_environment_new')
if not request.user.has_perm('checker.add_test_environment'):
raise PermissionDenied
if request.method == "POST":
form = TestEnvironmentForm(request.POST, instance=test_env)
else:
form = TestEnvironmentForm(instance=test_env)
if form.is_valid():
new_test_env = form.save(commit=False)
# I suppose there is a nicer way to do this, but it works.
new_test_env.template_name = form.cleaned_data['template_name']
new_test_env.save()
assign_perm('checker.view_test_environment',
request.user,
new_test_env)
assign_perm('checker.edit_test_environment',
request.user,
new_test_env)
cache_key = make_template_fragment_key('test_environment_description',
[new_test_env.pk])
cache.delete(cache_key)
return HttpResponseRedirect(reverse('test_environment_details',
args=[new_test_env.pk]))
return render(request, 'checker/test_environment_new.html',
{ 'form': form,
'form_post': form_post })
def contest_update(sender, instance, **kwargs):
if hasattr(instance, '_updating_stats_only'):
return
cache.delete_many(['generated-meta-contest:%d' % instance.id] +
[make_template_fragment_key('contest_html', (instance.id, engine))
for engine in EFFECTIVE_MATH_ENGINES])
def get_context_data(self, **kwargs):
def get_bookmarked_post(thread, bookmark):
"""Return latest read post and page from bookmark timestamp."""
post = Post.objects\
.filter(thread=thread, created__gt=bookmark)\
.only('id', 'pk').first()
if post:
page = get_post_page(thread, post)
return post, page
else:
return post, None
user_id = self.request.user.id
context = super().get_context_data(**kwargs)
bookmarks = self.request.user.cached_bookmarks
for t in context['object_list']:
# get thread's bookmark and check if there are unread items
b = bookmarks.get(t.pk, None)
if b:
unread_items = t.modified > b
else:
unread_items = (True if t.modified >
self.request.user.resetDateTime else False)
key = make_template_fragment_key(
'thread_status',
[t.pk, self.request.user.pk, self.request.user.resetDateTime]
)
cached = cache.get('read_status/{}/{}'.format(user_id, t.id))
# check whether additional calculation is needed
if (key in cache and cached == 'unread' and unread_items) or \
(key in cache and cached == 'read' and not unread_items):
continue
else:
cache.delete(key)
# add bookmark and page to thread object
if b:
t.bookmark, t.page = get_bookmarked_post(t, b)
else:
t.bookmark, t.page = True, 1
# now check if user is a contributor in this thread
is_contributor = (
True if t.contributors.filter(id=user_id) else False
)
# now we've got all the data we needed, let's choose the correct
# status icon and behaviour
if unread_items:
status = 'unread_contributor' if is_contributor else 'unread'
cache.set(
'read_status/{}/{}'.format(user_id, t.id), 'unread', None
)
else:
status = 'read_contributor' if is_contributor else 'read'
t.bookmark = None
cache.set(
'read_status/{}/{}'.format(user_id, t.id), 'read', None
)
t.status = 'img/{}.png'.format(status)
return context
def test_cache(self):
"""
should return that the cache has been cleared after a post has been edited
"""
old_post = Post(date=timezone.now(), text="Old text")
new_post = Post(date=timezone.now(), text="New text")
key = make_template_fragment_key('posttemplate', [old_post])
self.assertEqual(cache.get(key), None)
def _config(self):
key = utils.make_template_fragment_key(
"{}.{}.{}".format(self.request.user.id, self.model_name, 'list')
)
data = cache.get_or_set(
key, get_user_config(self.request.user, 'list', self.model), 180
)
return data
def handle(self, request, org, profile):
if profile.organizations.filter(id=org.id).exists():
return generic_message(request, _('Joining organization'), _('You are already in the organization.'))
if not org.is_open:
return generic_message(request, _('Joining organization'), _('This organization is not open.'))
profile.organizations.add(org)
profile.save()
cache.delete(make_template_fragment_key('org_member_count', (org.id,)))
def save(self, *args, **kwargs):
key1 = make_template_fragment_key("brochure", [self.id])
cache.delete(key1)
# key2 = make_template_fragment_key("product_page", [self.id])
# cache.delete(key2)
return super().save(*args, **kwargs)
def cache_seq_incr(fragm_name, *vary_on):
cache_key = make_template_fragment_key(fragm_name, vary_on)
try:
seq = cache.incr(cache_key)
except ValueError:
seq = 1
cache.set(cache_key, seq)
return seq
def clear_from_caches(self):
target = "guidelines_footer"
try:
language_code = self.language.code
target = make_template_fragment_key(target, [language_code])
cache.delete(target)
except Exception:
logging.warning('Error deleting %s cache', target)
def save(self, *args, **kwargs):
key = make_template_fragment_key(
"home_page_streams",
[self.id],
)
cache.delete(key)
return super().save(*args, **kwargs)
def test_cache(self):
key = make_template_fragment_key('index_page')
response_old = self.authorized_client.get(reverse('index'))
new_post = Post.objects.create(author=self.user, text='Пример поста')
response_new = self.authorized_client.get(reverse('index'))
cache.touch(key, 0)
response_newest = self.authorized_client.get(reverse('index'))
self.assertNotEqual(response_old.content, response_newest.content)
def finished_submission(sub):
cache.delete('user_complete:%d' % sub.user_id)
if hasattr(sub, 'contest'):
participation = sub.contest.participation
cache.delete('contest_complete:%d' % participation.id)
cache.delete(make_template_fragment_key('conrank_user_prob',
(participation.profile.user_id,
participation.contest_id)))
def invalidate_template_fragment(fragment_name, *variables):
cache_key = make_template_fragment_key(fragment_name, vary_on=variables)
#i_have_it = cache.get(cache_key) is not None
# if i_have_it:
# sys.stderr.write("UTIL cache invalidation - key '{}' is there\n".format(cache_key))
# else:
# sys.stderr.write("UTIL cache invalidation - key '{}' is NOT there\n".format(cache_key))
cache.delete(cache_key)
def test_index_page_cache_key(self):
self.client.force_login(self.user)
self.post = Post.objects.create(text='Новый пост1', author=self.user)
key = make_template_fragment_key('index_page', [1])
self.client.get(reverse('index'))
self.assertTrue(bool(cache.get(key)))
cache.clear()
self.assertFalse(bool(cache.get(key)))
def _config(self):
key = utils.make_template_fragment_key(
f'{self.request.user.id}.{self.model_name}.list'
)
data = cache.get_or_set(
key, get_user_config(self.request.user, 'list', self.model), 180
)
return data
def test_index_cache_key(self):
""" test that there is cache with key 'index_page' """
key = make_template_fragment_key('index_page', [1])
self.client.get('/')
self.assertTrue(bool(cache.get(key)),
'no data in cache under key "index_page"')
cache.clear()
self.assertFalse(bool(cache.get(key)), 'cache not cleared')
def delete_sidebar_cache(username):
from django.core.cache.utils import make_template_fragment_key
from blog.models import LinkShowType
keys = (make_template_fragment_key('sidebar', [username + x])
for x in LinkShowType.values)
for k in keys:
logger.info('delete sidebar key:' + k)
cache.delete(k)
def invalidate_cache(self):
"""
Invalidate the HTML cache for all the publications of this researcher.
"""
for rpk in [a.researcher_id for a in self.author_set.filter(researcher_id__isnull=False)]+[None]:
for lang in POSSIBLE_LANGUAGE_CODES:
key = make_template_fragment_key('publiListItem', [self.pk, lang, rpk])
cache.delete(key)
def template_cache_delete(fragment_name, vary_on=None):
"""Delete the template cached content.
Args:
fragment_name: name of the template cached fragment
vary_on: list of arguments
"""
cache.delete(make_template_fragment_key(fragment_name, vary_on))
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
# Clean cached version of staticpage
for lang_code, lang_name in settings.LANGUAGES:
cache.delete(make_template_fragment_key("staticpage_staticpage_detail", (lang_code, self.id)))
# Reset menu
from config.urls import register_sitetrees
register_sitetrees()
def save_model(self, request, obj, form, change):
super(MemberAdmin, self).save_model(request, obj, form, change)
# Delete the cache of the current member after updating:
cache.delete('mk_%d' % obj.id)
# Delete the template key
obj_url = urllib.unquote(obj.get_absolute_url())
if not isinstance(obj_url, unicode):
obj_url = obj_url.decode('utf-8')
key = make_template_fragment_key('mks_detail', [obj.id, 1, obj_url])
cache.delete(key)
def problem_update(sender, instance, **kwargs):
if hasattr(instance, '_updating_stats_only'):
return
cache.delete_many([
make_template_fragment_key('submission_problem', (instance.id,)),
make_template_fragment_key('problem_feed', (instance.id,)),
'problem_tls:%s' % instance.id, 'problem_mls:%s' % instance.id,
])
cache.delete_many([make_template_fragment_key('problem_html', (instance.id, engine, lang))
for lang, _ in settings.LANGUAGES for engine in EFFECTIVE_MATH_ENGINES])
cache.delete_many([make_template_fragment_key('problem_authors', (instance.id, lang))
for lang, _ in settings.LANGUAGES])
cache.delete_many(['generated-meta-problem:%s:%d' % (lang, instance.id) for lang, _ in settings.LANGUAGES])
if hasattr(settings, 'DMOJ_PDF_PROBLEM_CACHE'):
for lang, _ in settings.LANGUAGES:
unlink_if_exists(get_pdf_path('%s.%s.pdf' % (instance.code, lang)))
unlink_if_exists(get_pdf_path('%s.%s.log' % (instance.code, lang)))
