class TestPageImageTags(TestCase):
    def setUp(self):
        self.p = Page(title='test')
        self.p.save()

    def setUpTemplate(self):
        self.tmpl = Template(u'{% load pageimage_tags %}This will point to image \'{% pageimage \'BACKGROUND\' %}\'.')
        self.c = Context({'page': self.p})

    def test_simpletemplate_empty(self):
        self.setUpTemplate()
        tmplout = self.tmpl.render(self.c)
        self.assertTrue('\'\'' in tmplout)

    def test_simpletemplate_default(self):
        self.setUpTemplate()
        DefaultImage.objects.create(type='BACKGROUND', file='defaultback.jpg')
        self.assertTrue(
            '\'/static/media/defaultback.jpg\'' in self.tmpl.render(self.c)
        )

    def test_simpletemplate_specific(self):
        self.setUpTemplate()
        PageImage.objects.create(page=self.p, type='BACKGROUND', file='back.jpg')
        self.assertTrue(
            '\'/static/media/back.jpg\'' in self.tmpl.render(self.c)
        )

    def get_content_models(cls):
        """
        Return all Page subclasses that are admin registered, ordered
        based on the ``ADD_PAGE_ORDER`` setting.
        """
        models = []
        for model in Page.get_content_models():
            try:
                admin_url(model, "add")
            except NoReverseMatch:
                continue
            else:
                setattr(model, "meta_verbose_name", model._meta.verbose_name)
                setattr(model, "add_url", admin_url(model, "add"))
                models.append(model)
        order = [name.lower() for name in settings.ADD_PAGE_ORDER]

        def sort_key(page):
            name = "%s.%s" % (page._meta.app_label, page._meta.object_name)
            unordered = len(order)
            try:
                return (order.index(name.lower()), "")
            except ValueError:
                return (unordered, page.meta_verbose_name)
        return sorted(models, key=sort_key)

def get_page_types():
    qry = None
    for m in Page.get_content_models():
        q = models.Q(app_label=m._meta.app_label, model=m._meta.model_name)
        qry = qry | q if qry else q

    return qry

def models_for_pages(*args):
    """
    Create a select list containing each of the models that subclass the
    ``Page`` model.
    """
    page_models = []
    print Page.get_content_models()
    for model in Page.get_content_models():
        try:
            admin_url(model, "add")
        except NoReverseMatch:
            continue
        else:
            setattr(model, "name", model._meta.verbose_name)
            setattr(model, "add_url", admin_url(model, "add"))
            page_models.append(model)
    return page_models

    def setUp(self):
        self.user = User(username="asdf")
        self.user.set_password("asdf")
        self.user.save()

        p = os.path.dirname(os.path.abspath(__file__))

        icon = open(os.path.join(p, "test_files/icon.psd"))
        f_icon = File(icon)

        self.button = HybridButton(
            name="Testbutton",
            user=self.user,
            icon=f_icon,
        )
        self.button.save()

        page = Page(status='2', description="buttonizer", title="Buttonizer")
        page.save()

def autodiscover():
    autodiscover_modules('admin',register_to=site)

    for m in Page.get_content_models():
        try:
            adm = site._registry[m]
        except KeyError:
            continue

        if not isinstance(adm, PageAdmin) and isinstance(adm, mezz_PageAdmin):
            if site.safe_unregister(m):
                site.register(m, PageAdmin)

    site.lazy_registration()

def page_menu(context, token):
    """
    Return a list of child pages for the given parent, storing all
    pages in a dict in the context when first called using parents as keys
    for retrieval on subsequent recursive calls from the menu template.
    """
    # First arg could be the menu template file name, or the parent page.
    # Also allow for both to be used.
    template_name = None
    parent_page = None
    parts = token.split_contents()[1:]
    for part in parts:
        part = Variable(part).resolve(context)
        if isinstance(part, unicode):
            template_name = part
        elif isinstance(part, Page):
            parent_page = part
    if template_name is None:
        try:
            template_name = context["menu_template_name"]
        except KeyError:
            error = "No template found for page_menu in: %s" % parts
            raise TemplateSyntaxError(error)
    context["menu_template_name"] = template_name
    if "menu_pages" not in context:
        try:
            user = context["request"].user
            slug = context["request"].path
        except KeyError:
            user = None
            slug = ""
        num_children = lambda id: lambda: len(context["menu_pages"][id])
        has_children = lambda id: lambda: num_children(id)() > 0
        rel = [m.__name__.lower() for m in Page.get_content_models()]
        published = Page.objects.published(for_user=user).select_related(*rel)
        # Store the current page being viewed in the context. Used
        # for comparisons in page.set_menu_helpers.
        if "page" not in context:
            try:
                context["_current_page"] = published.get(slug=slug)
            except Page.DoesNotExist:
                context["_current_page"] = None
        elif slug:
            context["_current_page"] = context["page"]
        # Some homepage related context flags. on_home is just a helper
        # indicated we're on the homepage. has_home indicates an actual
        # page object exists for the homepage, which can be used to
        # determine whether or not to show a hard-coded homepage link
        # in the page menu.
        home = home_slug()
        context["on_home"] = slug == home
        context["has_home"] = False
        # Maintain a dict of page IDs -> parent IDs for fast
        # lookup in setting page.is_current_or_ascendant in
        # page.set_menu_helpers.
        context["_parent_page_ids"] = {}
        pages = defaultdict(list)
        for page in published.order_by("_order"):
            page.set_helpers(context)
            context["_parent_page_ids"][page.id] = page.parent_id
            setattr(page, "num_children", num_children(page.id))
            setattr(page, "has_children", has_children(page.id))
            pages[page.parent_id].append(page)
            if page.slug == home:
                context["has_home"] = True
        context["menu_pages"] = pages
    # ``branch_level`` must be stored against each page so that the
    # calculation of it is correctly applied. This looks weird but if we do
    # the ``branch_level`` as a separate arg to the template tag with the
    # addition performed on it, the addition occurs each time the template
    # tag is called rather than once per level.
    context["branch_level"] = 0
    parent_page_id = None
    if parent_page is not None:
        context["branch_level"] = getattr(parent_page, "branch_level", 0) + 1
        parent_page_id = parent_page.id

    # Build the ``page_branch`` template variable, which is the list of
    # pages for the current parent. Here we also assign the attributes
    # to the page object that determines whether it belongs in the
    # current menu template being rendered.
    context["page_branch"] = context["menu_pages"].get(parent_page_id, [])
    context["page_branch_in_menu"] = False
    for page in context["page_branch"]:
        page.in_menu = page.in_menu_template(template_name)
        page.num_children_in_menu = 0
        if page.in_menu:
            context["page_branch_in_menu"] = True
        for child in context["menu_pages"].get(page.id, []):
            if child.in_menu_template(template_name):
                page.num_children_in_menu += 1
        page.has_children_in_menu = page.num_children_in_menu > 0
        page.branch_level = context["branch_level"]
        page.parent = parent_page

        # Prior to pages having the ``in_menus`` field, pages had two
        # boolean fields ``in_navigation`` and ``in_footer`` for
        # controlling menu inclusion. Attributes and variables
        # simulating these are maintained here for backwards
        # compatibility in templates, but will be removed eventually.
#.........这里部分代码省略.........

def page_menu(context, token):
    """
    Return a list of child pages for the given parent, storing all
    pages in a dict in the context when first called using parents as keys
    for retrieval on subsequent recursive calls from the menu template.
    """
    # First arg could be the menu template file name, or the parent page.
    # Also allow for both to be used.
    template_name = None
    parent_page = None
    parts = token.split_contents()[1:]
    for part in parts:
        part = Variable(part).resolve(context)
        if isinstance(part, unicode):
            template_name = part
        elif isinstance(part, Page):
            parent_page = part
    if template_name is None:
        try:
            template_name = context["menu_template_name"]
        except KeyError:
            error = "No template found for page_menu in: %s" % parts
            raise TemplateSyntaxError(error)
    context["menu_template_name"] = template_name
    if "menu_pages" not in context:
        try:
            user = context["request"].user
            slug = context["request"].path
        except KeyError:
            user = None
            slug = ""
        num_children = lambda id: lambda: len(context["menu_pages"][id])
        has_children = lambda id: lambda: num_children(id)() > 0
        published = Page.objects.published(for_user=user)
        if slug == admin_url(Page, "changelist"):
            related = [m.__name__.lower() for m in Page.get_content_models()]
            published = published.select_related(*related)
        else:
            published = published.select_related(depth=2)
        # Store the current page being viewed in the context. Used
        # for comparisons in page.set_menu_helpers.
        if "page" not in context:
            try:
                context["_current_page"] = published.get(slug=slug)
            except Page.DoesNotExist:
                context["_current_page"] = None
        elif slug:
            context["_current_page"] = context["page"]
        # Maintain a dict of page IDs -> parent IDs for fast
        # lookup in setting page.is_current_or_ascendant in
        # page.set_menu_helpers.
        context["_parent_page_ids"] = {}
        pages = defaultdict(list)
        for page in published.order_by("_order"):
            context["_parent_page_ids"][page.id] = page.parent_id
            page.set_helpers(context)
            setattr(page, "num_children", num_children(page.id))
            setattr(page, "has_children", has_children(page.id))
            pages[page.parent_id].append(page)
        context["menu_pages"] = pages
        context["on_home"] = slug == reverse("home")
    # ``branch_level`` must be stored against each page so that the
    # calculation of it is correctly applied. This looks weird but if we do
    # the ``branch_level`` as a separate arg to the template tag with the
    # addition performed on it, the addition occurs each time the template
    # tag is called rather than once per level.
    context["branch_level"] = 0
    parent_page_id = None
    if parent_page is not None:
        context["branch_level"] = getattr(parent_page, "branch_level", 0) + 1
        parent_page_id = parent_page.id
    context["page_branch"] = context["menu_pages"].get(parent_page_id, [])
    context['page_branch_in_navigation'] = False
    context['page_branch_in_footer'] = False
    for page in context["page_branch"]:
        if page.in_navigation:
            context['page_branch_in_navigation'] = True
        if page.in_footer:
            context['page_branch_in_footer'] = True
        if (context.get('page_branch_in_navigation') and
            context.get('page_branch_in_footer')):
            break
    for i, page in enumerate(context["page_branch"]):
        context["page_branch"][i].branch_level = context["branch_level"]
        context["page_branch"][i].parent = parent_page
    t = get_template(template_name)
    return t.render(context)

 def setUp(self):
     self.p = Page(title='test')
     self.p.save()

class TestGetImageForPage(TestCase):
    def setUp(self):
        self.p = Page(title='test')
        self.p.save()

    def setUpDefaultImage(self):
        di = DefaultImage(file='default.jpg', type='BACKGROUND')
        di.save()

    def setUpPageImage(self):
        pi = PageImage(page=self.p, type='BACKGROUND', file='test.jpg')
        pi.save()

    def test_get_empty(self):
        self.assertEqual(
            '',
            get_image_for_page(self.p, 'BACKGROUND')
        )

    def test_get_default_image(self):
        self.setUpDefaultImage()

        self.assertEqual(
            '/static/media/default.jpg',
            get_image_for_page(self.p, 'BACKGROUND')
        )

    def test_get_specific_image(self):
        self.setUpDefaultImage()
        self.setUpPageImage()

        self.assertEqual(
            '/static/media/test.jpg',
            get_image_for_page(self.p, 'BACKGROUND')
        )

    def test_get_child_images(self):
        self.setUpDefaultImage()
        self.setUpPageImage()

        p1 = Page.objects.create(title='child1', parent=self.p)
        p2 = Page.objects.create(title='child2', parent=self.p)

        PageImage.objects.create(page=p2, type='BACKGROUND', file='child2.jpg')

        self.assertEqual(
            '/static/media/test.jpg',
            get_image_for_page(p1, 'BACKGROUND')
        )
        self.assertEqual(
            '/static/media/child2.jpg',
            get_image_for_page(p2, 'BACKGROUND')
        )

    def test_get_banner_image(self):
        DefaultImage.objects.create(type='BANNER', file='defaultbanner.jpg')

        self.assertEqual(
            '/static/media/defaultbanner.jpg',
            get_image_for_page(self.p, 'BANNER')
        )