class OpenGraphCategory(Item):
members_order = [
"title",
"code",
"types"
]
title = schema.String(
required = True,
unique = True,
translated = True,
spellcheck = True,
descriptive = True
)
code = schema.String(
required = True,
unique = True,
indexed = True
)
types = schema.Collection(
items = "woost.extensions.opengraph.opengraphtype.OpenGraphType",
bidirectional = True,
cascade_delete = True
)
def _load(self):
from woost.extensions.campaignmonitor import (campaignmonitorlist,
strings, useraction)
# Setup the synchronization view
from woost.controllers.backoffice.backofficecontroller \
import BackOfficeController
from woost.extensions.campaignmonitor.synccontroller import \
SyncCampaignMonitorListsController
BackOfficeController.sync_campaign_monitor_lists = \
SyncCampaignMonitorListsController
# Extension fields
from woost.extensions.campaignmonitor.campaignmonitorlist \
import CampaignMonitorList
CampaignMonitorExtension.add_member(
schema.String("api_key", required=True, text_search=False))
CampaignMonitorExtension.add_member(
schema.String("client_id", required=True, text_search=False))
CampaignMonitorExtension.add_member(
schema.Collection("lists",
items=schema.Reference(type=CampaignMonitorList),
integral=True,
related_end=schema.Reference()))
self.install()
class ValidationErrorResponse(ErrorResponse):
"""Response type for schema validation errors."""
status = 400
error_schema = schema.Schema(
members={
"type":
schema.String(
required=True,
doc="An identifier for the validation rule that failed"),
"message":
schema.String(
required=True,
doc="A human readable description of the validation error"),
"members":
schema.Collection(
items=schema.String(
required=True,
doc="The name of a member of the validated schema"),
doc="The members involved in the validation error")
})
def get_data(self, error: Exception) -> json_object:
data = super().get_data(error)
data["members"] = [
member.name for member in error.invalid_members if member.name
]
return data
class Template(Item):
type_group = "customization"
members_order = ["title", "identifier", "documents"]
title = schema.String(required=True,
unique=True,
indexed=True,
normalized_index=True,
full_text_indexed=True,
descriptive=True,
translated=True)
identifier = schema.String(required=True,
unique=True,
indexed=True,
max=255,
text_search=False)
documents = schema.Collection(items="woost.models.Document",
bidirectional=True,
editable=False,
synchronizable=False,
visible_in_reference_list=False)
class Change(PersistentObject):
"""A persistent record of an action performed on a CMS item."""
indexed = True
changeset = schema.Reference(required=True, type="woost.models.ChangeSet")
action = schema.String(required=True,
indexed=True,
enumeration=["create", "modify", "delete"])
target = schema.Reference(required=True,
type="woost.models.Item",
bidirectional=True)
changed_members = schema.Collection(type=set, items=schema.String())
item_state = schema.Mapping(required=False)
def __translate__(self, language, **kwargs):
return translations(
"woost.models.changesets.Change description",
action=self.action,
target=self.target) or PersistentObject.__translate__(
self, language, **kwargs)
class YouTubeVideo(Publishable):
instantiable = True
type_group = "resource"
uri_pattern = "http://youtube.com/watch?v=%s"
video_player = "cocktail.html.YouTubePlayer"
default_resource_type = "video"
members_order = ["title", "video_id"]
title = schema.String(
indexed = True,
normalized_index = True,
full_text_indexed = True,
descriptive = True,
translated = True,
spellcheck = True,
member_group = "content"
)
video_id = schema.String(
required = True,
listed_by_default = False,
normalization = lambda value: extract_video_id(value) or value,
member_group = "content"
)
def get_uri(self, **kwargs):
return URL(self.uri_pattern % (self.video_id,))
def is_internal_content(self, language = None):
return False
class SubscriptionFormBlock(Block):
instantiable = True
type_group = "blocks.forms"
members_order = ["subscriber_model", "lists"]
default_controller = \
"woost.extensions.campaign3.subscriptioncontroller.SubscriptionController"
subscriber_model = schema.String(
required=True,
default="woost.extensions.campaign3.subscriber.Subscriber",
text_search=False,
member_group="content")
lists = schema.Collection(items=schema.Reference(type=CampaignMonitorList),
min=1,
member_group="content",
listed_by_default=False)
view_class = schema.String(required=True,
shadows_attribute=True,
before_member="controller",
member_group="behavior")
class VimeoVideo(Publishable):
instantiable = True
type_group = "resource"
uri_pattern = "http://vimeo.com/%s"
video_player = "cocktail.html.VimeoPlayer"
default_resource_type = "video"
members_order = ["title", "video_id"]
title = schema.String(indexed=True,
normalized_index=True,
full_text_indexed=True,
descriptive=True,
translated=True,
member_group="content")
video_id = schema.String(required=True,
listed_by_default=False,
normalization=extract_video_id,
member_group="content")
def get_uri(self,
path=None,
parameters=None,
language=None,
host=None,
encode=True):
return self.uri_pattern % (self.video_id, )
class FacebookIdentityProvider(IdentityProvider):
provider_name = "Facebook"
user_identifier = "x_identity_facebook_user_id"
members_order = [
"client_id",
"client_secret",
"scope"
]
client_id = schema.String(
required=True,
text_search=False
)
client_secret = schema.String(
required=True,
text_search=False
)
scope = schema.Collection(
min=1,
default=schema.DynamicDefault(lambda: ["public_profile", "email"]),
items=schema.String()
)
def get_auth_url(self, target_url = None):
return (
"/facebook_oauth/%d/step1?%s" % (
self.id,
urlencode({
"target_url": target_url or get_request_url()
})
)
)
def __init__(self, *args, **kwargs):
schema.Schema.__init__(self, *args, **kwargs)
file_name_kw = {}
file_size_kw = {"min": 0}
mime_type_kw = {}
file_name_properties = kwargs.get("file_name_properties")
if file_name_properties:
file_name_kw.update(file_name_properties)
file_size_properties = kwargs.get("file_size_properties")
if file_size_properties:
file_size_kw.update(file_size_properties)
file_size_kw.setdefault(
"translate_value",
lambda value, language=None, **kwargs: format_bytes(value)
if value or value == 0 else "")
mime_type_properties = kwargs.get("mime_type_properties")
if mime_type_properties:
mime_type_kw.update(mime_type_properties)
self.add_member(schema.String("file_name", **file_name_kw))
self.add_member(schema.Integer("file_size", **file_size_kw))
self.add_member(schema.String("mime_type", **mime_type_kw))
class Event(Document):
members_order = [
"event_start", "event_end", "event_location", "image", "summary",
"blocks"
]
event_start = schema.DateTime(member_group="content", indexed=True)
event_end = schema.DateTime(member_group="content",
min=event_start,
indexed=True)
event_location = schema.String(edit_control="cocktail.html.TextArea",
translated=True,
member_group="content")
image = schema.Reference(type=File,
relation_constraints={"resource_type": "image"},
listed_by_default=False,
member_group="content")
summary = schema.String(translated=True,
edit_control="woost.views.RichTextEditor",
listed_by_default=False,
member_group="content")
blocks = Slot()
class BitlyURLShortener(URLShortener):
instantiable = True
members_order = ["login", "api_key"]
login = schema.String(required=True)
api_key = schema.String(required=True,
text_search=False,
listed_by_default=False)
def shorten_url(self, url):
response = urlopen("http://api.bitly.com/v3/shorten?"
"login=%s"
"&apiKey=%s"
"&longUrl=%s"
"&format=json" %
(self.login, self.api_key, quote(url)))
status = response.getcode()
body = response.read()
if status < 200 or status > 299:
raise URLShortenerServiceError(body)
return loads(body)["data"]["url"]
class TV3ALaCartaVideo(Publishable):
instantiable = True
type_group = "resource"
uri_pattern = "http://www.tv3.cat/videos/%s"
video_player = "woost.extensions.tv3alacarta.TV3ALaCartaPlayer"
default_resource_type = "video"
members_order = ["title", "video_id"]
title = schema.String(indexed=True,
normalized_index=True,
full_text_indexed=True,
descriptive=True,
translated=True,
member_group="content")
video_id = schema.String(required=True,
listed_by_default=False,
normalization=extract_video_id,
member_group="content")
def get_uri(self,
path=None,
parameters=None,
language=None,
host=None,
encode=True):
return self.uri_pattern % self.video_id
class CustomDefinition(Item):
visible_from_root = False
members_order = [
"title", "identifier", "definition_type", "enabled", "content_types",
"initialization"
]
title = schema.String(required=True,
indexed=True,
unique=True,
translated=True,
descriptive=True)
identifier = schema.String()
definition_type = schema.String(required=True,
default="dimension",
enumeration=["dimension", "metric"])
enabled = schema.Boolean(required=True, default=True)
content_types = schema.Collection(
items=schema.Reference(class_family=Item),
default=[Publishable],
min=1)
initialization = schema.CodeBlock(language="python")
def applies(self, publishable, website=None):
return isinstance(publishable, tuple(self.content_types))
def apply(self, publishable, values, index=None, env=None):
if not self.initialization:
return
if index is None:
from woost.models import Configuration
defs = Configuration.instance.google_analytics_custom_definitions
index = defs.index(self)
context = {
"publishable": publishable,
"index": index,
"value": schema.undefined,
"undefined": schema.undefined,
"env": {} if env is None else env
}
CustomDefinition.initialization.execute(self, context)
index = context["index"]
if index is not None:
value = context["value"]
if value is not schema.undefined:
key = self.definition_type + str(index)
value = get_ga_value(value)
values[key] = value
class SISPaymentGateway(PaymentGateway, Implementation):
instantiable = True
default_label = schema.DynamicDefault(
lambda: translations("SISPaymentGateway.label default"))
members_order = [
"merchant_name", "merchant_code", "merchant_terminal",
"merchant_secret_key", "pay_methods", "payment_successful_page",
"payment_failed_page"
]
merchant_code = schema.String(required=True,
shadows_attribute=True,
text_search=False)
merchant_name = schema.String(shadows_attribute=True, text_search=False)
merchant_terminal = schema.String(required=True,
shadows_attribute=True,
text_search=False)
merchant_secret_key = schema.String(required=True,
shadows_attribute=True,
text_search=False)
pay_methods = schema.Collection(
shadows_attribute = True,
items = schema.String(
enumeration = ["T", "D", "R"],
translate_value = lambda value, language = None, **kwargs: \
translations("SISPaymentGateway.pay_methods=%s" % (value,))
),
edit_control = "cocktail.html.CheckList"
)
payment_successful_page = schema.Reference(type=Document,
related_end=schema.Reference())
payment_failed_page = schema.Reference(type=Document,
related_end=schema.Reference())
def get_payment_successful_url(self, payment):
if self.payment_successful_page:
return self.payment_successful_page.get_uri(
host="!", parameters={"paymend_id": payment.id})
def get_payment_failed_url(self, payment):
if self.payment_failed_page:
return self.payment_failed_page.get_uri(
host="!", parameters={"paymend_id": payment.id})
class TwitterTimelineBlock(Block):
instantiable = True
type_group = "blocks.social"
view_class = "cocktail.html.TwitterTimeline"
members_order = [
"widget_id",
"theme",
"link_color",
"width",
"height",
"related_accounts"
]
widget_id = schema.String(
required = True,
member_group = "content"
)
theme = schema.String(
required = True,
default = "light",
enumeration = ("light", "dark"),
member_group = "appearence"
)
link_color = schema.Color(
member_group = "appearence"
)
width = schema.Integer(
member_group = "appearence"
)
height = schema.Integer(
member_group = "appearence"
)
related_accounts = schema.String(
member_group = "tweet"
)
def init_view(self, view):
Block.init_view(self, view)
view.widget_id = self.widget_id
view.theme = self.theme
view.link_color = self.link_color
view.width = self.width
view.height = self.height
view.related = self.related_accounts
class CampaignMonitorList(Item):
edit_node_class = \
"woost.extensions.campaign3.campaignmonitorlisteditnode.CampaignMonitorListEditNode"
members_order = [
"title",
"list_id",
"confirmation_page",
"confirmation_success_page",
"unsubscribe_page",
]
title = schema.String(required=True, descriptive=True)
list_id = schema.String(required=True, unique=True, text_search=False)
confirmation_page = schema.Reference(type="woost.models.Publishable",
related_end=schema.Collection())
confirmation_success_page = schema.Reference(
type="woost.models.Publishable", related_end=schema.Collection())
unsubscribe_page = schema.Reference(type="woost.models.Publishable",
related_end=schema.Collection())
def update(self):
list = List(
{
"api_key":
Configuration.instance.get_setting("campaign_monitor_api_key")
}, self.list_id)
details = list.details()
if self.confirmation_success_page:
confirmation_success_page = self.confirmation_success_page.get_uri(
host=".")
else:
confirmation_success_page = None
if self.unsubscribe_page:
unsubscribe_page = self.unsubscribe_page.get_uri(
host=".") + "?email=[email]"
else:
unsubscribe_page = None
list.update(details.Title,
unsubscribe_page,
details.ConfirmedOptIn,
confirmation_success_page,
unsubscribe_setting=details.UnsubscribeSetting)
class SiteInstallation(Item):
type_group = "setup"
edit_form = "woost.views.SiteInstallationForm"
edit_node_class = ("woost.controllers.backoffice."
"siteinstallationeditnode.SiteInstallationEditNode")
members_order = ("title", "url", "synchronization_user",
"synchronization_password")
default_synchronizable = False
title = schema.String(indexed=True,
unique=True,
descriptive=True,
required=True)
url = schema.URL(required=True)
synchronization_user = schema.String(listed_by_default=False)
synchronization_password = schema.String(
listed=False,
listed_by_default=False,
visible_in_detail_view=False,
searchable=False,
text_search=False,
edit_control="cocktail.html.PasswordBox")
@event_handler
def handle_changing(cls, event):
if event.member is cls.synchronization_password \
and event.value is not None:
event.value = User.encryption(event.value)
def test_password(self, password):
"""Indicates if the user's password matches the given string.
@param password: An unencrypted string to tests against the user's
encrypted password.
@type password: str
@return: True if the passwords match, False otherwise.
@rtype: bool
"""
if password:
return self.encryption(password) == self.synchronization_password
else:
return not self.synchronization_password
class Attribute(Item):
members_order = [
"title",
"enabled",
"content_types",
"scope",
"attribute_name",
"code"
]
title = schema.String(
required = True,
translated = True,
unique = True,
indexed = True,
descriptive = True
)
enabled = schema.Boolean(
required = True,
default = True,
indexed = True
)
content_types = schema.Collection(
items = schema.Reference(class_family = Item),
default = [Publishable],
ui_form_control = "cocktail.ui.SplitSelector",
min = 1
)
scope = schema.String(
required = True,
enumeration = ["any", "page", "ref"],
default = "any",
ui_form_control = "cocktail.ui.RadioSelector",
indexed = True
)
attribute_name = schema.String(
required = True,
unique = True,
indexed = True
)
code = schema.CodeBlock(
language = "python",
required = True
)
class EditTestModel(Item):
description = schema.String(required=True)
part = schema.Reference(bidirectional=True, integral=True)
container = schema.Reference(bidirectional=True)
class Subscriber(schema.SchemaObject):
members_order = ["subscriber_name", "subscriber_email"]
subscriber_name = schema.String(required=True)
subscriber_email = schema.EmailAddress(required=True)
class MemberPermission(Permission):
"""Base class for permissions that restrict operations on members."""
matching_members = schema.Collection(
default_type=set,
items=schema.String(
enumeration=lambda ctx: set(_eligible_members()),
translate_value=lambda value, language=None, **kwargs: ""
if not value else translations(_resolve_matching_member_reference(
value),
language,
qualified=True)),
edit_control="woost.views.MemberList")
def match(self, member, verbose=False):
member = member.original_member.schema.full_name + "." + member.name
members = self.matching_members
if members and member not in members:
if verbose:
print permission_doesnt_match_style("member doesn't match"),
return False
return True
def iter_matching_members(self):
for compound_name in self.matching_members:
yield _resolve_matching_member_reference(compound_name)
class TranslationPermission(Permission):
"""Base class for permissions that restrict operations on languages."""
def _matching_languages_enumeration(ctx):
from woost.models import Configuration
return Configuration.instance.languages
matching_languages = schema.Collection(
edit_control="cocktail.html.CheckList",
items=schema.String(
enumeration=_matching_languages_enumeration,
translate_value=lambda value, language=None, **kwargs: u""
if not value else translations(value, language, **kwargs)))
del _matching_languages_enumeration
def match(self, language, verbose=False):
languages = self.matching_languages
if languages and language not in languages:
if verbose:
print permission_doesnt_match_style("language doesn't match"),
return False
return True
class RenderPermission(ContentPermission):
"""Permission to obtain images representing instances of a content type."""
instantiable = True
def _image_factories_enumeration(ctx):
from woost.models.rendering.factories import image_factories
return image_factories.keys()
image_factories = schema.Collection(
items=schema.String(enumeration=_image_factories_enumeration),
searchable=False)
del _image_factories_enumeration
def match(self, target, image_factory, verbose=False):
if self.image_factories and image_factory not in self.image_factories:
print permission_doesnt_match_style("image_factory doesn't match")
return False
return ContentPermission.match(self, target, verbose)
@classmethod
def permission_not_found(cls, user, verbose=False, **context):
# If no specific render permission is found, a read permission will do
return user.has_permission(ReadPermission,
target=context["target"],
verbose=verbose)
def visible_languages(self):
return get_parameter(schema.Collection("language",
items=schema.String(),
default=[get_language()]),
source=CookieParameterSource(
cookie_naming="visible_languages",
cookie_duration=self.settings_duration))
def language_mode(self):
return get_parameter(schema.String(
"language_mode",
required=True,
enumeration=["all", "include", "exclude"],
default="all"),
errors="raise")
def submit(self):
mailing = self.context["cms_item"]
if self.mailer_action == "test":
# Send a test email
mailing._v_template_values = {
"cms": self.context["cms"],
"base_url": unicode(Location.get_current_host()).rstrip("/")
}
test_email = self.params.read(schema.String("test_email"))
# Create a fake user
receiver = User(email = test_email)
set_language(mailing.language)
mailing.send_message(self.smtp_server, receiver)
elif self.mailer_action == "send":
# Send the mailing
self.task_id = mailing.id
template_values = {
"cms": self.context["cms"],
"base_url": unicode(Location.get_current_host()).rstrip("/")
}
mailing.send(self.smtp_server, template_values, self.context.copy())
else:
EditController.submit(self)
class C(PersistentObject):
full_text_indexed = True
text = schema.String()
parent = schema.Reference(bidirectional=True)
def schema(self):
form_schema = schema.Schema("PasswordChangeConfirmationForm")
# New password
password_member = User.password.copy()
password_member.required = True
form_schema.add_member(password_member)
# New password confirmation
password_confirmation_member = schema.String(
name = "password_confirmation",
edit_control = "cocktail.html.PasswordBox",
required = True
)
@password_confirmation_member.add_validation
def validate_password_confirmation(member, value, ctx):
password = ctx.get_value("password")
password_confirmation = value
if password and password_confirmation \
and password != password_confirmation:
yield PasswordConfirmationError(member, value, ctx)
form_schema.add_member(password_confirmation_member)
return form_schema
class MailingList(Item):
members_order = ["title", "mailings"]
title = schema.String(
required = True,
unique = True,
indexed = True,
normalized_index = True,
full_text_indexed = True,
descriptive = True,
translated = True
)
users = schema.Collection(
items = "woost.models.User",
bidirectional = True,
listed_by_default = False
)
mailings = schema.Collection(
items = "woost.extensions.mailer.mailing.Mailing",
bidirectional = True,
editable = False,
listed_by_default = False
)
