def ready(self):

        # ensure that current LeprikonSite exists
        from .models.leprikonsite import LeprikonSite
        try:
            LeprikonSite.objects.get_current()
        except:
            pass

        # create leprikon page on first run
        from cms.api import create_page
        from cms.constants import TEMPLATE_INHERITANCE_MAGIC
        from menus.menu_pool import menu_pool
        from .conf import settings
        try:
            create_page(
                title='Leprikón',
                template=TEMPLATE_INHERITANCE_MAGIC,
                language=settings.LANGUAGE_CODE,
                slug='leprikon',
                apphook='LeprikonApp',
                apphook_namespace='leprikon',
                reverse_id='leprikon',
                in_navigation=True,
                navigation_extenders='LeprikonMenu',
                published=True,
            ).set_as_homepage()
            menu_pool.clear()
        except:
            pass

def pre_save_title(instance, raw, **kwargs):
    """Save old state to instance and setup path
    """
    if instance.page.languages:
        languages = instance.page.languages.split(',')
    else:
        languages = []
    if not instance.language in languages:
        languages.append(instance.language)
        instance.page.languages = ",".join(languages)
        instance.page._publisher_keep_state = True
        instance.page.save(no_signals=True)
    if not instance.page.publisher_is_draft:
        menu_pool.clear(instance.page.site_id)
    if instance.pk and not hasattr(instance, "tmp_path"):
        instance.tmp_path = None
        try:
            instance.tmp_path = Title.objects.filter(pk=instance.pk).values_list('path')[0][0]
        except IndexError:
            pass  # no Titles exist for this page yet
    # Build path from parent page's path and slug
    if instance.has_url_overwrite and instance.path:
        instance.path = instance.path.strip(" /")
    else:
        update_title(instance)
    apphook_pre_title_checker(instance, **kwargs)

 def process_request(self, request):
     """
     If we should show the toolbar for this request, put it on
     request.toolbar. Then call the request_hook on the toolbar.
     """
     if 'edit' in request.GET and not request.session.get('cms_edit', False):
         if not request.session.get('cms_edit', False):
             menu_pool.clear()
         request.session['cms_edit'] = True
         if request.session.get('cms_build', False):
             request.session['cms_build'] = False
     if 'edit_off' in request.GET and request.session.get('cms_edit', True):
         if request.session.get('cms_edit', True):
             menu_pool.clear()
         request.session['cms_edit'] = False
         if request.session.get('cms_build', False):
             request.session['cms_build'] = False
     if 'build' in request.GET and not request.session.get('cms_build', False):
         request.session['cms_build'] = True
     if request.user.is_staff:
         try:
             request.cms_latest_entry = LogEntry.objects.filter(
                 user=request.user,
                 action_flag__in=(ADDITION, CHANGE)
             ).only('pk').order_by('-pk')[0].pk
         except IndexError:
             request.cms_latest_entry = -1
     request.toolbar = CMSToolbar(request)

 def test_15_home_not_in_menu(self):
     with SettingsOverride(CMS_MODERATOR=False):
 
         page1 = Page.objects.get(pk=self.page1.pk)
         page1.in_navigation = False
         page1.save()
         page4 = Page.objects.get(pk=self.page4.pk)
         page4.in_navigation = False
         page4.save()
         context = self.get_context()
         tpl = Template("{% load menu_tags %}{% show_menu 0 100 100 100 %}")
         tpl.render(context) 
         nodes = context['children']
         self.assertEqual(len(nodes), 1)
         self.assertEqual(nodes[0].get_absolute_url(), "%s%s/" % (self.get_pages_root(), self.page2.get_slug()))
         self.assertEqual(nodes[0].children[0].get_absolute_url(), "%s%s/%s/" % (self.get_pages_root(), self.page2.get_slug(), self.page3.get_slug()))
         page4 = Page.objects.get(pk=self.page4.pk)
         page4.in_navigation = True
         page4.save()
         menu_pool.clear(settings.SITE_ID)
         context = self.get_context()
         tpl = Template("{% load menu_tags %}{% show_menu 0 100 100 100 %}")
         tpl.render(context) 
         nodes = context['children']
         self.assertEqual(len(nodes), 2)

def pre_save_title(instance, raw, **kwargs):
    """Save old state to instance and setup path
    """
    
    menu_pool.clear(instance.page.site_id)
    
    instance.tmp_path = None
    instance.tmp_application_urls = None
    
    if instance.id:
        try:
            tmp_title = Title.objects.get(pk=instance.id)
            instance.tmp_path = tmp_title.path
            instance.tmp_application_urls = tmp_title.application_urls
        except:
            pass # no Titles exist for this page yet
    
    # Build path from parent page's path and slug
    if instance.has_url_overwrite and instance.path:
        instance.path = instance.path.strip(" /")
    else:
        parent_page = instance.page.parent
        slug = u'%s' % instance.slug
        
        instance.path = u'%s' % slug
        if parent_page:
            parent_title = Title.objects.get_title(parent_page, language=instance.language, language_fallback=True)
            if parent_title:
                instance.path = (u'%s/%s' % (parent_title.path, slug)).lstrip("/")

 def setUp(self):
     super(BaseMenuTest, self).setUp()
     if not menu_pool.discovered:
         menu_pool.discover_menus()
     self.old_menu = menu_pool.menus
     menu_pool.menus = {'CMSMenu': self.old_menu['CMSMenu']}
     menu_pool.clear(settings.SITE_ID)

def pre_save_title(instance, raw, **kwargs):
    """Save old state to instance and setup path
    """
    page = instance.page
    page_languages = page.get_languages()

    if not instance.language in page_languages:
        page_languages.append(instance.language)
        page.update_languages(page_languages)

    if not page.publisher_is_draft:
        menu_pool.clear(page.site_id)

    if instance.pk and not hasattr(instance, "tmp_path"):
        instance.tmp_path = None
        try:
            instance.tmp_path = Title.objects.filter(pk=instance.pk).values_list("path")[0][0]
        except IndexError:
            pass  # no Titles exist for this page yet
    # Build path from parent page's path and slug
    if instance.has_url_overwrite and instance.path:
        instance.path = instance.path.strip(" /")
    else:
        update_title(instance)
    apphook_pre_title_checker(instance, **kwargs)

def pre_delete_page(instance, **kwargs):
    menu_pool.clear(instance.site_id)
    for placeholder in instance.placeholders.all():
        for plugin in placeholder.cmsplugin_set.all():
            plugin._no_reorder = True
            plugin.delete()
        placeholder.delete()
    clear_permission_cache()

 def test_incorrect_nav_extender_in_db(self):
     self._update_page(2, navigation_extenders="SomethingWrong")
     menu_pool.clear(settings.SITE_ID)
     context = self.get_context()
     tpl = Template("{% load menu_tags %}{% show_menu %}")
     tpl.render(context)
     nodes = context["children"]
     self.assertEqual(len(nodes), 2)

def pre_save_page(instance, **kwargs):
    instance.old_page = None
    try:
        instance.old_page = Page.objects.get(pk=instance.pk)
    except ObjectDoesNotExist:
        pass
    menu_pool.clear(instance.site_id)
    clear_permission_cache()

def pre_delete_page(instance, **kwargs):
    menu_pool.clear(instance.site_id)
    for placeholder in instance.get_placeholders():
        for plugin in placeholder.cmsplugin_set.all().order_by('-depth'):
            plugin._no_reorder = True
            plugin.delete(no_mp=True)
        placeholder.delete()
    clear_permission_cache()

 def save_model(self, request, obj, form, change):
     """
     Clear menu cache when changing menu structure
     """
     if 'config.menu_structure' in form.changed_data:
         from menus.menu_pool import menu_pool
         menu_pool.clear(all=True)
     return super(BlogConfigAdmin, self).save_model(request, obj, form, change)

 def test_extenders_on_root_child(self):
     self._update_page(4, navigation_extenders="TestMenu")
     menu_pool.clear(settings.SITE_ID)
     context = self.get_context()
     tpl = Template("{% load menu_tags %}{% show_menu 0 100 100 100 %}")
     tpl.render(context)
     nodes = context["children"]
     self.assertEqual(len(nodes), 2)
     self.assertEqual(len(nodes[1].children), 4)

def pre_save_page(instance, raw, **kwargs):
    """Helper pre save signal, assigns old_page attribute, so we can still
    compare changes. Currently used only if CMS_PUBLISHER
    """
    menu_pool.clear(instance.site_id)
    instance.old_page = None
    try:
        instance.old_page = Page.objects.get(pk=instance.pk)
    except ObjectDoesNotExist:
        pass

 def setUp(self):
     super(BaseMenuTest, self).setUp()
     u = User(username="test", is_staff = True, is_active = True, is_superuser = True)
     u.set_password("test")
     u.save()
     self.login_user(u)
     if not menu_pool.discovered:
         menu_pool.discover_menus()
     self.old_menu = menu_pool.menus
     menu_pool.menus = {'CMSMenu':self.old_menu['CMSMenu']}
     menu_pool.clear(settings.SITE_ID)

 def setUp(self):
     settings.CMS_MODERATOR = False
     u = User(username="test", is_staff = True, is_active = True, is_superuser = True)
     u.set_password("test")
     u.save()
     self.login_user(u)
     if not menu_pool.discovered:
         menu_pool.discover_menus()
     self.old_menu = menu_pool.menus
     menu_pool.menus = {'CMSMenu':self.old_menu['CMSMenu']}
     menu_pool.clear(settings.SITE_ID)
     self.create_some_nodes()

 def setUp(self):
     
     with SettingsOverride(CMS_MODERATOR = False):
         u = User(username="test", is_staff = True, is_active = True, is_superuser = True)
         u.set_password("test")
         u.save()
         self.login_user(u)
         menu_pool.clear(settings.SITE_ID)
         
         if not menu_pool.discovered:
             menu_pool.discover_menus()
         self.old_menu = menu_pool.menus
         menu_pool.menus = {'CMSMenu':self.old_menu['CMSMenu'], 'TestMenu':TestMenu()}

    def process_request(self, request):
        """
        If we should show the toolbar for this request, put it on
        request.toolbar. Then call the request_hook on the toolbar.
        """

        if not self.is_cms_request(request):
            return

        edit_on = get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')
        edit_off = get_cms_setting('CMS_TOOLBAR_URL__EDIT_OFF')
        build = get_cms_setting('CMS_TOOLBAR_URL__BUILD')
        disable = get_cms_setting('CMS_TOOLBAR_URL__DISABLE')
        anonymous_on = get_cms_setting('TOOLBAR_ANONYMOUS_ON')

        if disable in request.GET:
            request.session['cms_toolbar_disabled'] = True
        if edit_on in request.GET:  # If we actively enter edit mode, we should show the toolbar in any case
            request.session['cms_toolbar_disabled'] = False

        if not request.session.get('cms_toolbar_disabled', False) and (
                request.user.is_staff or (anonymous_on and request.user.is_anonymous())
        ):
            if edit_on in request.GET and not request.session.get('cms_edit', False):
                if not request.session.get('cms_edit', False):
                    menu_pool.clear()
                request.session['cms_edit'] = True
                if request.session.get('cms_build', False):
                    request.session['cms_build'] = False
            if edit_off in request.GET and request.session.get('cms_edit', True):
                if request.session.get('cms_edit', True):
                    menu_pool.clear()
                request.session['cms_edit'] = False
                if request.session.get('cms_build', False):
                    request.session['cms_build'] = False
            if build in request.GET and not request.session.get('cms_build', False):
                request.session['cms_build'] = True
        else:
            if request.session.get('cms_build'):
                request.session['cms_build'] = False
            if request.session.get('cms_edit'):
                request.session['cms_edit'] = False
        if request.user.is_staff:
            try:
                request.cms_latest_entry = LogEntry.objects.filter(
                    user=request.user,
                    action_flag__in=(ADDITION, CHANGE)
                ).only('pk').order_by('-pk')[0].pk
            except IndexError:
                request.cms_latest_entry = -1
        request.toolbar = CMSToolbar(request)

 def test_extenders_on_child(self):
     """
     TestMenu has 4 flat nodes
     """
     self._update_page(1, in_navigation=False)
     self._update_page(2, navigation_extenders="TestMenu")
     menu_pool.clear(settings.SITE_ID)
     menu_pool.clear(settings.SITE_ID)
     context = self.get_context()
     tpl = Template("{% load menu_tags %}{% show_menu 0 100 100 100 %}")
     tpl.render(context)
     nodes = context["children"]
     self.assertEqual(len(nodes), 2)
     self.assertEqual(len(nodes[0].children), 4)
     self.assertEqual(nodes[0].children[1].get_absolute_url(), "/")

    def test_02_extenders_on_root(self):
        Page.objects.filter(pk=1).update(navigation_extenders="TestMenu")
        menu_pool.clear(settings.SITE_ID)
        context = self.get_context()

        tpl = Template("{% load menu_tags %}{% show_menu 0 100 100 100 %}")
        tpl.render(context)
        nodes = context["children"]
        self.assertEqual(len(nodes), 2)
        self.assertEqual(len(nodes[0].children), 4)
        self.assertEqual(len(nodes[0].children[3].children), 1)
        Page.objects.filter(pk=1).update(in_navigation=False)
        menu_pool.clear(settings.SITE_ID)
        tpl = Template("{% load menu_tags %}{% show_menu %}")
        tpl.render(context)
        nodes = context["children"]
        self.assertEqual(len(nodes), 5)