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)