def validate_name(self, field): if not valid_username(field.data): raise wtforms.ValidationError("Name contains invalid characters.") existing = ResourceAction.query.filter_by(name=field.data, resource=self.edit_resource).first() if existing and existing.id != self.edit_id: raise wtforms.ValidationError("An action with that name already exists for this resource")
def validate_keys(form, field): if not field.data: return expected_keys_count = INCUBATION_PERIOD + SYMPTOMS_TO_VIRUS_NEGATIVE key_values = set(key['value'] for key in field.data) # All keys should be unique, and should match the expected count if len(key_values) != expected_keys_count: raise wtforms.ValidationError( 'Should contain {} daily keys.'.format(expected_keys_count) ) key_dates = sorted(key['date'] for key in field.data) # There should not be any missing date prev_date = None for date in key_dates: if prev_date is not None and date != prev_date + datetime.timedelta(days=1): raise wtforms.ValidationError('Key dates should not contain gaps.') prev_date = date if key_dates[0] > datetime.datetime.utcnow().date(): raise wtforms.ValidationError('Key dates can not all be in the future.')
def pre_validate(self, form): if not self._deb_file_input or not isinstance(self._deb_file_input, FileStorage): return # Save the deb file to a tmp file _, debtmp = mkstemp() with open(debtmp, "wb") as tmp: tmp.write(self._deb_file_input.read()) # Open the deb file and parse control information deb_obj = debfile.DebPackage(debtmp) tags = TagSection(deb_obj.control_content("control")) pkg_name = tags.get('Package', None) if pkg_name is None: # Remove the tmpfile os.unlink(debtmp) raise wtf.ValidationError("Invalid deb control file, " "package name is empty.") # Check 'unique' property on pkg_name with db_scoped_session() as se: obj_t = se.query(Item).filter_by(pkg_name=pkg_name).first() if obj_t != None and hasattr(form, 'iid') and obj_t.iid != form.iid.data: # obj exists, raise error raise wtf.ValidationError("The same package name found in " "%s" % obj_t) # Validation successful, fill the tmpfile path self._deb_tmpfile = debtmp self.data = debtmp
def validate_phone(self, field): existing = UserPhone.query.filter_by(phone=field.data).first() if existing is not None: if existing.user == g.user: raise wtforms.ValidationError( "You have already registered this phone number.") else: raise wtforms.ValidationError( "That phone number has already been claimed.") existing = UserPhoneClaim.query.filter_by(phone=field.data, user=g.user).first() if existing is not None: raise wtforms.ValidationError( "That phone number is pending verification.") # Step 1: Remove punctuation in number field.data = strip_phone(field.data) # Step 2: Validate number format if not valid_phone(field.data): raise wtforms.ValidationError( "Invalid phone number (must be in international format with a leading + symbol)" ) # Step 3: Check if Indian number (startswith('+91')) if not field.data.startswith('+91') or len(field.data) != 13: raise wtforms.ValidationError( "Only Indian mobile numbers are allowed at this time")
def validate_token_scope(self, field): scope = field.data try: _, scope_kind = scope.split(":", 1) except ValueError: raise wtforms.ValidationError(f"Unknown token scope: {scope}") if scope_kind == "unspecified": raise wtforms.ValidationError("Specify the token scope") if scope_kind == "user": self.validated_scope = scope_kind return try: scope_kind, scope_value = scope_kind.split(":", 1) except ValueError: raise wtforms.ValidationError(f"Unknown token scope: {scope}") if scope_kind != "project": raise wtforms.ValidationError(f"Unknown token scope: {scope}") if scope_value not in self.project_names: raise wtforms.ValidationError( f"Unknown or invalid project name: {scope_value}") self.validated_scope = {"projects": [scope_value]}
def validate_field(self, field): if not field.data: raise wtforms.ValidationError("field is empty") supported = ["cwshdr"] if field.data.lower() not in supported: template = "{} is not supported. Currently supported: {}" raise wtforms.ValidationError(template.format(field.data, supported))
def file_virus_validator(form, field): """ Checks for virus in the file from flask request object, raises wtf.ValidationError if virus is found else None. """ if not pagure_config["VIRUS_SCAN_ATTACHMENTS"]: return from pyclamd import ClamdUnixSocket if (field.name not in flask.request.files or flask.request.files[field.name].filename == ""): # If no file was uploaded, this field is correct return uploaded = flask.request.files[field.name] clam = ClamdUnixSocket() if not clam.ping(): raise wtforms.ValidationError( "Unable to communicate with virus scanner") results = clam.scan_stream(uploaded.stream.read()) if results is None: uploaded.stream.seek(0) return else: result = results.values() res_type, res_msg = result if res_type == "FOUND": raise wtforms.ValidationError("Virus found: %s" % res_msg) else: raise wtforms.ValidationError("Error scanning uploaded file")
def file_virus_validator(form, field): if not pagure.APP.config['VIRUS_SCAN_ATTACHMENTS']: return from pyclamd import ClamdUnixSocket if field.name not in flask.request.files or \ flask.request.files[field.name].filename == '': # If no file was uploaded, this field is correct return uploaded = flask.request.files[field.name] clam = ClamdUnixSocket() if not clam.ping(): raise wtforms.ValidationError( 'Unable to communicate with virus scanner') results = clam.scan_stream(uploaded.stream.read()) if results is None: uploaded.stream.seek(0) return else: result = results.values() res_type, res_msg = result if res_type == 'FOUND': raise wtforms.ValidationError('Virus found: %s' % res_msg) else: raise wtforms.ValidationError('Error scanning uploaded file')
def validate_username(self, field): if field.data in current_app.config['RESERVED_USERNAMES']: raise wtforms.ValidationError, "This name is reserved" if not valid_username(field.data): raise wtforms.ValidationError(u"Invalid characters in name. Names must be made of ‘a-z’, ‘0-9’ and ‘-’, without trailing dashes") existing = User.get(username=field.data) if existing is not None: raise wtforms.ValidationError("This username is taken")
def validate_name(self, field): if not valid_username(field.data): raise wtforms.ValidationError("Name contains invalid characters.") existing = self.edit_resource.get_action(field.data) if existing and existing.id != self.edit_id: raise wtforms.ValidationError( "An action with that name already exists for this resource")
def validate_id(self, field): # Check if user is authorized to edit this expense. if field.data: expense = Expense.query.get(field.data) if not expense: raise wtforms.ValidationError("Unknown expense") if expense.report.user != g.user: raise wtforms.ValidationError("You are not authorized to edit this expense")
def validate_delete_username(self, field): user = User.query.filter_by(username=self.delete_username.data).first() if user is None: raise wtforms.ValidationError("User not found") if user == current_user: raise wtforms.ValidationError("That's you") if user not in current_user.friends: raise wtforms.ValidationError("User is not a friend")
def Blog_length_limit(form, field): soup = BeautifulSoup(field.data, 'html.parser') [s.extract() for s in soup('script')] length = len(soup.get_text().strip()) if length < 10: raise wtforms.ValidationError(u'文章太短了,多敲几个字吧') if length > 20000: raise wtforms.ValidationError(u'文章长度超限,不能大于20000')
def validate_username(self, field): if Admin.query.filter_by(username=field.data).first(): password = setPassword(self.password.data) if password != Admin.query.filter_by( username=field.data).first().password: raise wtforms.ValidationError("您输入的用户名或密码错误!") else: raise wtforms.ValidationError("您输入的用户名或密码错误!")
def check_valid_timeline(form, field): publish_date = form.publish_date.data retract_date = form.retract_date.data if not publish_date: raise wtforms.ValidationError( _(u'Cannot retract an un-published form')) if retract_date < publish_date: raise wtforms.ValidationError(_('Must be after publish date'))
def validate_alias(form, field): if form.alias.data == 'new': raise wtforms.ValidationError(flask.Markup( 'The alias cannot be <code>new</code>.')) check = Election.search(SESSION, alias=form.alias.data) if check: if not (form._election_id and form._election_id == check[0].id): raise wtforms.ValidationError( 'There is already another election with this alias.')
def validate_endpoint(self, field): data = field.data.strip() if not Infura.is_valid_project_id_or_endpoint(data): raise wtforms.ValidationError( "Not a valid Infura URL nor Infura Project ID") if not (Infura.is_valid_project_id(data) or search(self.meta.network, data)): raise wtforms.ValidationError( f"Infura URL for wrong network, expected {self.meta.network}")
def validate_url(self, field): long_url = field.data if not is_url(long_url): raise wtforms.ValidationError('URL is invalid') short_id = g.tinyurl.get_short_id(long_url=long_url) if short_id is not None: short_url = common.get_short_url_from_short_id(short_id=short_id) raise wtforms.ValidationError( 'URL is already a TinyURL ({short_url}).'.format( short_url=short_url))
def validate_name(self, field): if not valid_username(field.data): raise wtforms.ValidationError("Name contains invalid characters.") if field.data in resource_registry: raise wtforms.ValidationError("This name is reserved for internal use") existing = Resource.query.filter_by(name=field.data).first() if existing and existing.id != self.edit_id: raise wtforms.ValidationError("A resource with that name already exists")
def __call__(self, form, field): email_domain = get_email_domain(field.data) try: dns.resolver.query(email_domain, 'MX') except dns.resolver.NXDOMAIN: raise wtforms.ValidationError(self.message or self.message_domain) except dns.resolver.NoAnswer: raise wtforms.ValidationError(self.message or self.message_email) except (dns.resolver.Timeout, dns.resolver.NoNameservers): pass
def validate_username(self, field): allowed_characters = string.ascii_lowercase + string.digits + "_" if any(c not in allowed_characters for c in self.username.data): raise wtforms.ValidationError( "Username may only contain lowercase letters, digits, and undescores." ) if User.query.filter_by(username=self.username.data).first(): raise wtforms.ValidationError("Username already taken")
def validate_dice_report(self, field): min_dreport_size = config['MIN_DREPORT_SIZE'] data = field.data and field.data.strip() if not data: raise wtforms.ValidationError("Dice-report is required.") if len(data) < min_dreport_size: raise wtforms.ValidationError( "Dice-report is too short (less than %s char)." % min_dreport_size) return data
def __call__(self, form, field): challenge = request.form.get('recaptcha_challenge_field', '') response = request.form.get('recaptcha_response_field', '') remote_ip = request.remote_addr if not challenge or not response: raise wtforms.ValidationError('This field is required.') if not self._validate_recaptcha(challenge, response, remote_ip): field.recaptcha_error = 'incorrect-captcha-sol' raise wtforms.ValidationError(self.message)
def validate_time(form, field): """ Validate if the data set in the given field is a valid time. """ if isinstance(field.data, time): # pragma: no cover return if not re.match(r'\d?\d:\d\d?', field.data): raise wtforms.ValidationError(_('Time must be of type "HH:MM"')) time_data = field.data.split(':') try: field.data = time(int(time_data[0]), int(time_data[1])) except ValueError: raise wtforms.ValidationError(_('Time must be of type "HH:MM"'))
def validate_name(self, field): if not valid_username(field.data): raise wtforms.ValidationError("Invalid characters in name") if field.data in current_app.config['RESERVED_USERNAMES']: raise wtforms.ValidationError("That name is reserved") existing = User.get(username=field.data) if existing is not None: raise wtforms.ValidationError("That name is taken") existing = Organization.get(name=field.data) if existing is not None and existing.id != self.edit_id: raise wtforms.ValidationError("That name is taken")
def validate_date(self, field): exists = Activity.query.filter_by(venue=self.venue, date=field.data).first() if exists: raise wtforms.ValidationError( u'You cannot have two activities on the same date. %s already exists.' % exists.title) if field.data < self.venue.event.from_date or field.data > self.venue.event.to_date: raise wtforms.ValidationError( u'Activity date should be within the event dates %s & %s.' % (self.venue.event.from_date, self.venue.event.to_date))
def check_renders_correctly(form, field): try: render_url(field.data) except NameError as e: raise wtforms.ValidationError( request.localizer.translate( _(u'Unsupported template variables: ${names}'), mapping={'names': e.message})) except Exception as e: raise wtforms.ValidationError( request.localizer.translate(_(u'Unexpected erorr: ${message}'), mapping={'message': e.message}))
def validate_namespace(self, field): if field.data: if not domain_namespace_match(self.website.data, field.data): raise wtforms.ValidationError( u"The namespace should be derived from your application’s website domain" ) client = self.edit_model.get(namespace=field.data) if client: if client == self.edit_obj: return raise wtforms.ValidationError( "This namespace has been claimed by another client app")
def validate_long_url(self, field): long_url = field.data if long_url is None or len(long_url) == 0: current_app.logger.debug('Long url is None or empty') return current_app.logger.debug( 'Long url: {long_url}'.format(long_url=long_url)) if not is_url(long_url): raise wtforms.ValidationError('Long URL is invalid') short_id = g.tinyurl.get_short_id(long_url=long_url) if short_id is None: raise wtforms.ValidationError( 'TinyURL does not yet exist for this Long URL')
def validate_short_id(self, field): short_id = field.data if short_id is None or len(short_id) == 0: current_app.logger.debug('Short id is None or empty') return current_app.logger.debug( 'Short id: {short_id}'.format(short_id=short_id)) if not in_alphabet(short_id, BASE62): raise wtforms.ValidationError('Short ID is invalid') long_url = g.tinyurl.get_long_url(short_id) if long_url is None: raise wtforms.ValidationError( 'TinyURL does not yet exist for this Short ID')