def test_page_meta_gplus(self):
        """
        Tests the Google+ schema data
        """
        page, __ = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page)
        for key, val in self.page_data.items():
            setattr(page_meta, key, val)
        for key, val in self.gplus_data.items():
            setattr(page_meta, key, val)
        page_meta.save()

        page.reload()

        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.gplus_author, 'https://plus.google.com/{0}'.format(self.gplus_data['gplus_author']))
        self.assertEqual(meta.gplus_type, self.gplus_data['gplus_type'])

        new_data = copy(self.gplus_data)
        new_data['gplus_author'] = 'https://plus.google.com/+SomeUser'
        for key, val in new_data.items():
            setattr(page_meta, key, val)
        page_meta.save()
        page.reload()
        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.gplus_author, new_data['gplus_author'])

        new_data = copy(self.gplus_data)
        new_data['gplus_author'] = '/SomePage'
        for key, val in new_data.items():
            setattr(page_meta, key, val)
        page_meta.save()
        page.reload()
        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.gplus_author, 'https://plus.google.com{0}'.format(new_data['gplus_author']))
Esempio n. 2
0
    def test_none_page(self):
        meta = get_page_meta(None, 'en')
        self.assertIsNone(meta)

        request = self.get_page_request(SimpleLazyObject(lambda: None), self.user, '/')
        meta = get_page_meta(request.current_page, 'en')
        self.assertIsNone(meta)
Esempio n. 3
0
    def test_page_meta_og(self):
        """
        Tests the OpenGraph meta tags
        """
        page, page_2 = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page)
        for key, val in self.page_data.items():
            setattr(page_meta, key, val)
        for key, val in self.og_data.items():
            setattr(page_meta, key, val)
        page_meta.save()

        page.reload()

        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.og_type, self.og_data['og_type'])
        self.assertEqual(meta.og_author_url, self.og_data['og_author_url'])
        self.assertEqual(meta.og_profile_id, self.og_data['og_author_fbid'])
        self.assertEqual(meta.og_publisher, self.og_data['og_publisher'])
        self.assertEqual(meta.og_app_id, self.og_data['og_app_id'])
        self.assertEqual(meta.published_time, page.publication_date.isoformat())
        self.assertEqual(meta.modified_time, page.changed_date.isoformat())
        if page.publication_end_date:
            self.assertEqual(meta.expiration_time, page.publication_end_date.isoformat())
        else:
            self.assertFalse(hasattr(meta, 'expiration_time'))
    def test_custom_extra(self):
        page1, __ = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page1)
        page_meta.save()
        title_meta = models.TitleMeta.objects.create(extended_object=page1.get_title_obj('en'))
        title_meta.save()

        models.GenericMetaAttribute.objects.create(
            page=page_meta, attribute='custom', name='attr', value='foo'
        )
        models.GenericMetaAttribute.objects.create(
            title=title_meta, attribute='custom', name='attr', value='bar'
        )

        page1.reload()

        meta = get_page_meta(page1, 'en')
        self.assertEqual(meta.extra_custom_props, [('custom', 'attr', 'bar'), ('custom', 'attr', 'foo')])

        meta = get_page_meta(page1, 'it')
        self.assertEqual(meta.extra_custom_props, [('custom', 'attr', 'foo')])
    def test_page_meta_gplus(self):
        """
        Tests the Google+ schema data
        """
        page, __ = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page)
        for key, val in self.page_data.items():
            setattr(page_meta, key, val)
        for key, val in self.gplus_data.items():
            setattr(page_meta, key, val)
        page_meta.save()

        page.reload()

        meta = get_page_meta(page, 'en')
        self.assertEqual(
            meta.gplus_author, 'https://plus.google.com/{0}'.format(
                self.gplus_data['gplus_author']))
        self.assertEqual(meta.gplus_type, self.gplus_data['gplus_type'])

        new_data = copy(self.gplus_data)
        new_data['gplus_author'] = 'https://plus.google.com/+SomeUser'
        for key, val in new_data.items():
            setattr(page_meta, key, val)
        page_meta.save()
        page.reload()
        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.gplus_author, new_data['gplus_author'])

        new_data = copy(self.gplus_data)
        new_data['gplus_author'] = '/SomePage'
        for key, val in new_data.items():
            setattr(page_meta, key, val)
        page_meta.save()
        page.reload()
        meta = get_page_meta(page, 'en')
        self.assertEqual(
            meta.gplus_author,
            'https://plus.google.com{0}'.format(new_data['gplus_author']))
Esempio n. 6
0
    def test_tags(self):
        tags1 = ('pagetag.1', 'pagetag.2')
        tags2 = ('titletag.1', 'titletag.2')
        try:
            from djangocms_page_tags.models import PageTags, TitleTags
        except ImportError:
            self.skipTest('djangocms_page_tags not installed')
        page1, page2 = self.get_pages()
        page_ext = PageTags.objects.create(extended_object=page1)
        page_ext.tags.add(*tags1)
        title_ext = TitleTags.objects.create(
            extended_object=page1.get_title_obj('en'))
        title_ext.tags.add(*tags2)
        title_ext = TitleTags.objects.create(
            extended_object=page2.get_title_obj('en'))
        title_ext.tags.add(*tags2)

        for page in (page1, page2):
            page_meta = models.PageMeta.objects.create(extended_object=page)
            for key, val in self.page_data.items():
                setattr(page_meta, key, val)
            for key, val in self.og_data.items():
                setattr(page_meta, key, val)
            page_meta.save()
            page.reload()

        for lang in self.languages:
            page1.publish(lang)
            page2.publish(lang)
        page1 = page1.get_public_object()
        page2 = page2.get_public_object()

        meta1 = get_page_meta(page1, 'en')
        meta2 = get_page_meta(page2, 'en')
        for tag in (tags2 + tags1):
            self.assertTrue(tag in meta1.tag)
        for tag in tags2:
            self.assertTrue(tag in meta2.tag)
    def test_page_meta_no_meta(self):
        """
        Tests the meta if no PageMeta is set
        """
        meta_settings.GPLUS_AUTHOR = self.gplus_data['gplus_author']
        page, __ = self.get_pages()

        meta = get_page_meta(page, 'en')
        self.assertEqual(
            meta.gplus_author, 'https://plus.google.com/{0}'.format(self.gplus_data['gplus_author'])
        )
        self.assertEqual(meta.gplus_type, self.gplus_data['gplus_type'])
        self.assertEqual(meta.published_time, page.publication_date.isoformat())
        self.assertEqual(meta.modified_time, page.changed_date.isoformat())
        meta_settings.GPLUS_AUTHOR = ''
Esempio n. 8
0
    def test_tags(self):
        tags1 = ('pagetag.1', 'pagetag.2')
        tags2 = ('titletag.1', 'titletag.2')
        try:
            from djangocms_page_tags.models import PageTags, TitleTags
        except ImportError:
            self.skipTest('djangocms_page_tags not installed')
        page1, page2 = self.get_pages()
        page_ext = PageTags.objects.create(extended_object=page1)
        page_ext.tags.add(*tags1)
        title_ext = TitleTags.objects.create(extended_object=page1.get_title_obj('en'))
        title_ext.tags.add(*tags2)
        title_ext = TitleTags.objects.create(extended_object=page2.get_title_obj('en'))
        title_ext.tags.add(*tags2)

        for page in (page1, page2):
            page_meta = models.PageMeta.objects.create(extended_object=page)
            for key, val in self.page_data.items():
                setattr(page_meta, key, val)
            for key, val in self.og_data.items():
                setattr(page_meta, key, val)
            page_meta.save()
            page.reload()

        for lang in self.languages:
            page1.publish(lang)
            page2.publish(lang)
        page1 = page1.get_public_object()
        page2 = page2.get_public_object()

        meta1 = get_page_meta(page1, 'en')
        meta2 = get_page_meta(page2, 'en')
        for tag in (tags2 + tags1):
            self.assertTrue(tag in meta1.tag)
        for tag in tags2:
            self.assertTrue(tag in meta2.tag)
    def test_page_meta_no_meta(self):
        """
        Tests the meta if no PageMeta is set
        """
        meta_settings.GPLUS_AUTHOR = self.gplus_data['gplus_author']
        page, __ = self.get_pages()

        meta = get_page_meta(page, 'en')
        self.assertEqual(
            meta.gplus_author, 'https://plus.google.com/{0}'.format(
                self.gplus_data['gplus_author']))
        self.assertEqual(meta.gplus_type, self.gplus_data['gplus_type'])
        self.assertEqual(meta.published_time,
                         page.publication_date.isoformat())
        self.assertEqual(meta.modified_time, page.changed_date.isoformat())
        meta_settings.GPLUS_AUTHOR = ''
Esempio n. 10
0
    def test_page_meta_gplus(self):
        """
        Tests the Google+ schema data
        """
        page, page_2 = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page)
        for key, val in self.page_data.items():
            setattr(page_meta, key, val)
        for key, val in self.gplus_data.items():
            setattr(page_meta, key, val)
        page_meta.save()

        page.reload()

        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.gplus_author, self.gplus_data['gplus_author'])
        self.assertEqual(meta.gplus_type, self.gplus_data['gplus_type'])
Esempio n. 11
0
    def test_page_meta_gplus(self):
        """
        Tests the Google+ schema data
        """
        page, page_2 = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page)
        for key, val in self.page_data.items():
            setattr(page_meta, key, val)
        for key, val in self.gplus_data.items():
            setattr(page_meta, key, val)
        page_meta.save()

        page.reload()

        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.gplus_author, self.gplus_data['gplus_author'])
        self.assertEqual(meta.gplus_type, self.gplus_data['gplus_type'])
Esempio n. 12
0
    def test_page_meta_twitter(self):
        """
        Tests the Twitter cards
        """
        page, page_2 = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page)
        for key, val in self.page_data.items():
            setattr(page_meta, key, val)
        for key, val in self.twitter_data.items():
            setattr(page_meta, key, val)
        page_meta.save()

        page.reload()

        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.twitter_site, self.twitter_data['twitter_site'])
        self.assertEqual(meta.twitter_author, self.twitter_data['twitter_author'])
        self.assertEqual(meta.twitter_type, self.twitter_data['twitter_type'])
        self.assertEqual(meta.get_domain(), settings.META_SITE_DOMAIN)
    def test_page_meta_twitter(self):
        """
        Tests the Twitter cards
        """
        page, page_2 = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page)
        for key, val in self.page_data.items():
            setattr(page_meta, key, val)
        for key, val in self.twitter_data.items():
            setattr(page_meta, key, val)
        page_meta.save()

        page.reload()

        meta = get_page_meta(page, 'en')
        self.assertEqual(meta.twitter_site, self.twitter_data['twitter_site'])
        self.assertEqual(meta.twitter_author, self.twitter_data['twitter_author'])
        self.assertEqual(meta.twitter_type, self.twitter_data['twitter_type'])
        self.assertEqual(meta.get_domain(), settings.META_SITE_DOMAIN)
    def determine_meta_attributes(self, request, obj, language):
        page_meta = {}
        try:  # If a Django CMS page
            meta_dict = get_page_meta(obj, language).__dict__
        except AttributeError:
            try:  # If a Model object that uses the ModelMeta-mixin
                meta_dict = obj.get_meta(request)
            except Exception:
                meta_dict = {}

        # <meta property="some" content="value"> --> {'some (property)': value}
        page_meta.update({
            '{} ({})'.format(name, attr): value
            for attr, name, value in meta_dict.pop('extra_custom_props', [])
        })

        for key, value in meta_dict.items():
            if type(value) == list:
                page_meta[key] = ",".join(value)
            if type(value) == str and key not in META_FIELD_BLACKLIST:
                page_meta[key] = value
        return page_meta
Esempio n. 15
0
    def test_cache_cleanup_on_update_delete_meta(self):
        """
        Meta caches are emptied when updating / deleting a meta
        """
        page1, __ = self.get_pages()
        page_meta = models.PageMeta.objects.create(extended_object=page1)
        title_meta = models.TitleMeta.objects.create(
            extended_object=page1.get_title_obj("en"))

        # cache objects
        for language in page1.get_languages():
            get_page_meta(page1, language)
        title_key = get_cache_key(title_meta.extended_object.page,
                                  title_meta.extended_object.language)
        self.assertTrue(cache.get(title_key))

        # Title update check
        title_meta.description = "Something"
        title_meta.save()
        self.assertIsNone(cache.get(title_key))

        # Refreshing cache
        get_page_meta(page1, title_meta.extended_object.language)
        self.assertTrue(cache.get(title_key))

        # Page update check
        page_meta.og_author_url = "Something"
        page_meta.save()
        self.assertIsNone(cache.get(title_key))

        # Refreshing cache
        get_page_meta(page1, title_meta.extended_object.language)
        self.assertTrue(cache.get(title_key))

        # Check deleting objects
        title_meta.delete()
        self.assertIsNone(cache.get(title_key))

        page_meta.delete()
        for language in page1.get_languages():
            title_key = get_cache_key(page1, language)
            self.assertIsNone(cache.get(title_key))
Esempio n. 16
0
def get_page_meta(page, language):
    """
    Retrieves all the meta information for the page in the given language

    :param page: a Page instance
    :param lang: a language code

    :return: Meta instance
    :type: object
    """
    from django.core.cache import cache
    from meta.views import Meta
    from .models import PageMeta, TitleMeta

    meta_key = get_cache_key(page, language)
    meta = cache.get(meta_key)
    if not meta:
        meta = Meta()
        title = page.get_title_obj(language)

        meta.title = page.get_title(language)

        try:
            titlemeta = title.titlemeta
            meta.description = titlemeta.description.strip()
            meta.keywords = titlemeta.keywords.strip().split(",")
            meta.locale = titlemeta.locale
            if titlemeta.image:
                meta.image = title.titlemeta.image.url
        except TitleMeta.DoesNotExist:
            # Skipping title-level metas
            pass
        try:
            pagemeta = page.pagemeta
            meta.object_type = pagemeta.og_type
            meta.og_type = pagemeta.og_type
            meta.og_app_id = pagemeta.og_app_id
            meta.og_profile_id = pagemeta.og_author_fbid
            meta.twitter_type = pagemeta.twitter_type
            meta.twitter_site = pagemeta.twitter_site
            meta.twitter_author = pagemeta.twitter_author
            meta.gplus_type = pagemeta.gplus_type
            meta.gplus_author = pagemeta.gplus_author
            meta.published_time = page.publication_date.isoformat()
            meta.modified_time = page.changed_date.isoformat()
            if page.publication_end_date:
                meta.expiration_time = page.publication_end_date.isoformat()
            if meta.og_type == 'article':
                meta.og_publisher = pagemeta.og_publisher
                if pagemeta.og_author_url:
                    meta.og_author_url = pagemeta.og_author_url
                elif pagemeta.og_author:
                    meta.og_author = {
                        'first_name': pagemeta.og_author.first_name,
                        'last_name': pagemeta.og_author.last_name
                    }

                try:
                    from djangocms_page_meta.utils import get_title_tags, get_page_meta
                    tags = get_title_tags(page, language)
                    tags += get_page_meta(page, language)
                    meta.tag = ",".join(tags)
                except ImportError:
                    # djangocms-page-meta not available
                    pass
            if not meta.image and pagemeta.image:
                meta.image = pagemeta.image.url
        except PageMeta.DoesNotExist:
            # Skipping page-level metas
            pass
        if not meta.description and page.get_meta_description(language):
            meta.description = page.get_meta_description(language).strip()
        meta.url = page.get_absolute_url(language)
    return meta
Esempio n. 17
0
def get_page_meta(page, language):
    """
    Retrieves all the meta information for the page in the given language

    :param page: a Page instance
    :param lang: a language code

    :return: Meta instance
    :type: object
    """
    from django.core.cache import cache
    from meta.views import Meta
    from .models import PageMeta, TitleMeta

    meta_key = get_cache_key(page, language)
    meta = cache.get(meta_key)
    if not meta:
        meta = Meta()
        title = page.get_title_obj(language)

        meta.title = page.get_page_title(language)
        if not meta.title:
            meta.title = page.get_title(language)

        try:
            titlemeta = title.titlemeta
            meta.description = titlemeta.description.strip()
            if titlemeta.keywords:
                meta.keywords = titlemeta.keywords.strip().split(",")
            meta.locale = titlemeta.locale
            meta.og_description = titlemeta.og_description.strip()
            meta.twitter_description = titlemeta.twitter_description.strip()
            meta.gplus_description = titlemeta.gplus_description.strip()
            if titlemeta.image:
                meta.image = title.titlemeta.image.url
        except TitleMeta.DoesNotExist:
            # Skipping title-level metas
            pass
        try:
            pagemeta = page.pagemeta
            meta.object_type = pagemeta.og_type
            meta.og_type = pagemeta.og_type
            meta.og_app_id = pagemeta.og_app_id
            meta.og_profile_id = pagemeta.og_author_fbid
            meta.twitter_type = pagemeta.twitter_type
            meta.twitter_site = pagemeta.twitter_site
            meta.twitter_author = pagemeta.twitter_author
            meta.gplus_type = pagemeta.gplus_type
            meta.gplus_author = pagemeta.gplus_author
            meta.published_time = page.publication_date.isoformat()
            meta.modified_time = page.changed_date.isoformat()
            if page.publication_end_date:
                meta.expiration_time = page.publication_end_date.isoformat()
            if meta.og_type == 'article':
                meta.og_publisher = pagemeta.og_publisher
                if pagemeta.og_author_url:
                    meta.og_author_url = pagemeta.og_author_url
                try:
                    from djangocms_page_meta.utils import get_title_tags, get_page_meta
                    tags = get_title_tags(page, language)
                    tags += get_page_meta(page, language)
                    meta.tag = ",".join(tags)
                except ImportError:
                    # djangocms-page-meta not available
                    pass
            if not meta.image and pagemeta.image:
                meta.image = pagemeta.image.url
        except PageMeta.DoesNotExist:
            # Skipping page-level metas
            pass
        if not meta.description and page.get_meta_description(language):
            meta.description = page.get_meta_description(language).strip()
        meta.url = page.get_absolute_url(language)
    return meta