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