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 ) ) ])
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
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
def get_public_schema(cls): public_schema = schema.Schema("OrderCheckoutSummary") cls.get_public_adapter().export_schema(cls, public_schema) payment_type = public_schema.get_member("payment_type") if payment_type: payments = PaymentsExtension.instance if payments.enabled and payments.payment_gateway: translate_value = payment_type.translate_value def payment_type_translate_value(value, language=None, **kwargs): if value == "payment_gateway": return payments.payment_gateway.label else: return translate_value(value, language=language, **kwargs) payment_type.translate_value = payment_type_translate_value return public_schema
def model(self): return schema.Schema("DeletePurchaseForm", members = [ schema.Reference("purchase", type = ECommercePurchase, required = True, enumeration = lambda ctx: Basket.get().purchases ) ])
def model(self): source_instance = self.source_instance if source_instance is not None \ and isinstance(source_instance, schema.SchemaObject): return source_instance.__class__ return schema.Schema(get_full_name(self.__class__))
def form_model(self): identifier = self.context["cms"].authentication.identifier_field.copy() identifier.name = "user" form_model = schema.Schema("woost.controllers.logincontroller.form", members=[identifier, User.password.copy()]) return form_model
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 ) ])
def form_schema(self): form_schema = schema.Schema("UploadFilesForm") upload = FileUpload("upload", required=True) upload["mime_type"].enumeration = [ "application/zip", "application/x-zip-compressed" ] form_schema.add_member(upload) return form_schema
def schema(self): """A schema describing the fields and validation logic that make up the form. """ if self.model is None: raise ValueError("No form model specified for %s" % self) adapted_schema = schema.Schema( name=self.get_schema_name(), schema_aliases=self.get_schema_aliases()) adapted_schema.is_form = True return self.adapter.export_schema(self.model, adapted_schema)
def content_schema(self): content_schema = schema.Schema("Changelog") content_schema = self.content_adapter.export_schema( ChangeSet, content_schema ) content_schema.add_member( schema.Member("action"), before = "changes" ) changes = content_schema["changes"] changes.listed_by_default = True changes.searchable = True return content_schema
def schema(self): user_id_member = self.identifier_member.copy() user_id_member.name = "user" @user_id_member.add_validation def validate_user_identifier_exists(member, value, context): if value and self.user is None: yield UserIdentifierNotRegisteredError( member, value, context) @user_id_member.add_validation def validate_user_has_email(member, value, context): if self.user is not None and not self.user.email: yield UserEmailMissingError(member, value, context) return schema.Schema("PasswordChangeRequestForm", members=[user_id_member])
class InputErrorResponse(ErrorResponse): """Response type for schema coercion errors.""" status = 400 error_schema = schema.Schema( members={ "errors": schema.Collection(items=schema.Record( record_schema=ValidationErrorResponse.error_schema)) }) def get_data(self, error: Exception) -> json_object: data = super().get_data(error) val_error_resp = error_responses[schema.exceptions.ValidationError] data["errors"] = [ val_error_resp.get_data(val_error) for val_error in error.errors ] return data
def schema(self): return schema.Schema( "ShopOrderCostFilter", members=[ schema.String( "operator", required=True, default="eq", enumeration=self.operators, text_search=False, translate_value=lambda value, language=None, **kwargs: "" if not value else translations( "cocktail.html.UserFilterEntry operator " + value, language, **kwargs)), schema.Boolean("include_shipping", default=False), schema.Boolean("include_taxes", default=False), schema.Boolean("include_discounts", default=False), schema.Decimal("value", required=True) ])
def model(self): model = schema.Schema("SetQuantitiesForm", members = [ schema.Collection("quantity", items = schema.Integer(min = 1), length = len(Basket.get().purchases) ) ]) @extend(model["quantity"].items) def translate_error(member, error, language = None, **kwargs): if isinstance(error, schema.exceptions.MinValueError): return translations( "SetQuantitiesForm-MinValueError", language, **kwargs ) else: return call_base(error, language, **kwargs) return model
def form_schema(self): return schema.Schema( "FacebookAlbumsForm", members=[ schema.String("album_title", required=True), schema.String("album_description", edit_control="cocktail.html.TextArea"), schema.Collection( "subset", items=schema.Reference( type=File, relation_constraints=[ File.resource_type.equal("image") ], required=True, enumeration=lambda ctx: self.selection), min=1, default=schema.DynamicDefault(lambda: self.selection)), schema.Collection( "photo_languages", min=1, items=schema.String(required=True, enumeration=lambda ctx: Configuration. instance.languages, translate_value=lambda value, language= None, **kwargs: "" if not value else translations( value, language, **kwargs)), default=schema.DynamicDefault( lambda: Configuration.instance.languages)), schema.Boolean("generate_story", required=True, default=True), 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 _adapt_comments_schema(self, comment_model): adapter = self._create_comments_adapter(comment_model) comments_schema = schema.Schema(comment_model.name + "Form") adapter.export_schema(comment_model, comments_schema) return comments_schema
from datetime import timedelta from BTrees.OOBTree import OOBTree from cocktail import schema from cocktail.javascriptserializer import JS from cocktail.events import event_handler from cocktail.persistence import PersistentMapping from woost import app from woost.models import Item, User, Publishable, LocaleMember export_task_schema = schema.Schema( "woost.extensions.staticpub.export.export_task_schema", members=[ schema.Reference("item", type=Publishable, required=True), LocaleMember("language"), schema.String("action", required=True, enumeration=["post", "delete"]), schema.String("state", required=True, enumeration=["pending", "failed", "success"]), schema.String("error_message") ]) class Export(Item): type_group = "staticpub" instantiable = False members_order = ["user", "destination", "state", "tasks"] user = schema.Reference(editable=schema.READ_ONLY,
def index(self, **params): set_language("en") submitted = cherrypy.request.method == "POST" successful = False errors = [] HOST_FORMAT = \ re.compile(r"^([a-z]+(\.[a-z]+)*)|(\d{1,3}(\.\d{1,3}){3})$") paths = sorted([p for p in sys.path if os.access(p, os.W_OK)]) form_schema = schema.Schema( name = "Installer", members = [ schema.String( name = "project_name", required = True, format = r"^[A-Z][A-Za-z_0-9]*$", member_group = "project" ), schema.String( name = "python_package_repository", required = True, enumeration = paths, translatable_enumeration = False, default = paths and paths[0] or None, member_group = "project" ), schema.String( name = "installation_id", required = True, member_group = "project", default = "DEV" ), schema.String( name = "admin_email", required = True, default = "admin@localhost", member_group = "project" ), schema.String( name = "admin_password", required = True, min = 8, edit_control = "cocktail.html.PasswordBox", member_group = "project" ), schema.String( name = "languages", required = True, default = "en", format = r"^[a-zA-Z]{2}(\W+[a-zA-Z]{2})*$", member_group = "project" ), schema.String( name = "webserver_host", required = True, format = HOST_FORMAT, default = "127.0.0.1", member_group = "webserver" ), schema.Integer( name = "webserver_port", required = True, default = 8080, member_group = "webserver" ), schema.Boolean( name = "validate_webserver_address", default = True, member_group = "webserver" ), schema.String( name = "database_host", required = True, format = HOST_FORMAT, default = "127.0.0.1", member_group = "database" ), schema.Integer( name = "database_port", required = True, default = 8081, member_group = "database" ), schema.Boolean( name = "validate_database_address", default = True, member_group = "database" ), schema.Integer( name = "base_id", member_group = "database" ) ] ) def make_address_validation(host_field, port_field, check_field): def validate_address(schema, validable, context): if validable[check_field]: host = validable[host_field] port = validable[port_field] host_member = schema[host_field] port_member = schema[port_field] if host_member.validate(host) \ and port_member.validate(port) \ and not self._is_valid_local_address(host, port): yield WrongAddressError( schema, validable, context, host_member, port_member ) return validate_address form_schema.add_validation(make_address_validation( "webserver_host", "webserver_port", "validate_webserver_address" )) form_schema.add_validation(make_address_validation( "database_host", "database_port", "validate_database_address" )) form_data = {} if submitted: get_parameter( form_schema, target = form_data, errors = "ignore", undefined = "set_none" ) errors = list(form_schema.get_errors(form_data)) if not errors: form_data["project_path"] = os.path.join( form_data["python_package_repository"], form_data["project_name"].lower() ) try: if os.path.exists(form_data["project_path"]): raise InstallFolderExists() self.install(form_data) except Exception, ex: errors.append(ex) if not isinstance(ex, InstallFolderExists): traceback.print_tb(sys.exc_info()[2]) try: rmtree(form_data["project_path"]) except Exception, rmex: tb = sys.exc_info()[2] traceback.print_tb(sys.exc_info()[2]) errors.append(rmex) else: successful = True
#-*- coding: utf-8 -*- u""" @author: Jordi Fernández @contact: [email protected] @organization: Whads/Accent SL @since: March 2010 """ from cocktail import schema SubscriptionForm = schema.Schema( "SubscriptionForm", members=[ schema.String("email", required=True, format=r"([\w\-\.]+@(\w[\w\-]+\.)+[\w\-]+)"), schema.String("name") ]) SubscriptionForm.members_order = "name", "email"