def _create_template(self, name):
template = Template()
template.qname = "woost.extensions.ecommerce.%s_template" % name
self.__translate_field(template, "title")
template.engine = "cocktail"
template.identifier = \
"woost.extensions.ecommerce.%sPage" % underscore_to_capital(name)
return template
def _load(self):
from woost.controllers.notifications import notify_user
from woost.controllers.backoffice.basebackofficecontroller import \
BaseBackOfficeController
from woost.controllers.backoffice.itemcontroller import \
ItemController
from woost.extensions.mailer import (
sendemailaction,
createmailingaction,
strings
)
from woost.extensions.mailer.mailing import Mailing, \
RunningMailingError
from woost.extensions.mailer.sendemailcontroller import \
SendEmailController
ItemController.send_email = SendEmailController
Template.add_member(
schema.Boolean(
"per_user_customizable",
default = False,
listed_by_default = False
)
)
Template.members_order.append("per_user_customizable")
User.add_member(
schema.Collection(
"mailingLists",
items = "woost.extensions.mailer.mailinglist.MailingList",
bidirectional = True,
listed_by_default = False
)
)
@when(BaseBackOfficeController.exception_raised)
def handle_exception_raised(event):
if isinstance(
event.exception,
RunningMailingError
):
notify_user(translations(event.exception), "error")
raise cherrypy.HTTPRedirect(event.source.contextual_uri())
# Disable interactive features from rendered pages when rendering
# static content
from woost.controllers.cmscontroller import CMSController
@when(CMSController.producing_output)
def disable_user_controls(event):
if context.get("sending_email", False):
event.output["show_user_controls"] = False
def test_unlink(self):
template = list(Template.select())[0]
publishable = Publishable()
publishable.set("enabled", True, "en")
publishable.template = template
publishable.insert()
datastore.commit()
browser.open("/en/cms/content/%d/fields" % publishable.id)
admin_login()
assert not browser.is_element_present(
"css=.template_field .control .new")
assert not browser.is_element_present(
"css=.template_field .control .delete")
browser.click("css=.template_field .control .unlink")
browser.wait_for_page_to_load(10000)
val = browser.get_value("edited_item_template")
assert not browser.get_value("edited_item_template")
def test_select(self):
template = list(Template.select())[0]
browser.open(
"/en/cms/content/new/?item_type=woost.models.publishable.Publishable"
)
admin_login()
assert not browser.is_element_present(
"css=.template_field .control .new")
assert not browser.is_element_present(
"css=.template_field .control .unlink")
assert not browser.is_element_present(
"css=.template_field .control .delete")
browser.click("css=.template_field .control .select")
browser.wait_for_page_to_load(10000)
assert browser.is_visible("css=.collection_display #%d" % template.id)
browser.click("css=.collection_display #%d" % template.id)
browser.click("css=.ContentView .select_action")
browser.wait_for_page_to_load(10000)
assert translations(template, "en") \
in browser.jquery_html(".template_field .control")
assert browser.get_value("edited_item_template") == str(template.id)
def remove_template_engine(e):
from woost.models import Template
for template in Template.select():
try:
del template._engine
except AttributeError:
pass
def move_blocks_to_core(e):
from cocktail.persistence import datastore
from woost.models import Item, Page, Template, Block, TextBlock
from woost.models.rendering import Renderer
# Rename keys
for key in list(datastore.root):
if key.startswith("woost.extensions.blocks."):
new_key = key.replace(".extensions.blocks.", ".models.")
datastore.root[new_key] = datastore.root.pop(key)
# Consolidate StandardPage and BlocksPage into the new Page model
for block in Block.select():
try:
pages = block._BlocksPage_blocks
except AttributeError:
pass
else:
block._Page_blocks = pages
del block._BlocksPage_blocks
page_ids = datastore.root.pop(
"woost.models.standardpage.StandardPage-keys")
if page_ids:
for id in page_ids:
Page.keys.add(id)
page = Page.get_instance(id)
page._p_changed = True
block = TextBlock()
for lang, trans in page.translations.iteritems():
if hasattr(trans, "_body"):
block.set("text", trans._body, lang)
del trans._body
page.blocks.append(block)
block.insert()
page_ids = datastore.root.pop("woost.models.blockspage.BlocksPage-keys")
if page_ids:
for id in page_ids:
Page.keys.add(id)
# Update references to the old template for block pages
for template in Template.select():
if template.identifier == "woost.extensions.blocks.BlocksPageView":
template.identifier = "woost.views.StandardView"
# Fix the name in the related end for Page.blocks
for block in Block.select():
block.Page_blocks._PersistentRelationCollection__member_name = \
"Page_blocks"
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"))
def test_item_selector(self):
from woost.models import Publishable, Template
template = list(Template.select())[0]
browser.open(
"/en/cms/content/?content_view=flat&type=woost.models.publishable.Publishable&search_expanded=true"
)
admin_login()
browser.fire_event("css=.new_filter_selector", "click")
browser.fire_event("css=.new_filter-member-template", "click")
assert not browser.is_element_present("css=.filters .value_field .new")
assert not browser.is_element_present(
"css=.filters .value_field .edit")
assert not browser.is_element_present(
"css=.filters .value_field .delete")
assert not browser.is_element_present(
"css=.filters .value_field .unlink")
browser.click("css=.filters .value_field .select")
browser.select_frame(
"dom=selenium.browserbot.getCurrentWindow().frames[0]")
browser.wait_for_element_present("css=.collection_display", 10000)
assert not browser.is_element_present("css=.new_action")
browser.click("css=.collection_display #%d" % template.id)
browser.click("css=.select_action")
browser.select_frame("relative=parent")
browser.wait_for_element_present("css=.collection_display", 10000)
assert translations(template, "en") \
in browser.jquery_html(".filters .value_field")
assert browser.get_value("filter_value0") == str(template.id)
browser.click("css=.filters .search_button")
browser.wait_for_page_to_load(10000)
rows_count = browser.jquery_count(".collection_display .item_row")
assert rows_count == len(template.items)
class CampaignMonitorSubscriptionPage(Document):
members_order = "lists", "subscription_form", "body"
default_template = schema.DynamicDefault(
lambda: Template.get_instance(
qname = u"woost.extensions.campaignmonitor.subscription_template"
)
)
default_controller = schema.DynamicDefault(
lambda: Controller.get_instance(
qname = u"woost.extensions.campaignmonitor.subscription_controller"
)
)
body = schema.String(
translated = True,
listed_by_default = False,
edit_control = "woost.views.RichTextEditor",
member_group = "content"
)
lists = schema.Collection(
items = schema.Reference(
type = CampaignMonitorList
),
member_group = "content",
listed_by_default = False
)
subscription_form = schema.String(
member_group = "content",
default = \
"woost.extensions.campaignmonitor.subscriptionform.SubscriptionForm",
text_search = False
)
class UserForm(Document):
groups_order = list(Document.groups_order)
groups_order.insert(groups_order.index("content") + 1, "form")
members_order = [
"form_model", "excluded_members", "should_save_instances",
"redirection", "email_notifications"
]
default_controller = schema.DynamicDefault(lambda: Controller.get_instance(
qname="woost.extensions.usermodels.user_form_controller"))
default_template = schema.DynamicDefault(lambda: Template.get_instance(
qname="woost.extensions.usermodels.user_form_template"))
form_model = schema.Reference(required=True,
class_family="woost.models.Item",
member_group="form")
excluded_members = schema.Collection(items=schema.String(),
edit_control="cocktail.html.TextArea",
member_group="form")
should_save_instances = schema.Boolean(required=True,
default=True,
member_group="form")
redirection = schema.Reference(type=Publishable,
related_end=schema.Collection(),
member_group="form")
email_notifications = schema.Collection(
items=schema.Reference(type=EmailTemplate),
related_end=schema.Collection(),
member_group="form")
class ECommerceProduct(Publishable):
instantiable = False
members_order = [
"description",
"price",
"weight",
"attachments",
"purchase_model",
"purchases",
"template"
]
default_controller = schema.DynamicDefault(
lambda: Controller.get_instance(
qname = "woost.extensions.ecommerce.product_controller"
)
)
description = schema.String(
translated = True,
edit_control = "woost.views.RichTextEditor",
member_group = "product_data"
)
price = schema.Decimal(
required = True,
default = Decimal("0"),
member_group = "product_data"
)
weight = schema.Decimal(
translate_value = lambda value, language = None, **kwargs:
"" if not value else "%s Kg" % translations(value, language),
member_group = "product_data"
)
attachments = schema.Collection(
items = schema.Reference(type = File),
related_end = schema.Collection(),
member_group = "product_data"
)
purchase_model = schema.Reference(
class_family = "woost.extensions.ecommerce.ecommercepurchase."
"ECommercePurchase",
default = schema.DynamicDefault(
lambda: ECommerceProduct.purchase_model.class_family
),
required = True,
searchable = False,
member_group = "product_data"
)
purchases = schema.Collection(
items = "woost.extensions.ecommerce.ecommercepurchase."
"ECommercePurchase",
bidirectional = True,
visible = False,
member_group = "product_data"
)
template = schema.Reference(
type = Template,
related_end = schema.Collection(),
default = schema.DynamicDefault(
lambda: Template.get_instance(
qname = "woost.extensions.ecommerce.product_template"
)
),
member_group = "presentation"
)
def get_image(self):
for attachment in self.attachments:
if attachment.resource_type == "image" \
and attachment.is_accessible():
return attachment
def offers(self):
from woost.extensions.ecommerce import ECommerceExtension
for pricing in ECommerceExtension.instance.pricing:
if not pricing.hidden and pricing.applies_to(self):
yield pricing
@getter
def inherited_resources(self):
if self.inherit_resources and self.parent is None:
catalog = Document.get_instance(
qname = "woost.extensions.ecommerce.catalog_page"
)
if catalog:
for resource in catalog.inherited_resources:
yield resource
for resource in catalog.branch_resources:
yield resource
else:
for resource in Publishable.inherited_resources.__get__(self):
yield resource
def _install(self):
from woost.extensions.campaignmonitor.campaignmonitorsubscriptionpage \
import CampaignMonitorSubscriptionPage
# Subscription controller
campaign_monitor_controller = self._create_asset(
Controller,
"subscription_controller",
python_name=
"woost.extensions.campaignmonitor.campaignmonitorcontroller."
"CampaignMonitorController",
title=extension_translations)
# Unsubscription controller
unsubscription_controller = self._create_asset(
Controller,
"unsubscription_controller",
python_name="woost.extensions.campaignmonitor."
"campaignmonitorunsubscriptioncontroller."
"CampaignMonitorUnsubscriptionController",
title=extension_translations)
# Subscription template
subscription_view = self._create_asset(
Template,
"subscription_template",
identifier="woost.extensions.campaignmonitor."
"CampaignMonitorSubscriptionView",
engine="cocktail",
title=extension_translations)
# Unsubscription template
unsubscription_view = self._create_asset(
Template,
"unsubscription_template",
identifier="woost.extensions.campaignmonitor."
"CampaignMonitorUnsubscriptionView",
engine="cocktail",
title=extension_translations)
# Default subscription page
subscription_page = self._create_asset(CampaignMonitorSubscriptionPage,
"subscription_page",
title=extension_translations,
hidden=True)
# Standard Template
standard_template = Template.get_instance(
qname="woost.standard_template")
# Default pending page
pending_page = self._create_asset(StandardPage,
"pending_page",
title=extension_translations,
body=extension_translations,
template=standard_template,
hidden=True)
# Default confirmation success page
confirmation_success_page = self._create_asset(
StandardPage,
"confirmation_success_page",
title=extension_translations,
body=extension_translations,
template=standard_template,
hidden=True)
# Default unsubscribe page
unsubscribe_page = self._create_asset(
StandardPage,
"unsubscribe_page",
title=extension_translations,
body=extension_translations,
controller=unsubscription_controller,
template=unsubscription_view,
hidden=True)