class EditTestModel(Item):
description = schema.String(required=True)
part = schema.Reference(bidirectional=True, integral=True)
container = schema.Reference(bidirectional=True)
class VideoBlock(Block):
instantiable = True
view_class = "woost.views.VideoBlockView"
block_display = "woost.views.VideoBlockDisplay"
member_order = ["element_type", "video", "player_settings"]
element_type = ElementType(member_group="content")
video = schema.Reference(type=Publishable,
required=True,
relation_constraints={"resource_type": "video"},
related_end=schema.Collection(),
invalidates_cache=True,
member_group="content")
player_settings = schema.Reference(type=VideoPlayerSettings,
required=True,
related_end=schema.Collection(),
invalidates_cache=True,
member_group="content")
def get_block_image(self):
return self.video
def init_view(self, view):
Block.init_view(self, view)
view.tag = self.element_type
view.video = self.video
view.player_settings = self.player_settings
view.depends_on(self.video)
def form_schema(self):
return schema.Schema("FacebookPublicationForm", members = [
schema.Collection("subset",
items = schema.Reference(
type = Publishable,
required = True,
enumeration = lambda ctx: self.selection
),
min = 1,
default = schema.DynamicDefault(lambda: self.selection)
),
schema.Collection("published_languages",
items = schema.String(
translate_value = lambda value, language = None, **kwargs:
"" if not value
else translations(value, language, **kwargs),
enumeration = lambda ctx: self.eligible_languages
),
min = 1,
default = schema.DynamicDefault(
lambda: self.eligible_languages
)
),
schema.Collection("publication_targets",
items = schema.Reference(
type = FacebookPublicationTarget,
required = True,
enumeration = lambda ctx: self.allowed_publication_targets
),
min = 1,
default = schema.DynamicDefault(
lambda: self.allowed_publication_targets
)
)
])
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 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 PayPalPaymentGateway(PaymentGateway, Implementation):
instantiable = True
default_label = schema.DynamicDefault(
lambda: translations("PayPalPaymentGateway.label default"))
members_order = [
"business", "payment_successful_page", "payment_failed_page"
]
business = schema.String(required=True,
shadows_attribute=True,
text_search=False)
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={"payment_id": payment.id})
def get_payment_failed_url(self, payment):
if self.payment_failed_page:
return self.payment_failed_page.get_uri(
host="!", parameters={"payment_id": payment.id})
class UserReference(UserRelation):
instantiable = True
groups_order = UserMember.groups_order
member_class = schema.Reference
edit_controls = [
"cocktail.html.DropdownSelector", "cocktail.html.RadioSelector",
"woost.views.ItemSelector"
]
search_controls = [
"cocktail.html.DropdownSelector", "cocktail.html.RadioSelector",
"woost.views.ItemSelector"
]
member_type = schema.Reference(class_family=Item,
member_group="definition")
member_class_family = schema.Reference(class_family=Item,
member_group="definition")
member_type.exclusive = member_class_family.not_()
member_class_family = member_type.not_()
member_cycles_allowed = schema.Boolean(required=True,
default=True,
listed_by_default=False,
member_group="definition")
class A(PersistentObject):
full_text_indexed = True
text = schema.String()
child = schema.Reference(bidirectional=True, text_search=True)
irrelevant_child = schema.Reference(bidirectional=True)
def form_model(self):
from woost.extensions.staticsite import StaticSiteExtension
extension = StaticSiteExtension.instance
site_languages = Configuration.instance.languages
def allowed_destinations():
return [
destination
for destination in extension.destinations
if get_current_user().has_permission(
ExportationPermission,
destination = destination
)
]
return schema.Schema("ExportStaticSite", members = [
schema.Reference(
"snapshoter",
type =
"woost.extensions.staticsite.staticsitesnapshoter."
"StaticSiteSnapShoter",
required = True,
enumeration = lambda ctx: extension.snapshoters,
edit_control =
"cocktail.html.RadioSelector"
if len(allowed_destinations()) > 1
else "cocktail.html.HiddenInput",
default = schema.DynamicDefault(lambda: extension.snapshoters[0])
),
schema.Reference(
"destination",
type =
"woost.extensions.staticsite.staticsitedestination."
"StaticSiteDestination",
required = True,
enumeration = lambda ctx: allowed_destinations(),
edit_control =
"cocktail.html.RadioSelector"
if len(allowed_destinations()) > 1
else "cocktail.html.HiddenInput",
default = schema.DynamicDefault(lambda: allowed_destinations()[0])
),
schema.Boolean(
"update_only",
required = True,
default = True
),
schema.Boolean(
"follow_links",
required = True,
default = True
)
])
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 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 SignUpPage(Document):
members_order = [
"user_type", "roles", "confirmation_target",
"confirmation_email_template"
]
# Defines the persistent class that will be
# used like schema in signup process
user_type = schema.Reference(class_family=User,
required=True,
member_group="signup_process")
# The collection of roles that will be applyed
# to each instance (of user_type class) created throw
# a signuppage
roles = schema.Collection(
items="woost.models.Role",
related_end=schema.Collection(name="related_signup_pages",
visible=False),
member_group="signup_process",
relation_constraints=lambda ctx: [excluded_roles()])
# If is None, doesn't require an email confirmation
# process to complete signup process
confirmation_email_template = schema.Reference(
type=EmailTemplate,
related_end=schema.Collection(),
member_group="signup_process")
confirmation_target = schema.Reference(type="woost.models.Publishable",
related_end=schema.Collection(),
member_group="signup_process",
required=True)
default_template = schema.DynamicDefault(lambda: Template.get_instance(
qname=u"woost.extensions.signup.signup_template"))
default_controller = schema.DynamicDefault(lambda: Controller.get_instance(
qname=u"woost.extensions.signup.signup_controller"))
default_confirmation_email_template = schema.DynamicDefault(
lambda: EmailTemplate.get_instance(
qname=u"woost.extensions.signup.signup_confirmation_email_template"
))
default_confirmation_target = schema.DynamicDefault(
lambda: Publishable.get_instance(
qname=u"woost.extensions.signup.signup_confirmation_target"))
class RenderPermission(ContentPermission):
"""Permission to obtain images representing instances of a content type."""
instantiable = True
factories = schema.Collection(
items = schema.Reference(type = ImageFactory),
related_end = schema.Collection(),
edit_control = "cocktail.html.CheckList",
searchable = False
)
def match(self, target, image_factory, verbose = False):
if self.factories and image_factory not in self.factories:
print permission_doesnt_match_style("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 _load(self):
from woost.extensions.twitterpublication import (
strings,
tweetuseraction,
twitterauthuseraction,
tweetpermission
)
from woost.extensions.twitterpublication.twitterpublicationtarget \
import TwitterPublicationTarget
TwitterPublicationExtension.add_member(
schema.Collection("targets",
items = schema.Reference(type = TwitterPublicationTarget),
integral = True,
bidirectional = True,
related_end = schema.Collection()
)
)
from woost.controllers.backoffice.backofficecontroller \
import BackOfficeController
from woost.extensions.twitterpublication.tweetcontroller \
import TweetController
BackOfficeController.tweet = TweetController
self.install()
def __call__(self, **parameters):
# Get references to the gateway and payment
gateway = get_parameter(
schema.Reference("gateway_id", type=DummyPaymentGateway))
if gateway is None:
raise ValueError("Wrong payment gateway")
payment_id = get_parameter(schema.String("payment_id"))
payment = payment_id and gateway.get_payment(payment_id) or None
if payment is None:
raise ValueError("Wrong payment id (%s)" % payment_id)
# Notify the payment to the application
cms = self.context["cms"]
notification_uri = Location.get_current_host()
notification_uri.path_info = cms.application_uri(
"payment_notification", payment_id=payment_id)
urlopen(str(notification_uri))
# Redirect the user after the transaction's over
redirection = None
if gateway.payment_status == "accepted":
redirection = gateway.payment_successful_page
elif gateway.payment_status == "failed":
redirection = gateway.payment_failed_page
raise cherrypy.HTTPRedirect((redirection and cms.uri(redirection)
or cms.application_uri()).encode("utf-8"))
class UserCollection(UserRelation):
instantiable = True
groups_order = UserMember.groups_order
member_class = schema.Collection
edit_controls = [
"cocktail.html.TextArea", "cocktail.html.CheckList",
"cocktail.html.MultipleChoiceSelector"
]
search_controls = [
"cocktail.html.DropdownSelector", "cocktail.html.RadioSelector",
"woost.views.ItemSelector", "cocktail.html.CheckList",
"cocktail.html.MultipleChoiceSelector"
]
member_items = schema.Reference(type=UserMember,
required=True,
bidirectional=True,
related_key="parent_collection",
integral=True,
member_group="constraints")
member_min = schema.Integer(listed_by_default=False,
member_group="constraints")
member_max = schema.Integer(min=member_min,
listed_by_default=False,
member_group="constraints")
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 ExportationPermission(Permission):
"""Permission to execute a site's exportation to a destination."""
instantiable = True
def _destination_edit_control(parent, obj, member):
display = templates.new("cocktail.html.DropdownSelector")
display.empty_label = translations(
"woost.extensions.staticsite any destination"
)
return display
destination = schema.Reference(
type = "woost.extensions.staticsite.staticsitedestination.StaticSiteDestination",
related_key = "destination_permissions",
bidirectional = True,
edit_control = _destination_edit_control
)
del _destination_edit_control
def match(self, destination, verbose = False):
if self.destination and destination is not self.destination:
print permission_doesnt_match_style("destination doesn't match")
return False
return Permission.match(self, verbose)
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 MenuBlock(Block):
instantiable = True
view_class = "woost.views.Menu"
root = schema.Reference(type=Document,
related_end=schema.Collection(),
member_group="content")
root_visible = schema.Boolean(required=True,
default=False,
member_group="content")
max_depth = schema.Integer(member_group="content")
expanded = schema.Boolean(required=True,
default=False,
member_group="content")
def init_view(self, view):
Block.init_view(self, view)
view.root = self.root
view.root_visible = self.root_visible
view.max_depth = self.max_depth
view.expanded = self.expanded
def _load(self):
from woost.extensions.facebookpublication import (
strings, fbpublishuseraction, fbpublishauthuseraction,
facebookpublicationpermission)
from woost.extensions.facebookpublication.facebookpublicationtarget \
import FacebookPublicationTarget
FacebookPublicationExtension.add_member(
schema.Collection(
"targets",
items=schema.Reference(type=FacebookPublicationTarget),
integral=True,
bidirectional=True,
related_end=schema.Collection()))
from woost.controllers.backoffice.backofficecontroller \
import BackOfficeController
from woost.extensions.facebookpublication.facebookpublicationcontroller \
import FacebookPublicationController
BackOfficeController.fbpublish = FacebookPublicationController
from woost.extensions.facebookpublication.facebookalbumscontroller \
import FacebookAlbumsController
BackOfficeController.fbpublish_albums = FacebookAlbumsController
class Permission(Item):
type_group = "access"
instantiable = False
visible_from_root = False
authorized = schema.Boolean(required=True, default=True)
role = schema.Reference(type="woost.models.Role",
bidirectional=True,
min=1)
def match(self, verbose=False):
"""Indicates if the permission matches the given context.
@return: True if the permission matches, False otherwise.
@rtype: bool
"""
return True
def __translate__(self, language, **kwargs):
return translations(self.__class__.full_name + "-instance",
language,
instance=self,
**kwargs) or Item.__translate__(
self, language, **kwargs)
@classmethod
def permission_not_found(cls, user, verbose=False, **context):
if verbose:
print unauthorized_style("unauthorized")
return False
def selection(self):
return get_parameter(schema.Collection("selection",
items=schema.Reference(
type=Publishable,
required=True),
min=1),
errors="raise")
class C(PersistentObject):
full_text_indexed = True
text = schema.String()
parent = schema.Reference(bidirectional=True)
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
def sibling(self):
target_member = self.target_member
if target_member and isinstance(target_member, schema.Collection):
return get_parameter(
schema.Reference(
"sibling",
type=target_member.related_type,
enumeration=self.target_object.get(target_member)))
def model(self):
return schema.Schema("DeletePurchaseForm", members = [
schema.Reference("purchase",
type = ECommercePurchase,
required = True,
enumeration = lambda ctx: Basket.get().purchases
)
])
class CampaignMonitorList(Item):
members_order = [
"title",
"list_id",
"confirmation_page",
"confirmation_success_page",
"unsubscribe_page",
]
title = schema.String(required=True, descriptive=True, spellcheck=True)
list_id = schema.String(required=True, unique=True, text_search=False)
confirmation_page = schema.Reference(type=Page,
related_end=schema.Collection())
confirmation_success_page = schema.Reference(
type=Page, related_end=schema.Collection())
unsubscribe_page = schema.Reference(type=Page,
related_end=schema.Collection())
def update(self):
list = List({"api_key": get_setting("x_campaign3_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="!").merge(
URL(query={"email": "[email]"})))
else:
unsubscribe_page = None
list.update(details.Title,
unsubscribe_page,
details.ConfirmedOptIn,
confirmation_success_page,
unsubscribe_setting=details.UnsubscribeSetting)
class ChangeSet(PersistentObject):
"""A persistent record of a set of L{changes<Change>} performed on one or
more CMS items."""
members_order = "id", "author", "date", "changes"
indexed = True
changes = schema.Mapping(
searchable=False,
get_item_key=lambda change: change.target and change.target.id)
author = schema.Reference(required=True, type="woost.models.User")
date = schema.DateTime(required=True,
default=schema.DynamicDefault(datetime.now))
_thread_data = local()
@classgetter
def current(cls):
return getattr(cls._thread_data, "current", None)
@classgetter
def current_author(cls):
cs = cls.current
return cs and cs.author
def begin(self):
if self.current:
raise TypeError("Can't begin a new changeset, another changeset "
"is already in place")
self._thread_data.current = self
def end(self):
try:
del self._thread_data.current
except AttributeError:
raise TypeError("Can't finalize the current changeset, there's no "
"changeset in place")
def get_searchable_text(self, languages, visited_objects=None):
if visited_objects is None:
visited_objects = set()
elif self in visited_objects:
return
visited_objects.add(self)
# Concatenate the descriptions of change authors and targets
for language in languages:
if self.author:
yield translations(self.author, language)
for change in self.changes.itervalues():
yield translations(change.target, language)
class B(PersistentObject):
full_text_indexed = True
text = schema.String()
parent = schema.Reference(bidirectional=True)
children = schema.Collection(bidirectional=True, text_search=True)
