Esempio n. 1
0
translations.load_bundle("woost.extensions.opengraph.publishable")

File.default_x_opengraph_enabled = False
File.default_x_opengraph_type = None

Publishable.members_order += ["x_opengraph_enabled", "x_opengraph_type"]


class GroupByOpenGraphCategory(GroupByMember):
    member = OpenGraphType.category


Publishable.add_member(
    schema.Boolean("x_opengraph_enabled",
                   required=True,
                   default=True,
                   listed_by_default=False,
                   member_group="meta.x_opengraph"))

Publishable.add_member(
    schema.Reference("x_opengraph_type",
                     type=OpenGraphType,
                     required=Publishable["x_opengraph_enabled"],
                     related_end=schema.Collection(block_delete=True),
                     default=schema.DynamicDefault(
                         lambda: OpenGraphType.get_instance(code="article")),
                     indexed=True,
                     listed_by_default=False,
                     member_group="meta.x_opengraph"))

Esempio n. 2
0
"""

@author:		Martí Congost
@contact:		[email protected]
@organization:	Whads/Accent SL
@since:			February 2010
"""
from decimal import Decimal
from cocktail.translations import translations
from cocktail import schema
from woost.models import Publishable, URI

Publishable.add_member(schema.Boolean("sitemap_indexable",
                                      required=True,
                                      default=True,
                                      indexed=True,
                                      member_group="sitemap",
                                      listed_by_default=False),
                       append=True)

URI.default_sitemap_indexable = False

Publishable.add_member(schema.String(
    "sitemap_change_frequency",
    enumeration=[
        "always", "hourly", "daily", "weekly", "monthly", "yearly", "never"
    ],
    translate_value=lambda value, language=None, **kwargs: ""
    if not value else translations(
        "woost.extensions.sitemap.change_frequency " + value, language, **
        kwargs),
@author:		Martí Congost
@contact:		[email protected]
@organization:	Whads/Accent SL
@since:			February 2010
"""
from decimal import Decimal
from cocktail.translations import translations
from cocktail import schema
from woost.models import Publishable, URI

translations.load_bundle("woost.extensions.sitemap.publishable")

URI.default_sitemap_indexable = False

Publishable.add_member(schema.String("x_sitemap_change_frequency",
                                     enumeration=[
                                         "always", "hourly", "daily", "weekly",
                                         "monthly", "yearly", "never"
                                     ],
                                     member_group="meta.robots",
                                     text_search=False,
                                     listed_by_default=False),
                       append=True)

Publishable.add_member(schema.Decimal("x_sitemap_priority",
                                      min=0,
                                      max=1,
                                      listed_by_default=False,
                                      member_group="meta.robots"),
                       append=True)
Esempio n. 4
0
    def _load(self):

        from cocktail.persistence import datastore
        from cocktail.controllers import UserCollection, get_parameter
        from cocktail.pkgutils import resolve
        from woost.models import (Publishable, Role, CreatePermission,
                                  get_current_user)
        from woost.models.changesets import changeset_context
        from woost.controllers.basecmscontroller import BaseCMSController

        # Import the extension's models
        from woost.extensions.comments import strings
        from woost.extensions.comments.comment import Comment

        # Captcha
        #------------------------------------------------------------------------------
        try:
            from woost.extensions.recaptcha import ReCaptchaExtension
        except ImportError:
            pass
        else:
            from woost.extensions.recaptcha.schemarecaptchas import ReCaptcha
            if ReCaptchaExtension.instance.enabled:
                CommentsExtension.add_member(
                    schema.Boolean("captcha_enabled", default=False))

        # Extend Publishable model
        Publishable.add_member(
            schema.Boolean("allow_comments",
                           required=True,
                           default=False,
                           member_group="administration"))

        Publishable.add_member(
            schema.Collection("comments",
                              items=schema.Reference(type=Comment),
                              bidirectional=True,
                              related_key="publishable",
                              integral=True))

        @when(BaseCMSController.processed)
        def _process_comments(event):

            # Comments variables initialization
            comments_user_collection = None
            comments_schema = None
            comment_errors = None
            comment_data = {}

            controller = event.source
            comment_model = \
                resolve(getattr(controller, "comment_model", Comment))
            publishable = controller.context["publishable"]
            user = get_current_user()

            if publishable is not None and publishable.allow_comments:

                # Comments collection
                comments_user_collection = UserCollection(comment_model)
                comments_user_collection.allow_type_selection = False
                comments_user_collection.allow_filters = False
                comments_user_collection.allow_language_selection = False
                comments_user_collection.allow_member_selection = False
                comments_user_collection.params.prefix = "comments_"
                comments_user_collection.base_collection = publishable.comments

                # Show the last comments page if not specified
                if "comments_page" not in cherrypy.request.params:
                    div, mod = divmod(len(comments_user_collection.subset),
                                      comments_user_collection.page_size)
                    comments_page = div - 1 if not mod and div != 0 else div
                    cherrypy.request.params.update(
                        comments_page=str(comments_page))

                # Adapting the comments model
                comments_schema = CommentsExtension.instance._adapt_comments_schema(
                    comment_model)

                if user.anonymous \
                and getattr(CommentsExtension.instance, "captcha_enabled", False):
                    comments_schema.add_member(ReCaptcha("captcha"))

                # Insert a new comment
                if cherrypy.request.method == "POST" \
                and "post_comment" in cherrypy.request.params:

                    with changeset_context(user):
                        get_parameter(comments_schema,
                                      target=comment_data,
                                      errors="ignore")

                        comment_errors = schema.ErrorList(
                            comments_schema.get_errors(comment_data))

                        if not comment_errors:
                            comment = comment_model()

                            adapter = CommentsExtension.instance._create_comments_adapter(
                                comment_model)
                            adapter.import_object(
                                comment_data,
                                comment,
                                source_schema=comments_schema,
                                target_schema=comment_model)

                            comment.publishable = publishable
                            user.require_permission(CreatePermission,
                                                    target=comment)

                            comment.insert()
                            datastore.commit()
                            CommentsExtension.instance._after_process_comments(
                                comment)
                else:
                    comment_errors = schema.ErrorList([])

            # Update the output
            controller.output.update(
                comments_user_collection=comments_user_collection,
                comments_schema=comments_schema,
                comment_errors=comment_errors,
                comment_data=comment_data)

        self.install()
Esempio n. 5
0
"""

.. moduleauthor:: Martí Congost <*****@*****.**>
"""
from cocktail.translations import translations
from cocktail import schema
from woost.models import Publishable, URI

translations.load_bundle("woost.extensions.staticpub.publishable")

Publishable.add_member(
    schema.Boolean(
        "x_staticpub_exportable",
        required=True,
        default=True,
        indexed=True,
        affects_cache_invalidation=False,
        listed_by_default=False,
        member_group="publication",
        shadows_attribute=True
    )
)

URI.default_x_staticpub_exportable = False

Esempio n. 6
0
from cocktail import schema
from cocktail.iteration import first
from cocktail.translations import translations
from cocktail.html.datadisplay import display_factory
from woost.models import Publishable, Document, News, File
from woost.extensions.opengraph.opengraphtype import OpenGraphType
from woost.extensions.opengraph.utils import export_content

File.default_open_graph_enabled = False
File.default_open_graph_type = None

Publishable.members_order += ["open_graph_enabled", "open_graph_type"]

Publishable.add_member(
    schema.Boolean("open_graph_enabled",
                   required=True,
                   default=True,
                   listed_by_default=False,
                   member_group="meta.open_graph"))

Publishable.add_member(
    schema.Reference("open_graph_type",
                     type=OpenGraphType,
                     required=Publishable["open_graph_enabled"],
                     related_end=schema.Collection(block_delete=True),
                     default=schema.DynamicDefault(
                         lambda: OpenGraphType.get_instance(code="article")),
                     indexed=True,
                     listed_by_default=False,
                     member_group="meta.open_graph",
                     edit_control=display_factory(
                         "cocktail.html.DropdownSelector",
Esempio n. 7
0
u"""

.. moduleauthor:: Martí Congost <*****@*****.**>
"""
from cocktail.modeling import extend, call_base
from cocktail.translations import translations
from cocktail import schema
from cocktail.html.datadisplay import display_factory
from woost.models import Publishable

Publishable.add_member(
    schema.Reference(
        "access_restriction",
        type="woost.extensions.restrictedaccess.accessrestriction."
        "AccessRestriction",
        bidirectional=True,
        indexed=True,
        edit_control=display_factory("cocktail.html.RadioSelector",
                                     empty_option_displayed=True),
        search_control="cocktail.html.DropdownSelector",
        member_group="publication"))


@extend(Publishable.access_restriction)
def translate_value(self, value, language=None, **kwargs):

    if not value:
        return translations("Publishable.access_restriction=None", language,
                            **kwargs)

    return call_base(value, language, **kwargs)