def initialize(context):
validation.register(validators.ProjectIdValidator('isNonConflictingProjectId'))
validation.register(validators.ProjectContactValidator('isValidContact'))
# Kick content registration and sys.modules mangling
from Products.PloneSoftwareCenter import content
allTypes = listTypes(config.PROJECTNAME)
# Register Archetypes content with the machinery
content_types, constructors, ftis = process_types(
allTypes, config.PROJECTNAME)
center_content_types = []
center_constructors = []
project_content_types = []
project_constructors = []
member_content_types = []
member_constructors = []
for i in range(len(allTypes)):
aType = allTypes[i]
if aType['klass'].meta_type in ('PloneSoftwareCenter',):
center_content_types.append(content_types[i])
center_constructors.append(constructors[i])
elif aType['klass'].meta_type in ('PSCProject',):
project_content_types.append(content_types[i])
project_constructors.append(constructors[i])
else:
member_content_types.append(content_types[i])
member_constructors.append(constructors[i])
# software center itself
ContentInit(
config.PROJECTNAME + ' Center',
content_types = tuple(center_content_types),
permission = psc_permissions.AddSoftwareCenter,
extra_constructors = tuple(center_constructors),
fti = ftis,
).initialize(context)
# projects
ContentInit(
config.PROJECTNAME + ' Project',
content_types = tuple(project_content_types),
permission = psc_permissions.AddProject,
extra_constructors = tuple(project_constructors),
fti = ftis,
).initialize(context)
# regular content
ContentInit(
config.PROJECTNAME + ' Project Content',
content_types = tuple(member_content_types),
permission = permissions.AddPortalContent,
extra_constructors = tuple(member_constructors),
fti = ftis,
).initialize(context)
def registerValidatorLogged(klass, *args, **kwargs):
klassName = str(klass)
for c in ["Products.%s." % PROJECTNAME]:
klassName = klassName.replace(c, "")
try:
validation.register(klass(*args, **kwargs))
log("Worked: validation.register(%s(*%s, **%s))\n" % (klassName, repr(args), repr(kwargs)))
except Exception, e:
log("Failed: validation.register(%s(*%s, **%s)): %s\n" % (klassName, repr(args), repr(kwargs), str(e)))
raise e
def registerValidatorLogged(klass, *args, **kwargs):
klassName = str(klass)
for c in ["Products.%s." % PROJECTNAME]:
klassName = klassName.replace(c, '')
try:
validation.register(klass(*args, **kwargs))
log('Worked: validation.register(%s(*%s, **%s))\n' %
(klassName, repr(args), repr(kwargs)))
except Exception, e:
log('Failed: validation.register(%s(*%s, **%s)): %s\n' %
(klassName, repr(args), repr(kwargs), str(e)))
raise e
def registerValidatorLogged(klass, *args, **kwargs):
klassName = str(klass)
for c in ["Products.%s." % config.PROJECTNAME]:
klassName = klassName.replace(c, '')
try:
validation.register(klass(*args, **kwargs))
log('Done: validation.register(%s(*%s, **%s))'
% (klassName, repr(args), repr(kwargs)))
except Exception, e:
log('Failed: validation.register(%s(*%s, **%s)): %s'
%(klassName, repr(args), repr(kwargs), str(e)))
raise e
def _registerStringValidators():
for kwa in config.stringValidators:
id = kwa['id']
errmsg = kwa.get('errmsg', _('Validation failed: $id',
mapping={'id': id}))
# create a validator to match, register it.
validatorId = 'pfgv_%s' % id
revalid = RegexValidator(validatorId,
kwa.get('regex', '.+'),
ignore=kwa.get('ignore', ''),
)
validation.register(revalid)
def _registerStringValidators():
for kwa in config.stringValidators:
id = kwa['id']
errmsg = kwa.get('errmsg', 'Validation failed: %s' % id)
errid = kwa.get('errid', errmsg)
errmsg = _(errid, errmsg)
# create a validator to match, register it.
validatorId = 'pfgv_%s' % id
revalid = RegexValidator(validatorId,
kwa.get('regex', '.+'),
ignore=kwa.get('ignore', ''),
)
validation.register(revalid)
def _registerStringValidators():
for kwa in config.stringValidators:
id = kwa['id']
errmsg = kwa.get('errmsg', 'Validation failed: %s' % id)
errid = kwa.get('errid', errmsg)
if HAS_PLONE25:
errmsg = _(errid, errmsg)
# create a validator to match, register it.
validatorId = 'pfgv_%s' % id
revalid = RegexValidator(validatorId,
kwa.get('regex', '.+'),
ignore=kwa.get('ignore', ''),
)
validation.register(revalid)
def initialize(context):
"""initialize product (called by zope)"""
for validator in validatorList:
validation.register(validator)
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
cmfutils.ContentInit(
PROJECTNAME + ' Content',
content_types = content_types,
permission = DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors = constructors,
fti = ftis,
).initialize(context)
from senaite.patient import messageFactory as _
from Products.validation import validation
from Products.validation.interfaces.IValidator import IValidator
from zope.interface import implementer
@implementer(IValidator)
class TemporaryIdentifierValidator(object):
"""Verifies the value for a TemporaryIdentifierField is valid
"""
name = "temporary_identifier_validator"
def __call__(self, value, *args, **kwargs):
field = kwargs.get("field", None)
if not field:
return True
identifier = value.get("value", "")
required = getattr(field, "required", False)
if required and not identifier:
field_title = field.widget.label
msg = _("Required field: ${title}", mapping={"title": field_title})
ts = api.get_tool("translation_service")
return to_utf8(ts.translate(msg))
return True
# Register validators
validation.register(TemporaryIdentifierValidator())
from poapi import ClassificationTool, GraphVizTool
ModuleSecurityInfo("zExceptions").declarePublic("NotFound")
allow_module("Products.PloneOntology.utils")
allow_module("re")
import proposal
import ctool
import ontology
import keyword
import archive
import graphviztool
import owl
validation.register(keyword.XMLNCNameValidator('isXMLNCName'))
validation.register(keyword.UniqueNameValidator('isUniqueName'))
tools = (ClassificationTool, GraphVizTool)
def initialize(context):
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
cmfutils.ToolInit(PROJECTNAME, tools=tools,
icon='tool.gif',
).initialize( context )
cmfutils.registerIcon(ontology.Ontology,
'storage.png', globals())
from zope.interface import implements
class OSPathValidator(object):
"""Validates
"""
implements(IValidator)
name = "os_path_exists"
def __call__(self, value, *args, **kwargs):
if not os.path.exists(value):
return _("Path not found")
return True
validation.register(OSPathValidator())
class AnalysisSpecificationsValidator(BaseValidator):
"""Min panic value must be below min value
Max panic value must be above max value
Values must be numbers
"""
implements(IValidator)
name = "bhp_analysisspecs_validator"
def validate_service(self, request, uid):
"""Validates the specs values from request for the service uid. Returns
a non-translated message if the validation failed.
"""
# -*- coding: utf-8 -*-
"""Init and utils."""
from Products.validation import validation
from zope.i18nmessageid import MessageFactory
_ = MessageFactory('collective.clamav')
from collective.clamav.validator import ClamavValidator # noqa
validation.register(ClamavValidator('isVirusFree'))
try:
datetime.strptime(value, '%Y-%m-%d')
except ValueError:
instance = kwargs['instance']
title = kwargs['field'].widget.label
trans = getToolByName(instance, 'translation_service').translate
msg = _(
"Incorrect data format in '${title}', should be YYYY-MM-DD",
mapping={'title': safe_unicode(value)}
)
return to_utf8(trans(msg))
return True
validation.register(Date_Format_Validator())
class UniqueClientPatientIDValidator:
"""
Checks if the client patient ID is unique. It does
so only if the checkbox 'Client Patient ID must be
unique' is selected . This checkbox can be found in
Bika Setup under Id server tab
"""
implements(IValidator)
name = "unique_client_patient_ID_validator"
def __call__(self, value, *args, **kwargs):
# avoid the catalog query if the option is not selected
implements(IValidator)
def __init__(self, name, title='', description=''):
self.name = name
self.title = title or name
self.description = description
def __call__(self, value, *args, **kwargs):
try:
length = len(value) - 1
except TypeError:
return ("Validation failed(%s): cannot calculate length "
"of %s."
"" % (self.name, value))
except AttributeError:
return ("Validation failed(%s): cannot calculate length "
"of %s."
"" % (self.name, value))
if length < 1:
return ("Validation failed(%s): Need at least one entry." %
self.name)
return True
isDataGridFilled = DataGridValidator(
'isDataGridFilled',
title='DataGrid has entries',
description='The DataGridField must have at least one entry.')
validation.register(isDataGridFilled)
from Products.Archetypes.atapi import listTypes, process_types
from Products.CMFCore import permissions as cmf_permissions
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.utils import ContentInit
from Products.validation import validation
from zope.i18nmessageid import MessageFactory
from Products.PloneSoftwareCenter import config
from Products.PloneSoftwareCenter import permissions as psc_permissions
from Products.PloneSoftwareCenter import validators
PSCMessageFactory = MessageFactory('plonesoftwarecenter')
validation.register(validators.ProjectIdValidator('isNonConflictingProjectId'))
validation.register(validators.ProjectContactValidator('isValidContact'))
registerDirectory(config.SKINS_DIR, config.GLOBALS)
def initialize(context):
# Kick content registration and sys.modules mangling
from Products.PloneSoftwareCenter import content
content # pyflakes
allTypes = listTypes(config.PROJECTNAME)
# Register Archetypes content with the machinery
content_types, constructors, ftis = process_types(
allTypes, config.PROJECTNAME)
center_content_types = []
from Products.ATContentTypes.content.folder import ATFolder
from Products.ATContentTypes.content.folder import ATFolderSchema
from Products.Archetypes import atapi
import tempfile
from Products.CMFCore.utils import getToolByName
from random import random
import shutil
from Products.Archetypes import atapi
from config import PROJECTNAME
from Products.TutorWeb.BaseQuestionSelectionParameters import BaseQuestionSelectionParameters
from Products.TutorWeb.BaseQuestionSelectionParameters import BaseQuestionSelectionParametersSchema
from Products.validation.validators.RangeValidator import RangeValidator
from Products.validation import validation
validRange = RangeValidator("validRange", -1.0, 1.000001)
validation.register(validRange)
# class extending BaseQuestionSelectionParameters
# returns by default values contained in a referenced BaseQuestionSelectionParameters object
class QuestionSelectionParameters(BaseQuestionSelectionParameters):
"""Container for parameres used when selection a question in a quiz."""
_at_rename_after_creation = True
schema = BaseQuestionSelectionParametersSchema.copy() + Schema((
FloatField("historical_selection_probability",
required=False,
default='-1.0',
# # -1.0 <= value < 1.000001
validators = ('validRange',),
widget=DecimalWidget(description='Probability of selecting questions in a quiz from previous lectures. Possible values:\n'
def register():
""" Custom AT validators
"""
validation.register(
ManagementPlanCodeValidator('management_plan_code_validator'))
"""Main product initializer
"""
from comuneimola.compensi import config
from Products.Archetypes import atapi
from Products.CMFCore import utils
from zope.i18nmessageid import MessageFactory
compensiMessageFactory = MessageFactory('comuneimola.compensi')
from Products.validation import validation
from validators import FloatValidator
validation.register(FloatValidator('isFloat'))
def initialize(context):
content_types, constructors, ftis = atapi.process_types(
atapi.listTypes(config.PROJECTNAME),
config.PROJECTNAME)
for atype, constructor in zip(content_types, constructors):
utils.ContentInit('%s: %s' % (config.PROJECTNAME, atype.portal_type),
content_types=(atype, ),
permission=config.ADD_PERMISSIONS[atype.portal_type],
extra_constructors=(constructor,),
).initialize(context)
from Products.validation import validation
from Products.Reflecto.validators import isValidFilesystemPath
from Products.CMFCore.utils import ContentInit
from Products.CMFCore.DirectoryView import registerDirectory
from Products.Archetypes.public import process_types, listTypes
from Products.Reflecto.permissions import AddReflectorFolder
from Products.Reflecto.config import PROJECTNAME
registerDirectory("skins", globals())
validation.register(isValidFilesystemPath())
def initialize(context):
import Products.Reflecto.content
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=AddReflectorFolder,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
"""Main product initializer
"""
from zope.i18nmessageid import MessageFactory
from ebc.pauta import config
from Products.Archetypes import atapi
from Products.CMFCore import utils
from Products.CMFCore.permissions import setDefaultRoles
pautaMessageFactory = MessageFactory('ebc.pauta')
from Products.validation import validation
from validator import DuracaoValidator
validation.register(DuracaoValidator('isValidDuracao'))
def initialize(context):
"""Initializer called when used as a Zope 2 product.
This is referenced from configure.zcml. Regstrations as a "Zope 2 product"
is necessary for GenericSetup profiles to work, for example.
Here, we call the Archetypes machinery to register our content types
with Zope and the CMF.
"""
# Retrieve the content types that have been registered with Archetypes
# This happens when the content type is imported and the registerType()
# call in the content type's module is invoked. Actually, this happens
# during ZCML processing, but we do it here again to be explicit. Of
# copyright (c) 2004 ITB, Humboldt-University Berlin # # written by: Raphael Ritz, [email protected] # # # ########################################################################## """package installer""" from Products.CMFCore import utils from Products.CMFCore.DirectoryView import registerDirectory from Products.Archetypes.public import process_types, listTypes from config import * # the custom validator from Products.validation import validation from validator.isPartialUrl import PartialUrlValidator validation.register(PartialUrlValidator('isPartialUrl')) # the demo content types from examples import demo, formattablename # backwards compatibility import sys import ateapi sys.modules['Products.ATExtensions.at_extensions'] = ateapi registerDirectory(SKINS_DIR, GLOBALS) def initialize(context): content_types, constructors, ftis = process_types( listTypes(PROJECTNAME), PROJECTNAME)
else:
value = [value, '%s/' % value]
cat = getToolByName(kwargs['instance'], 'portal_catalog')
brains = cat.searchResults({'portal_type': 'Organisation',
'getUrl': value})
if brains:
for brain in brains:
org_ob = brain.getObject()
if kwargs['instance'].UID() != org_ob.UID():
return ("Validation failed, there is already an "
"organisation poiting to this URL.")
return 1
validation.register(
UniqueOrganisationUrlValidator('unique_organisation_url_validator'))
# Base schema for datasets and figures
dataservice_base_schema = Schema((
LinesField(
name='geographicCoverage',
languageIndependent=True,
required=True,
multiValued=1,
default=[],
vocabulary=NamedVocabulary(COUNTRIES_DICTIONARY_ID),
widget=MultiSelectionWidget(
macro="countries_widget",
helper_js=("countries_widget.js",),
helper_css=("countries_widget.css",),
size=15,
def js_recurrenceinput_params(self):
return json.dumps(self.get_recurrenceinput_params())
InitializeClass(RecurrenceWidget)
registerWidget(RecurrenceWidget,
title='Recurring Date',
description=('Renders a recurrence widget to enter all the '
'info for recurring dates.'),
used_for=('plone.app.event.recurrence.RecurrenceField',))
class RecurrenceValidator(object):
# TODO: tests
implements(IValidator)
def __init__(self, name):
self.name = name
def __call__(self, value, *args, **kwargs):
try:
rrule.rrulestr(value) # TODO: rm dep. on rrule. check with regex
assert('FREQ' in value) # TODO: check if freq before other
# recurrence parms
except (ValueError, TypeError, AssertionError):
return "Validation failed: Please enter valid recurrence data."
return True
validation.register(RecurrenceValidator('isRecurrence'))
# This statement makes Blog, BlogEntry and BlogFolder available to import via:
# from Products.SimpleBlog.content import Blog, BlogFolder, BlogEntry
# Without it, you would have to use:
# from Products.SimpleBlog.content.Blog import Blog
# from Products.SimpleBlog.content.BlogFolder import BlogFolder
# from Products.SimpleBlog.content.BlogEntry import BlogEntry
from blog import Blog
from blogfolder import BlogFolder
from blogentry import BlogEntry
from Products.validation import validation
from validator import AnonValidator
validation.register(AnonValidator('validatethis'))
# check we have 3 digits separated by dots
errmsg = "Validation failed, management plan code is not in " \
"the format #.#.# e.g. 1.5.2"
digits = value[1].split('.')
if len(digits) == 3:
for dig in digits:
try:
int(dig)
except ValueError:
return errmsg
return 1
else:
return errmsg
validation.register(
ManagementPlanCodeValidator('management_plan_code_validator'))
class ImageMinSize(object):
""" Image minimum size validator
"""
implements(IValidator)
def __init__(self, name, title='ImageSizeValidator',
description='Image size validator'):
self.name = name
self.title = title or name
self.description = description
def __call__(self, value, instance, *args, **kwargs):
""" check to see if the image is at least 1024px """
def initialize(context):
# imports packages and types for registration
from Products.validation import validation
validation.register(validators.ReferenceValidator('ReferenceValidator'))
validation.register(
validators.isValidYearValidator('isValidYearValidator'))
validation.register(
validators.isDifficultToWalkValidator('isDifficultToWalkValidator'))
validation.register(
validators.orientationSession2hoursValidator(
'orientationSession2hoursValidator'))
validation.register(
validators.orientationSession2DateValidator(
'orientationSession2DateValidator'))
validation.register(
validators.orientationConflictDateValidator(
'orientationConflictDateValidator'))
validation.register(
validators.financialAidValidator('financialAidValidator'))
import content
# initialize portal content
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=DEFAULT_ADD_CONTENT_PERMISSION,
extra_constructors=constructors,
fti=ftis,
).initialize(context)
# apply customization-policy, if theres any
if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
CustomizationPolicy.register(context)
print 'Customization policy for UWOshOIE installed'
from zope.interface import implements
from Products.validation.interfaces.IValidator import IValidator
from Products.validation import validation
from zope.component import getMultiAdapter
class CaptchaValidator:
""" Archetypes field validator for use with collective.captcha or collective.recaptcha
"""
implements(IValidator)
name = 'CaptchaValidator'
def __init__(self, name, title='', description=''):
self.name = name
self.title = title or name
self.description = description
def __call__(self, value, *args, **kwargs):
context = kwargs.get('instance')
request = kwargs.get('REQUEST')
captcha = getMultiAdapter((context, request), name='captcha')
if not captcha.verify(value):
return ("Verification failed: Please type the characters you see below.")
return 1
validation.register(CaptchaValidator('isCorrectCaptcha'))
from bika.lims.utils import to_utf8
from Products.CMFCore.utils import getToolByName
from zope.interface import implements
from Products.validation import validation
from Products.validation.interfaces.IValidator import IValidator
from datetime import datetime
class Date_Format_Validator:
""" Verifies whether the format is the correct or not """
implements(IValidator)
name = "isDateFormat"
def __call__(self, value, *args, **kwargs):
instance = kwargs['instance']
try:
datetime.strptime(value, '%Y-%m-%d')
except ValueError:
instance = kwargs['instance']
title = kwargs['field'].widget.label
trans = getToolByName(instance, 'translation_service').translate
msg = _(
"Incorrect data format in '${title}', should be YYYY-MM-DD",
mapping={'title': safe_unicode(value)})
return to_utf8(trans(msg))
return True
validation.register(Date_Format_Validator())
from Products.Archetypes.public import StringWidget
from Products.Archetypes.Registry import registerWidget
class ColorWidget(StringWidget):
_properties = StringWidget._properties.copy()
_properties.update({
'macro' : "colorchooser",
})
registerWidget(ColorWidget,
title='Color',
description='Like StringWidget, stores the hex value of a color.',
used_for=('Products.Archetypes.Field.StringField',)
)
from Products.validation import validation
from Products.validation.validators import RegexValidator
validation.register(RegexValidator('isHexColor', r'^[0-9a-fA-F]{6}$', title='', description='',
errmsg='is not a hexadecimal color code.'))
return True
try:
datetime.strptime(value, '%Y-%m-%d')
except ValueError:
instance = kwargs['instance']
title = kwargs['field'].widget.label
trans = getToolByName(instance, 'translation_service').translate
msg = _(
"Incorrect data format in '${title}', should be YYYY-MM-DD",
mapping={'title': safe_unicode(value)})
return to_utf8(trans(msg))
return True
validation.register(Date_Format_Validator())
class UniqueClientPatientIDValidator:
"""
Checks if the client patient ID is unique. It does
so only if the checkbox 'Client Patient ID must be
unique' is selected . This checkbox can be found in
Bika Setup under Id server tab
"""
implements(IValidator)
name = "unique_client_patient_ID_validator"
def __call__(self, value, *args, **kwargs):
# avoid the catalog query if the option is not selected
from Products.validation import validation
from Products.CMFCore import utils, DirectoryView
from Products.DimensionWidget.config import *
from validator import PositiveDimensionValidator
validation.register(PositiveDimensionValidator('isPositiveDimension', title='', description=''))
DirectoryView.registerDirectory('skins', product_globals)
from eea.indicators.content.ExternalDataSpec import ExternalDataSpec
from eea.indicators.content.MethodologyReference import MethodologyReference
from eea.indicators.content.Specification import Specification
from eea.indicators.content.Assessment import Assessment
from eea.indicators.content.RationaleReference import RationaleReference
from eea.indicators.content.AssessmentPart import AssessmentPart
from eea.indicators.content.WorkItem import WorkItem
from eea.indicators.content.FactSheetDocument import FactSheetDocument
from eea.indicators.content.IndicatorFactSheet import IndicatorFactSheet
from eea.indicators.content.KeyMessage import KeyMessage
from eea.indicators.content.PolicyDocumentReference import (
PolicyDocumentReference,
)
# Validators
validation.register(
UniquePolicyDocTitleValidator('unique_policy_title_validator'))
validation.register(
UniquePolicyDocUrlValidator('unique_policy_url_validator'))
validation.register(
OneAssessmentPartPerQuestionValidator('one_assessment_per_question'))
validation.register(
FrequencyUpdateValidator('validate_frequency_years'))
validation.register(TimeOfYearValidator('validate_time_of_year'))
validation.register(CodesValidator('validate_codes'))
def register():
""" Register custom content
"""
# Content
registerType(PolicyQuestion, PROJECTNAME)
instance = kwargs['instance']
request = instance.REQUEST
form = request.get('form', {})
fieldname = kwargs['field'].getName()
form_value = form.get(fieldname, False)
if form_value is False:
# not required...
return True
if value == instance.get(fieldname):
# no change.
return True
return True
validation.register(IdentifierTypeAttributesValidator())
class IdentifierValidator:
"""some actual validation should go here.
I'm leaving this stub registered, but adding no extra validation.
"""
implements(IValidator)
name = "identifiervalidator"
def __call__(self, value, *args, **kwargs):
instance = kwargs['instance']
request = instance.REQUEST
form = request.get('form', {})
fieldname = kwargs['field'].getName()
else:
#BBB
__implements__ = (IValidator, )
name = 'LinkSpamValidator'
def __init__(self, name, title='', description=''):
self.name = name
self.title = title or name
self.description = description
def __call__(self, value, *args, **kwargs):
# validation is optional and configured on the field
obj = kwargs.get('field')
if not obj:
return 1
if hasattr(obj,'validate_no_link_spam') and obj.validate_no_link_spam:
bad_signs = ("<a ",
"www.",
"http:",
".com",
)
value = value.lower()
for s in bad_signs:
if s in value:
return ("Validation failed(%(name)s): links are not allowed." %
{ 'name' : self.name, })
return 1
validation.register(LinkSpamValidator('isNotLinkSpam'))
def __init__(self, name, title='', description=''):
self.name = name
self.title = title or name
self.description = description
def __call__(self, value, *args, **kwargs):
# validation is optional and configured on the field
obj = kwargs.get('field')
if not obj:
return 1
if hasattr(obj, 'validate_no_link_spam') and obj.validate_no_link_spam:
bad_signs = (
"<a ",
"www.",
"http:",
".com",
)
value = value.lower()
for s in bad_signs:
if s in value:
return (
"Validation failed(%(name)s): links are not allowed." %
{
'name': self.name,
})
return 1
validation.register(LinkSpamValidator('isNotLinkSpam'))
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.
#
__author__ = """T. Kim Nguyen <*****@*****.**> <unknown>"""
__docformat__ = 'plaintext'
##code-section init-module-header #fill in your manual code here
from Products.validation import validation
from DisallowValueModificationValidator import DisallowValueModificationValidator
from isEmailUWOshValidator import isEmailUWOshValidator
validation.register(
DisallowValueModificationValidator('disallowValueModification'))
validation.register(isEmailUWOshValidator('isEmailUWOsh'))
##/code-section init-module-header
# Subpackages
# Additional
# Classes
import HomecomingSignupSheet
import HomecomingTeam
##code-section init-module-footer #fill in your manual code here
##/code-section init-module-footer
from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
from Products.validation import validation
from Validators import FormattedUSPhoneValidator, USAddressValidator, \
LinesAllFloatValidator, LinesAllIntValidator, SimpleDataGridValidator
validation.register(FormattedUSPhoneValidator('isFormattedUSPhone'))
validation.register(USAddressValidator('isUSAddress'))
validation.register(LinesAllFloatValidator('areLinesFloat'))
validation.register(LinesAllIntValidator('areLinesInt'))
validation.register(SimpleDataGridValidator('isValidGrid'))
from config import ADD_CONTENT_PERMISSION, PROJECTNAME, SKINS_DIR, GLOBALS
registerDirectory(SKINS_DIR, GLOBALS)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
#Import Types here to register them
import Example
content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
permission=ADD_CONTENT_PERMISSION,
except ValueError:
return (
"Validation failed(%(name)s): could not convert '%(value)s' to number"
% {
'name': self.name,
'value': value
})
if minval <= nval <= maxval:
return 1
if minval > nval:
return (
"Validation failed(%(name)s): '%(value)s' is too small. Must be at least %(min)s."
% {
'name': self.name,
'value': value,
'min': minval,
})
else:
return (
"Validation failed(%(name)s): '%(value)s' is too large. Must be no greater than %(max)s."
% {
'name': self.name,
'value': value,
'max': maxval,
})
validation.register(ExRangeValidator('inExNumericRange'))
from zope.i18nmessageid import MessageFactory
PSCMessageFactory = MessageFactory('ploneservicescenter')
from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore import utils as CMFCoreUtils
from Products.CMFCore.DirectoryView import registerDirectory
from Products.PloneServicesCenter.validators import IndustriesValidator
from Products.validation import validation
from config import SKINS_DIR, GLOBALS, PROJECTNAME
from config import ADD_CONTENT_PERMISSION
registerDirectory(SKINS_DIR, GLOBALS)
validation.register(IndustriesValidator('validateIndustries'))
def initialize(context):
# Get all the content types in the content directory
from Products.PloneServicesCenter import content
content # pyflakes
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
CMFCoreUtils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
except:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date."
"" % (self.name, value))
if parts[1] < 1 or parts[1] > 12:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date."
"" % (self.name, value))
if parts[2] < 1 or parts[2] > 31:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date."
"" % (self.name, value))
try:
value = DateTime(parts[0], parts[1], parts[2])
except:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date."
"" % (self.name, value))
return True
try:
value = DateTime(value)
except:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date."
"" % (self.name, value))
return True
validation.register(
IsoDateValidator('isValidIsoDate', title='', description=''))
from Products.validation import validation as validationService
from Products.validation.interfaces.IValidator import IValidator
from zope.interface import implements
class MyValidator:
implements(IValidator)
def __init__(self, name, fun):
self.name = name
self.fun = fun
def __call__(self, value, instance, field, *args, **kwargs):
return self.fun(value)
# never validates
validationService.register(MyValidator('v1', lambda val:val))
# always validates
validationService.register(MyValidator('v2', lambda val:1))
# never validates
validationService.register(MyValidator('v3', lambda val:[]))
settings = [
{'field': {}, # this is the dict of field properties
'value': None,
'assertion': lambda result:result is None, # result of field.validate()
},
{'field': {'required': 1}, # required
'value': None, # ... but no value given
'assertion': lambda result:result is not None},
if len(pmaxs) > 0:
pmaxs = pmaxs[0]
uids = pmins.keys()
for uid in uids:
pmin = pmins.get(uid, '') == '' and '0' or pmins[uid]
pmax = pmaxs.get(uid, '') == '' and '0' or pmaxs[uid]
# Values must be numbers
try:
pmin = float(pmin)
except:
return ts(
_("Validation failed: Panic min value must be "
"numeric"))
try:
pmax = float(pmax)
except:
return ts(
_("Validation failed: Panic min value must be "
"numeric"))
if pmin > pmax:
return ts(
_("Validation failed: Panic max value must be "
"greater than panic min value"))
return True
validation.register(AnalysisSpecificationPanicValidator())
import sys, os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir))
from interfaces.IValidator import IValidator
del sys, os
import re
class TimeEstimateValidator:
__implements__ = IValidator
format = re.compile(r"\s*(\d+d)?\s*(\d+h)?\s*(\d+m)?\s*")
def __init__(self,
name,
title='TimeEstimateValidator',
description='Validates for [%dd] [%dh] [%dm]'):
self.name = name
self.title = title or name
self.description = description
def __call__(self, value, *args, **kwargs):
m = self.format.match(value)
if reduce(lambda x, y: x or y, m.groups()):
return True
else:
return('Format: $Nd $Nh $Nm')
from Products.validation import validation
validation.register(TimeEstimateValidator('timeestimate'))
from Products.TutorWeb.tools import log
# mark start of Product initialization in log file
log('------------------------------------------------------------------\n')
import os, os.path
from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore import utils as cmfutils
from Products.CMFCore.DirectoryView import registerDirectory
from Products.validation.validators.validator import RegexValidator
from Products.validation import validation
from validators import SameDepartmentCodeValidator, SameCourseCodeValidator, SameQuestionIdValidator, SetCorrectAnswerValidator, SameSchoolNameValidator, SameClassNameValidator
validation.register(SameDepartmentCodeValidator("isSameDepartmentCode"))
validation.register(SameCourseCodeValidator("isSameCourseCode"))
validation.register(SameQuestionIdValidator("isSameQuestionId"))
validation.register(SetCorrectAnswerValidator("hasSetCorrectAnswer"))
validation.register(SameSchoolNameValidator("isSameSchoolName"))
validation.register(SameClassNameValidator("isSameClassName"))
# some global constants (in ALL_CAPS) and functions
from Products.TutorWeb.config import *
from Products.TutorWeb.tools import *
from Products.TutorWeb.permissions import *
from Products.TutorWeb.ECQTool import ECQTool
module = ''
# register the validator 'isPositiveInt' in the Zope environment and log whether the registration worked
return ("Validation failed(%s): could not "
"convert %s to a ISO format date.""" % (self.name, value))
if len(parts[2]) > 2:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date.""" % (self.name, value))
try:
parts = [int(x) for x in parts]
except:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date.""" % (self.name, value))
if parts[1] < 1 or parts[1] > 12:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date.""" % (self.name, value))
if parts[2] < 1 or parts[2] > 31:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date.""" % (self.name, value))
try:
value = DateTime(parts[0], parts[1], parts[2])
except:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date.""" % (self.name, value))
return True
try:
value = DateTime(value)
except:
return ("Validation failed(%s): could not "
"convert %s to a ISO format date.""" % (self.name, value))
return True
validation.register(IsoDateValidator('isValidIsoDate', title='', description=''))
# from Products.ATContentTypes.content.base import updateActions, updateAliases
from Products.ATContentTypes.content.schemata import finalizeATCTSchema
from Products.ATContentTypes.content.folder import ATFolderSchema
from Products.ATContentTypes.content.folder import ATFolder
from Products.validation import validation
# local imports
from Products.ECAssignmentBox.config import *
from Products.ECAssignmentBox.ECAssignmentBox import ECAssignmentBox
from Products.ECAssignmentBox.validators import *
isPositive = PositiveNumberValidator("isPositive")
validation.register(isPositive)
ECFolderSchema = Schema(
(
TextField(
"directions",
default_content_type="text/structured",
default_output_type="text/html",
allowable_content_types=TEXT_TYPES,
widget=RichWidget(
label="Directions",
label_msgid="label_directions",
description="Instructions/directions that all assignment boxes in this folder refer to",
description_msgid="help_directions",
i18n_domain=I18N_DOMAIN,
rows=8,
})
InitializeClass(RecurrenceWidget)
registerWidget(RecurrenceWidget,
title='Recurring Date',
description=('Renders a recurrence widget to enter all the '
'info for recurring dates.'),
used_for=('plone.app.event.recurrence.RecurrenceField', ))
class RecurrenceValidator(object):
# TODO: tests
implements(IValidator)
def __init__(self, name):
self.name = name
def __call__(self, value, *args, **kwargs):
try:
rrule.rrulestr(value) # TODO: rm dep. on rrule. check with regex
assert ('FREQ' in value) # TODO: check if freq before other
# recurrence parms
except (ValueError, TypeError, AssertionError):
return "Validation failed: Please enter valid recurrence data."
return True
validation.register(RecurrenceValidator('isRecurrence'))
from zope.interface import implements
class MyValidator:
implements(IValidator)
def __init__(self, name, fun):
self.name = name
self.fun = fun
def __call__(self, value, instance, field, *args, **kwargs):
return self.fun(value)
# never validates
validationService.register(MyValidator('v1', lambda val: val))
# always validates
validationService.register(MyValidator('v2', lambda val: 1))
# never validates
validationService.register(MyValidator('v3', lambda val: []))
settings = [
{
'field': {}, # this is the dict of field properties
'value': None,
'assertion':
lambda result: result is None, # result of field.validate()
},
{
'field': {
'required': 1
>>> validator = PythonValidator()
>>> validator('True')
1
>>> validator("asd : asd")
'invalid syntax (Script (Python), line 1)'
>>> validator("foo ( bar")
'unexpected EOF while parsing (Script (Python), line 1)'
"""
if issubclass(IValidator, Interface):
implements(IValidator)
else:
__implements__ = (IValidator, )
name = 'pythonvalidator'
def __call__(self, value, *args, **kwargs):
if not isinstance(value, PythonScript):
script = PythonScript('no_id')
script.ZPythonScript_edit('**options', value)
value = script
script._compile()
if script.errors:
return '<br/>\n'.join(script.errors)
else:
return 1
validation.register(PythonValidator())
from Products.validation import validation
from Products.CMFCore import utils, DirectoryView
from Products.TimeRangeWidget.config import *
from validator import TimeRangeValidator
validation.register(TimeRangeValidator('isValidTimeRange', title='', description=''))
DirectoryView.registerDirectory('skins', product_globals)
name = "IsCheckedValidator"
def __init__(self, name, title="", description=""):
self.name = name
self.title = title or name
self.description = description
def __call__(self, value, *args, **kwargs):
if (type(value) == BooleanType) and value or (type(value) in StringTypes) and (value == "1"):
return True
return "Validation failed(%s): must be checked." % self.name
validation.register(IsCheckedValidator("isChecked"))
class IsUncheckedValidator:
""" Validates a Boolean field, which should have a "1" (checked)
or "0" unchecked, to be unchecked.
"""
if issubclass(IValidator, Interface):
implements(IValidator)
else:
# BBB
__implements__ = (IValidator,)
name = "IsUncheckedValidator"
from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore import utils
from Products.CMFCore.DirectoryView import registerDirectory
from Products.validation import validation
from Validators import FormattedUSPhoneValidator, USAddressValidator, \
LinesAllFloatValidator, LinesAllIntValidator, SimpleDataGridValidator
validation.register(FormattedUSPhoneValidator('isFormattedUSPhone'))
validation.register(USAddressValidator('isUSAddress'))
validation.register(LinesAllFloatValidator('areLinesFloat'))
validation.register(LinesAllIntValidator('areLinesInt'))
validation.register(SimpleDataGridValidator('isValidGrid'))
from config import ADD_CONTENT_PERMISSION, PROJECTNAME, SKINS_DIR, GLOBALS
registerDirectory(SKINS_DIR, GLOBALS)
def initialize(context):
"""Initializer called when used as a Zope 2 product."""
#Import Types here to register them
import Example
content_types, constructors, ftis = process_types(
listTypes(PROJECTNAME),
PROJECTNAME)
utils.ContentInit(
PROJECTNAME + ' Content',
content_types=content_types,
self.maxlength = maxlength
self.title = title or name
self.description = description
def __call__(self, value, *args, **kwargs):
field = kwargs.get('field', None)
widget = getattr(field, 'widget', None)
# get maxlength
if 'maxlength' in kwargs:
maxlength = kwargs.get('maxlength')
elif safe_hasattr(widget, 'maxlength'):
maxlength = int(widget.maxlength or 0)
else:
# set to given default value (default defaults to 0)
maxlength = self.maxlength
if maxlength == 0:
return 1
nval = len(value.replace('\r\n', '\n'))
if nval <= maxlength:
return 1
else:
return ("Validation failed(%(name)s): '%(value)s' is too long. Must be no longer than %(max)s characters." %
{'name': self.name, 'value': getattr(widget, 'label', 'Entry'), 'max': maxlength})
validation.register(MaxLengthValidator('isNotTooLong'))
from Products.Archetypes import atapi
from Products.CMFCore import utils
from matem.event import config # noqa
from zope.i18nmessageid import MessageFactory # noqa
_ = MessageFactory('matem.event') # noqa
from Products.validation import validation
from matem.event.validators import ExternalSpeakerValidator
from matem.event.validators import InternalSpeakerValidator
# Define a message factory for when this product is internationalised.
# This will be imported with the special name "_" in most modules. Strings
# like _(u"message") will then be extracted by i18n tools for translation.
validation.register(InternalSpeakerValidator('isEmptyInternalSpeakerValidator'))
validation.register(ExternalSpeakerValidator('isEmptyExternalSpeakerValidator'))
def initialize(context):
"""Initializer called when used as a Zope 2 product.
This is referenced from configure.zcml. Regstrations as a "Zope 2 product"
is necessary for GenericSetup profiles to work, for example.
Here, we call the Archetypes machinery to register our content types
with Zope and the CMF.
"""
# Retrieve the content types that have been registered with Archetypes
# This happens when the content type is imported and the registerType()
return True
else:
instance.REQUEST['validated'] = self.name
pmins = instance.REQUEST.get('minpanic', {})[0]
pmaxs = instance.REQUEST.get('maxpanic', {})[0]
uids = pmins.keys()
for uid in uids:
pmin = pmins.get(uid, '') == '' and '0' or pmins[uid]
pmax = pmaxs.get(uid, '') == '' and '0' or pmaxs[uid]
# Values must be numbers
try:
pmin = float(pmin)
except:
return ts(_("Validation failed: Panic min value must be "
"numeric"))
try:
pmax = float(pmax)
except:
return ts(_("Validation failed: Panic min value must be "
"numeric"))
if pmin > pmax:
return ts(_("Validation failed: Panic max value must be "
"greater than panic min value"))
return True
validation.register(AnalysisSpecificationPanicValidator())
implements(ivalidator)
def __init__(self, name):
self.name = name
def __call__(self, value, *args, **kwargs):
filename = getattr(value, "filename")
t = filename.split(".")
ext = t[-1].lower()
if ext != "flv":
return "Validation failed: file is not FLV "
return 1
validation.register(VideoValidator("isVideo"))
FileSchema = file.ATFileSchema.copy()
del (FileSchema["file"])
VideoSchema = FileSchema + Schema(
(
BlobFileField(
"file",
required=True,
primary=True,
searchable=True,
validators=(("isNonEmptyFile", V_REQUIRED), ("checkFileMaxSize", V_REQUIRED), ("isVideo")),
widget=FileWidget(description="", label="File", show_content_type=False),
),
BlobImageField("image", required=True, widget=ImageWidget(label="Clip", description="")),
)
instance = kwargs['instance']
request = instance.REQUEST
form = request.get('form', {})
fieldname = kwargs['field'].getName()
form_value = form.get(fieldname, False)
if form_value is False:
# not required...
return True
if value == instance.get(fieldname):
# no change.
return True
return True
validation.register(IdentifierTypeAttributesValidator())
class IdentifierValidator:
"""some actual validation should go here.
I'm leaving this stub registered, but adding no extra validation.
"""
implements(IValidator)
name = "identifiervalidator"
def __call__(self, value, *args, **kwargs):
instance = kwargs['instance']
request = instance.REQUEST
form = request.get('form', {})
fieldname = kwargs['field'].getName()
"""Main product initializer
"""
from zope.i18nmessageid import MessageFactory
from ebc.pauta import config
from Products.Archetypes import atapi
from Products.CMFCore import utils
from Products.CMFCore.permissions import setDefaultRoles
pautaMessageFactory = MessageFactory('ebc.pauta')
from Products.validation import validation
from validator import DuracaoValidator
validation.register(DuracaoValidator('isValidDuracao'))
def initialize(context):
"""Initializer called when used as a Zope 2 product.
This is referenced from configure.zcml. Regstrations as a "Zope 2 product"
is necessary for GenericSetup profiles to work, for example.
Here, we call the Archetypes machinery to register our content types
with Zope and the CMF.
"""
# Retrieve the content types that have been registered with Archetypes
# This happens when the content type is imported and the registerType()
# call in the content type's module is invoked. Actually, this happens
# during ZCML processing, but we do it here again to be explicit. Of
