cms.signals: 164 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/cms/signals.py

Stats: 0 executed, 151 missed, 13 excluded, 123 ignored

  1. # -*- coding: utf-8 -*-
  2. from django.conf import settings
  3. from django.core.exceptions import ObjectDoesNotExist
  4. from django.db.models import signals
  5. from django.dispatch import Signal
  6. from cms.cache.permissions import (
  7. clear_user_permission_cache, clear_permission_cache)
  8. from cms.models import (Page, Title, CMSPlugin, PagePermission,
  9. GlobalPagePermission, PageUser, PageUserGroup)
  10. from menus.menu_pool import menu_pool
  11. # fired after page location is changed - is moved from one node to other
  12. page_moved = Signal(providing_args=["instance"])
  13. # fired when some of nodes (Title) with applications gets saved
  14. application_post_changed = Signal(providing_args=["instance"])
  15. # fired after page gets published - copied to public model - there may be more
  16. # than one instances published before this signal gets called
  17. post_publish = Signal(providing_args=["instance"])
  18. def update_plugin_positions(**kwargs):
  19. plugin = kwargs['instance']
  20. plugins = CMSPlugin.objects.filter(language=plugin.language, placeholder=plugin.placeholder).order_by("position")
  21. last = 0
  22. for p in plugins:
  23. if p.position != last:
  24. p.position = last
  25. p.save()
  26. last += 1
  27. signals.post_delete.connect(update_plugin_positions, sender=CMSPlugin, dispatch_uid="cms.plugin.update_position")
  28. def update_title_paths(instance, **kwargs):
  29. """Update child pages paths in case when page was moved.
  30. """
  31. for title in instance.title_set.all():
  32. title.save()
  33. page_moved.connect(update_title_paths, sender=Page, dispatch_uid="cms.title.update_path")
  34. def update_title(title):
  35. parent_page_id = title.page.parent_id
  36. slug = u'%s' % title.slug
  37. if title.page.is_home():
  38. title.path = ''
  39. elif not title.has_url_overwrite:
  40. title.path = u'%s' % slug
  41. if parent_page_id:
  42. parent_title = Title.objects.get_title(parent_page_id,
  43. language=title.language, language_fallback=True)
  44. if parent_title:
  45. title.path = (u'%s/%s' % (parent_title.path, slug)).lstrip("/")
  46. def pre_save_title(instance, raw, **kwargs):
  47. """Save old state to instance and setup path
  48. """
  49. menu_pool.clear(instance.page.site_id)
  50. instance.tmp_path = None
  51. instance.tmp_application_urls = None
  52. if instance.id:
  53. try:
  54. tmp_title = Title.objects.get(pk=instance.id)
  55. instance.tmp_path = tmp_title.path
  56. instance.tmp_application_urls = tmp_title.application_urls
  57. except:
  58. pass # no Titles exist for this page yet
  59. # Build path from parent page's path and slug
  60. if instance.has_url_overwrite and instance.path:
  61. instance.path = instance.path.strip(" /")
  62. else:
  63. update_title(instance)
  64. signals.pre_save.connect(pre_save_title, sender=Title, dispatch_uid="cms.title.presave")
  65. def post_save_title(instance, raw, created, **kwargs):
  66. # Update descendants only if path changed
  67. application_changed = False
  68. if instance.path != getattr(instance,'tmp_path',None) and not hasattr(instance, 'tmp_prevent_descendant_update'):
  69. descendant_titles = Title.objects.filter(
  70. page__lft__gt=instance.page.lft,
  71. page__rght__lt=instance.page.rght,
  72. page__tree_id__exact=instance.page.tree_id,
  73. language=instance.language,
  74. has_url_overwrite=False,
  75. ).order_by('page__tree_id', 'page__parent', 'page__lft')
  76. for descendant_title in descendant_titles:
  77. descendant_title.path = '' # just reset path
  78. descendant_title.tmp_prevent_descendant_update = True
  79. if descendant_title.application_urls:
  80. application_changed = True
  81. descendant_title.save()
  82. if not hasattr(instance, 'tmp_prevent_descendant_update') and \
  83. (instance.application_urls != getattr(instance, 'tmp_application_urls', None) or application_changed):
  84. # fire it if we have some application linked to this page or some descendant
  85. application_post_changed.send(sender=Title, instance=instance)
  86. # remove temporary attributes
  87. if getattr( instance, 'tmp_path', None):
  88. del(instance.tmp_path)
  89. if getattr( instance, 'tmp_application_urls' , None):
  90. del(instance.tmp_application_urls)
  91. try:
  92. del(instance.tmp_prevent_descendant_update)
  93. except AttributeError:
  94. pass
  95. signals.post_save.connect(post_save_title, sender=Title, dispatch_uid="cms.title.postsave")
  96. def post_save_user(instance, raw, created, **kwargs):
  97. """Signal called when new user is created, required only when CMS_PERMISSION.
  98. Asignes creator of the user to PageUserInfo model, so we now who had created
  99. this user account.
  100. requires: CurrentUserMiddleware
  101. """
  102. from cms.utils.permissions import get_current_user
  103. # read current user from thread locals
  104. creator = get_current_user()
  105. if not creator or not created or not hasattr(creator, 'pk'):
  106. return
  107. from django.db import connection
  108. # i'm not sure if there is a workaround for this, somebody any ideas? What
  109. # we are doing here is creating PageUser on Top of existing user, i'll do it
  110. # through plain SQL, its not nice, but...
  111. # TODO: find a better way than an raw sql !!
  112. cursor = connection.cursor()
  113. query = "INSERT INTO %s (user_ptr_id, created_by_id) VALUES (%d, %d)" % (
  114. PageUser._meta.db_table,
  115. instance.pk,
  116. creator.pk
  117. )
  118. cursor.execute(query)
  119. cursor.close()
  120. def post_save_user_group(instance, raw, created, **kwargs):
  121. """The same like post_save_user, but for Group, required only when
  122. CMS_PERMISSION.
  123. Asignes creator of the group to PageUserGroupInfo model, so we now who had
  124. created this user account.
  125. requires: CurrentUserMiddleware
  126. """
  127. from cms.utils.permissions import get_current_user
  128. # read current user from thread locals
  129. creator = get_current_user()
  130. if not creator or not created or creator.is_anonymous():
  131. return
  132. from django.db import connection
  133. # TODO: same as in post_save_user - raw sql is just not nice - workaround...?
  134. cursor = connection.cursor()
  135. query = "INSERT INTO %s (group_ptr_id, created_by_id) VALUES (%d, %d)" % (
  136. PageUserGroup._meta.db_table,
  137. instance.pk,
  138. creator.pk
  139. )
  140. cursor.execute(query)
  141. cursor.close()
  142. if settings.CMS_PERMISSION:
  143. # only if permissions are in use
  144. from django.contrib.auth.models import User, Group
  145. # regster signals to user related models
  146. signals.post_save.connect(post_save_user, User)
  147. signals.post_save.connect(post_save_user_group, Group)
  148. def pre_save_page(instance, raw, **kwargs):
  149. """Helper pre save signal, assigns old_page attribute, so we can still
  150. compare changes. Currently used only if CMS_PUBLISHER
  151. """
  152. instance.old_page = None
  153. try:
  154. instance.old_page = Page.objects.get(pk=instance.pk)
  155. except ObjectDoesNotExist:
  156. pass
  157. def post_save_page_moderator(instance, raw, created, **kwargs):
  158. """Helper post save signal, cleans old_page attribute.
  159. """
  160. old_page = instance.old_page
  161. del(instance.old_page)
  162. if settings.CMS_MODERATOR:
  163. # tell moderator something was happen with this page
  164. from cms.utils.moderator import page_changed
  165. page_changed(instance, old_page)
  166. def post_save_page(instance, **kwargs):
  167. for page in instance.get_descendants():
  168. for title in page.title_set.all():
  169. update_title(title)
  170. title.save()
  171. def update_placeholders(instance, **kwargs):
  172. instance.rescan_placeholders()
  173. def invalidate_menu_cache(instance, **kwargs):
  174. menu_pool.clear(instance.site_id)
  175. if settings.CMS_MODERATOR:
  176. # tell moderator, there is something happening with this page
  177. signals.pre_save.connect(pre_save_page, sender=Page, dispatch_uid="cms.page.presave")
  178. signals.post_save.connect(post_save_page_moderator, sender=Page, dispatch_uid="cms.page.postsave")
  179. signals.post_save.connect(post_save_page, sender=Page)
  180. signals.post_save.connect(update_placeholders, sender=Page)
  181. signals.pre_save.connect(invalidate_menu_cache, sender=Page)
  182. signals.pre_delete.connect(invalidate_menu_cache, sender=Page)
  183. def pre_save_user(instance, raw, **kwargs):
  184. clear_user_permission_cache(instance)
  185. def pre_delete_user(instance, **kwargs):
  186. clear_user_permission_cache(instance)
  187. def pre_save_group(instance, raw, **kwargs):
  188. if instance.pk:
  189. for user in instance.user_set.all():
  190. clear_user_permission_cache(user)
  191. def pre_delete_group(instance, **kwargs):
  192. for user in instance.user_set.all():
  193. clear_user_permission_cache(user)
  194. def pre_save_pagepermission(instance, raw, **kwargs):
  195. if instance.user:
  196. clear_user_permission_cache(instance.user)
  197. def pre_delete_pagepermission(instance, **kwargs):
  198. if instance.user:
  199. clear_user_permission_cache(instance.user)
  200. def pre_save_globalpagepermission(instance, raw, **kwargs):
  201. if instance.user:
  202. clear_user_permission_cache(instance.user)
  203. menu_pool.clear(all=True)
  204. def pre_delete_globalpagepermission(instance, **kwargs):
  205. if instance.user:
  206. clear_user_permission_cache(instance.user)
  207. def pre_save_delete_page(instance, **kwargs):
  208. clear_permission_cache()
  209. if settings.CMS_PERMISSION:
  210. signals.pre_save.connect(pre_save_user, sender=User)
  211. signals.pre_delete.connect(pre_delete_user, sender=User)
  212. signals.pre_save.connect(pre_save_user, sender=PageUser)
  213. signals.pre_delete.connect(pre_delete_user, sender=PageUser)
  214. signals.pre_save.connect(pre_save_group, sender=Group)
  215. signals.pre_delete.connect(pre_delete_group, sender=Group)
  216. signals.pre_save.connect(pre_save_group, sender=PageUserGroup)
  217. signals.pre_delete.connect(pre_delete_group, sender=PageUserGroup)
  218. signals.pre_save.connect(pre_save_pagepermission, sender=PagePermission)
  219. signals.pre_delete.connect(pre_delete_pagepermission, sender=PagePermission)
  220. signals.pre_save.connect(pre_save_globalpagepermission, sender=GlobalPagePermission)
  221. signals.pre_delete.connect(pre_delete_globalpagepermission, sender=GlobalPagePermission)
  222. signals.pre_save.connect(pre_save_delete_page, sender=Page)
  223. signals.pre_delete.connect(pre_save_delete_page, sender=Page)