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"