def validate(self): rv = FlaskForm.validate(self) if not rv: return False if len(str(self.postalcode.data)) is 5 and int(self.postalcode.data): return True self.postalcode.data = re.sub(r'\s', r'', self.postalcode.data) if not len(str(self.postalcode.data)) is 6: self.postalcode.errors.append('Invalid postal code (length)') return False if not ''.join([ str(self.postalcode.data)[0], str(self.postalcode.data)[2], str(self.postalcode.data)[4] ]).isalpha(): self.postalcode.errors.append( 'Invalid postal code (example: A1A1A1)' ) return False if not ''.join([ str(self.postalcode.data)[1], str(self.postalcode.data)[3], str(self.postalcode.data)[5] ]).isdigit(): self.postalcode.errors.append( 'Invalid postal code (example: A1A1A1)' ) return False return True
def validate(self): # Validate all other fields with default validators if not FlaskForm.validate(self): return False result = True archive_date = self.archive_date.data publish_date = self.publish_date.data if archive_date and publish_date > archive_date: self.archive_date.errors.append( _('Archive date needs to be after the publish date.')) result = False # Test if either english or dutch is entered if not (self.nl_title.data or self.en_title.data): self.nl_title.errors.append( _('Either Dutch or English title required')) result = False if not (self.nl_content.data or self.en_content.data): self.nl_content.errors.append( _('Either Dutch or English content required')) result = False # XOR the results to test if both of a language was given if bool(self.nl_title.data) != bool(self.nl_content.data): self.nl_title.errors.append( _('Dutch title requires Dutch content and vice versa')) result = False if bool(self.en_title.data) != bool(self.en_content.data): self.en_title.errors.append( _('English title requires English content and vice versa')) result = False return result
def validate(self): rv = FlaskForm.validate(self) if rv is None: return False user = authenticate_user(current_user.username, self.password.data) if user is None: return False return True
def validate(self): if not Form.validate(self): return False if self.username.data == self.original_username: return True user = User.query.filter_by(username = self.username.data).first() if user != None: return False return True
def validate(self): if not FlaskForm.validate(self): return False user = User.query.filter_by(email = self.email.data.lower()).first() if user: self.email.errors.append("That email is already taken") return False else: return True
def validate(self): if not FlaskForm.validate(self): return False user = User.query.filter_by(email = self.email.data.lower()).first() if user and user.check_password(self.password.data): return True else: self.email.errors.append("Invalid e-mail or password") return False
def validate(self): if not FlaskForm.validate(self): return False if self.open.data: self.desired_state = DoorState.Open elif self.present.data: self.desired_state = DoorState.Present return True
def validate(self): rv = FlaskForm.validate(self) if not rv: return False user = User.get_user(self.username.data) if user and user.username.lower() != g.user.username.lower(): self.username.errors.append('Username already in use') return False return True
def validate(self): rv = FlaskForm.validate(self) if rv is None: return False user = authenticate_user(self.username.data, self.password.data) if user is None: self.username.errors.append("Invalid username or password") return False else: self.user = user return True
def validate(self): rv = FlaskForm.validate(self) if rv is None: return False user = User.objects(username__iexact=self.username.data).first() if user is None: return True else: self.username.errors.append("Username is already taken - try again") return False
def validate(self): rv = Form.validate(self) if not rv: return False captcha = session['captcha'] captcha_data = self.captcha.data if captcha_data.lower() != captcha.lower(): self.captcha.errors.append(_('The captcha is error')) return False return True
def validate(self): rv = FlaskForm.validate(self) config = ConfigParser.RawConfigParser() config.read('swingflask.conf') if ( self.username.data == config.get('admin', 'username') and self.password.data == config.get('admin', 'password') ): return True else: self.username.errors.append('Invalid credentials') return False
def validate(self): # check default validation if not FlaskForm.validate(self): return False # check nested forms for t in self.target_set: if not t.form.validate(): error_fields = ','.join(t.form.errors.keys()) self.target_set.errors.append({'target': t.name, 'message': 'Invalid target ' + error_fields}) return False return True
def validate(self): if not FlaskForm.validate(self): print "wrong two" return False user = User.query.filter_by(username=self.username.data).first() if user and user.verify_password(self.password_hash.data): return True else: flash('invalid username or password') self.username.errors.append("Invalid username or password") return False
def validate(self): rv = FlaskForm.validate(self) if not rv: return False user = User.query.filter_by(username=self.username.data).first() if user and user.verify_password(self.password_hash.data): print "login 1 working" return True else: flash("Invalid username or password") #self.username.errors.append("Invalid username or password") return False
def validate(self, *args, **kwargs): """ Validates the form by calling `validate` on each field, passing any extra `Form.validate_<fieldname>` validators to the field validator. also calls `validate_ldap` """ valid = FlaskForm.validate(self, *args, **kwargs) if not valid: logging.debug("Form validation failed before we had a change to " "check ldap. Reasons: '{0}'".format(self.errors)) return valid return self.validate_ldap()
def validate(self): # Validate all other fields with default validators if not FlaskForm.validate(self): return False # Test if either english or dutch is entered if self.start_time.data >= self.end_time.data: self.start_time.errors.append( _("Start time must be before end time")) # Append empty string to mark the field red. self.end_time.errors.append('') return False return True
def validate(self): rv = FlaskForm.validate(self) if not rv: return False print "hello worlkd" username = User.query.filter(func.lower(User.username) == func.lower(self.username.data)).first() if username: self.username.errors.append("Invalid username or password") flash('username taken') return False else: print "Register Validate success" return True
def validate(self): rv = FlaskForm.validate(self) if not rv: return False if self.action.data not in ('edit', 'new'): return False has_error = False if self.action.data in ('edit', 'new'): if type(self.name.data) not in (str, unicode) or not re.search(r'[A-Za-z0-9]', self.name.data): self.name.errors.append(word("The name must be filled in.")) has_error = True if type(self.method.data) not in (str, unicode) or self.method.data not in ('referer', 'ip', 'none'): self.name.errors.append(word("You must select an option.")) has_error = True if has_error: return False return True
def validate(self): self.user = None rv = FlaskForm.validate(self) if not rv: return False user = User.get_user(self.username.data) if user is None: self.username.errors.append('Unknown username') return False if not user.check_password(self.password.data): self.password.errors.append('Invalid password') return False self.user = user return True
def validate(self): rv = FlaskForm.validate(self) if not rv: return False user = User.query.filter_by(email=self.email.data).first() if user is not None: error = 'Email already in use' self.email.errors.append(error) print(("ERROR: %s" % error)) return False user = User(username=self.username.data, email=self.email.data) user.password = self.password.data self.user = user return True
def validate(self): if not self.url.data.startswith((r"http://", r"https://")): self.url.data = "".join(["https://",self.url.data]) if not FlaskForm.validate(self): return False if not self.description.data: self.description.data = self.url.data if not self.user.data: self.user.data = current_user.username # filter out the tags from the system stripped = set(filter(None, [t.strip() for t in self.tags.data.split(",")])) self.tags.data=",".join(sorted(stripped)) return True
def validate(self): if not (self.url.data.startswith("http://") or self.url.data.startswith("https://")): self.url.data = "http://" + self.url.data if not FlaskForm.validate(self): return False if not self.description.data: self.description.data = self.url.data #filter out empty and duplicate tag names stripped = [t.strip() for t in self.tags.data.split(',')] not_empty = [tag for tag in stripped if tag] #remove empty strings tagset = set(not_empty) #to remove duplicates self.tags.data = ",".join(tagset) #creating comma seperated values return True
def validate(self): if not FlaskForm.validate(self): return False institution_class = InstitutionClass.query.get(self.class_id.data) if institution_class is None: self.class_id.errors.append('Le type d\'institution n\'existe pas!') return False wilaya = Wilaya.query.get(self.wilaya_id.data) if wilaya is None: self.wilaya_id.errors.append('La wilaya n\'existe pas!') return False commune = Commune.query.get(self.commune_id.data) if commune is None or commune.wilaya_id is not wilaya.id: self.commune_id.errors.append('La commune n\'existe pas!') return False return True
def validate(self): if not (self.url.data.startswith("http://") or\ self.url.data.startswith("https://")): self.url.data = "http://" + self.url.data if not FlaskForm.validate(self): return False if not self.description.data: self.description.data = self.url.data # filter out empty and duplicate tag names stripped = [t.strip() for t in self.tags.data.split(',')] not_empty = [tag for tag in stripped if tag] tagset = set(not_empty) self.tags.data = ','.join(tagset) return True
def validate(self): # check that all required fields have been filled rv = FlaskForm.validate(self) if not rv: return False # check if given student reg no. is already registered student_ = Student.query.filter_by(reg_num=self.reg_num.data).first() if not student_: self.reg_num.errors.append("Unknown Registration Number") return False # save lecturer self.student_ = student_ # log staff in login_user(student_) # successful validation return True
def validate(self): """ custom validation method :return: boolean """ result = True if not FlaskForm.validate(self): result = False if not self.comm.data and not self.extcomm.data and not self.larcomm.data: err_message = "At last one of those values could not be empty" self.comm.errors.append(err_message) self.larcomm.errors.append(err_message) self.extcomm.errors.append(err_message) result = False return result
def validate(self): if not FlaskForm.validate(self): return False if self.nickname.data == self.original_nickname: return True if self.nickname.data != User.make_valid_nickname(self.nickname.data): self.nickname.errors.append( gettext( 'This nickname has invalid characters. ' 'Please use letters, numbers, dots and underscores only.')) return False user = User.query.filter_by(nickname=self.nickname.data).first() if user is not None: self.nickname.errors.append( gettext('This nickname is already in use. ' 'Please choose another one.')) return False return True
def validate(self): """ Validation of the Things form checking for tags separated by comma. Returns: True if the form is validated by it parent, else False. """ if not FlaskForm.validate(self): return False # Filter out empty and duplicate tag names stripped = [t.strip() for t in self.tags.data.split(',')] not_empty = [tag for tag in stripped if tag] tagset = set(not_empty) self.tags.data = ",".join(tagset) return True
def validate(self): """ Send a test request to see if this API credentials are valid """ rv = FlaskForm.validate(self) if not rv: return False client = ZoomClient(api_key=self.api_key.data, api_secret=self.api_secret.data) response = json.loads(client.user.list().content) # If invalid credentials, raise error to the form. if response.get("code") != 200: self.api_key.errors.append(response.get("message")) self.api_secret.errors.append(response.get("message")) return False return True
def validate(self): bad_names = [ 'delete', 'admin', 'bitcoin', 'bitcoincash', 'answer.cash', 'username', 'user_name', 'room', 'business', 'answer_bot', 'all', 'rooms', 'people', 'followers', 'monero', 'btc', 'btccash', 'answer' ] rv = FlaskForm.validate(self) if rv is True: if self.subcommonname.data.lower() in bad_names: flash('Name is not allowed.', category="danger") return False else: return True
def validate(self): # check default validation if not FlaskForm.validate(self): return False # check nested forms for t in self.target_set: if not t.form.validate(): error_fields = ','.join(t.form.errors.keys()) self.target_set.errors.append({ 'target': t.name, 'message': 'Invalid target ' + error_fields }) return False return True
def validate(self): return True rv = FlaskForm.validate(self) if not rv: return False start_date = self.start_date.data end_date = self.end_date.data today_date = date.today() if start_date > end_date: self.start_date.errors.append('Invalid start date ') return False if start_date < today_date: self.start_date.errors.append('Invalid start date') return False if start_date < today_date: self.end_date.errors.append('Invalid end date') return False return True
def validate(self): valid = FlaskForm.validate(self) if not valid: return False # make sure username exists in database user = User.query.filter_by(username=self.username.data).first() if user is None: self.username.errors.append( 'Unrecognized username. Please try again') return False # make sure password matches if not check_password_hash(user.password, self.password.data): self.password.errors.append('Password incorrect. Please try again') return False return True
def validate(self): return_value = Form.validate(self) if not return_value: return False if not self.first_name.data: self.first_name.errors.append({ "id": "firstNameInputLink", "message": "Enter your first name", "href": "firstNameContainer", "error_alert": "Enter your first name" }) return_value = False else: result = re.match(r"^[a-zA-Z0-9,-.'\s]+$", self.first_name.data) if not result: self.first_name.errors.append({ "id": "firstNameInputLink", "message": "Check your first name", "href": "firstNameContainer", "error_alert": "Check that you've entered your first name correctly" }) return_value = False if not self.last_name.data: self.last_name.errors.append({ "id": "lastNameInputLink", "message": "Enter your last name", "href": "lastNameContainer", "error_alert": "Enter your last name" }) return_value = False else: result = re.match(r"^[a-zA-Z0-9,-.'\s]+$", self.last_name.data) if not result: self.last_name.errors.append({ "id": "lastNameInputLink", "message": "Check your last name", "href": "lastNameContainer", "error_alert": "Check that you've entered your last name correctly" }) return_value = False return return_value
def validate(self): """ handles all address validation """ rv = FlaskForm.validate(self) if not rv: return False # Validate Addresses origin_validator = AddressValidator() # Check if not valid origin if not origin_validator.is_valid_address(self.startLocation.data): self.startLocation.errors.append('Origin: Invalid Location') return False dest_validator = AddressValidator() # check if not valid destination if not dest_validator.is_valid_address(self.endLocation.data): self.endLocation.errors.append('Destination: Invalid Location') return False # check if origin and destination are the same if origin_validator.address == dest_validator.address: self.startLocation.errors.append('Origin cannot match destination') self.endLocation.errors.append('Destination cannot match origin') return False # check if there are logged in drivers users = User.query.all() drivers = [] for u in users: if u.has_roles('driver') and u.is_logged_in(): drivers.append(u) if len(drivers) == 0: self.startLocation.errors.append( 'There are no available drivers at this time') self.endLocation.errors.append( 'There are no available drivers at this time') return False # If address validation passes, check for available drivers self.startLocation = origin_validator.address self.endLocation = dest_validator.address # all vaidations passed return True
def validate(self): if not (self.nm_url.data.startswith('https://') or self.nm_url.data.startswith('http://')): self.nm_url.data = "http://" + self.nm_url.data if not Form.validate(self): return False if not self.nm_description.data: self.nm_description.data = self.nm_url.data #filter our empty and duplicate tag names stripped = [t.strip() for t in self.tags.data.split(',')] #retira os espaços not_empty = [tag for tag in stripped if tag] #retira os vazios tagset = set(not_empty) #retira os duplicados self.tags.data = ','.join(tagset) return True
def validate(self): """Validate the form.""" rv = FlaskForm.validate(self) if not rv: return False user = db.session.query(User).filter_by(email=self.email.data).first() if user is None: self.email.errors.append(u'Unknown email.') return False if not user.check_password(self.password.data): self.password.errors.append(u'Invalid password.') return False self.user = user return True
def validate(self): """ Validate this form as usual and check for any form-level validation errors based on question type :return: boolean """ valid_fields = FlaskForm.validate(self) valid_date_range_form = True valid_calculated_form = True valid_mutually_exclusive_form = True for question in self.schema.get_questions_for_block(self.block_json): if question['type'] == 'DateRange' and valid_date_range_form: valid_date_range_form = self.validate_date_range_question(question) elif question['type'] == 'Calculated' and valid_calculated_form: valid_calculated_form = self.validate_calculated_question(question) elif question['type'] == 'MutuallyExclusive' and valid_mutually_exclusive_form and valid_fields: valid_mutually_exclusive_form = self.validate_mutually_exclusive_question(question) return valid_fields and valid_date_range_form and valid_calculated_form and valid_mutually_exclusive_form
def validate(self) -> bool: valid = FlaskForm.validate(self) hash_ = bcrypt.hashpw( self.password_old.data.encode('utf-8'), current_user.password.encode('utf-8')) if hash_ != current_user.password.encode('utf-8'): self.password_old.errors.append(_('error wrong password')) valid = False if self.password.data != self.password2.data: self.password.errors.append(_('error passwords must match')) self.password2.errors.append(_('error passwords must match')) valid = False if self.password_old.data == self.password.data: self.password.errors.append(_('error new password like old password')) valid = False if len(self.password.data) < session['settings']['minimum_password_length']: self.password.errors.append(_('error password too short')) valid = False return valid
def validate(self): rv = FlaskForm.validate(self) if not rv: return False user = User.get_user(self.username.data) if user and user.username.lower() != g.user.username.lower(): self.username.errors.append('Username already in use') return False if self.password.data: if self.old_password.data == '': self.old_password.errors.append('Please enter your old password') return False elif not user.check_password(self.old_password.data): self.old_password.errors.append('Incorrect password') return False return True
def validate(self): rv = FlaskForm.validate(self) if not rv: return False birth_date = str_to_date(self.birth_date.data) if not birth_date: self.birth_date.errors.append("Invalid birth date") return False if birth_date >= datetime.date(datetime.today()): self.birth_date.errors.append( "A birth date can not be today or later.") return False self.birth_date.data = birth_date start_date = str_to_date(self.start_date.data) if not start_date: start_date = datetime.date(datetime.today()) self.start_date.data = start_date return True
def validate(self): rv = FlaskForm.validate(self) if not rv: return False if len(self.foldername.data) > 15: flash("Invalid name: " + self.foldername.data) flash("Name can be at most 15 characters.") return False if self.foldername.data.find('#') != -1: flash("Invalid name: " + self.foldername.data) flash("Name cannot contain character '#'.") return False if self.foldername.data.find(' ') != -1: flash("Invalid name: " + self.foldername.data) flash("Name cannot contain spaces.") return False return True
def validate(self): valid = FlaskForm.validate(self) if not valid: return False # make sure user entered a unique username user = User.query.filter_by(username=self.username.data).first() if user is not None: self.username.errors.append( 'Username already taken. Please try again') return False # make sure user entered a unique email user = User.query.filter_by(email=self.email.data).first() if user is not None: self.email.errors.append('Email already taken. Please try again') return False return True
def validate(self): if not FlaskForm.validate(self): return False if self.name.data and self.password.data and self.role.data: from peerplaysbase.account import PasswordKey pkey = PasswordKey(self.name.data, self.password.data, self.role.data) self.privateKey.data = pkey.get_private_key() if self.privateKey.data: try: Node().validateAccount(self.privateKey.data), return True except Exception: self.privateKey.errors.append( "No account connected to this private key") return False else: return False
def validate(self): rv = FlaskForm.validate(self) if not rv: return False if self.action.data not in ('edit', 'new'): return False has_error = False if self.action.data in ('edit', 'new'): if (not isinstance(self.name.data, string_types)) or not re.search( r'[A-Za-z0-9]', self.name.data): self.name.errors.append(word("The name must be filled in.")) has_error = True if (not isinstance(self.method.data, string_types) ) or self.method.data not in ('referer', 'ip', 'none'): self.name.errors.append(word("You must select an option.")) has_error = True if has_error: return False return True
def validate(self): rv = FlaskForm.validate(self) # parse invitation token invitation = self.invitation.data email = "" try: if current_app.config['ACCOUNT_CREATION_NEEDS_INVITATION']: seed, email = serialiser.loads(invitation) if seed != "invitation": raise ValueError("") if self.email.data == "": self.email.data = email except Exception as err: self.invitation.errors.append('Wrong token' + err.message) return False rv = self.email.validate(email) if rv: self.username.errors.append('Adresse invalide.') # uniqness if Users.has_pseudo(self.username.data): self.username.errors.append('Ce pseudo utilisé') rv = False user = Users.get_by_email(self.email.data) if user: message = 'Un compte est déja enregistré pour cette adresse %s' % email self.email.errors.append(message) raise EmailExistsValidationError(message, user) # password complexity if not self.password.data or len(self.password.data) < 8: self.password.errors.append( 'La longueur de password minimal est de 8 caractères') rv = False return rv
def validate(self): """Extra validation, used to validate gene list.""" # Default validation as defined in field validators self.transcripts = [] # Reset transcripts on validation if not FlaskForm.validate(self): return False if self.gene_list.data: # Parse gene_list errors, self.transcripts = parse_gene_list(self.gene_list.data, self.transcripts) if errors: self.gene_list.errors.extend(errors) return False if self.gene_list.errors: return False return True
def validate(self): if not self.url.data.startswith( "http://") and not self.url.data.startswith("https://"): self.url.data = "https://" + self.url.data # print(self.url.data) # sys.stdout.flush() if not FlaskForm.validate(self): return False if not self.description.data: self.description.data = self.url.data stripped = [t.strip() for t in self.tags.data.split(',')] not_empty = [tag for tag in stripped if tag] tagset = set(not_empty) self.tags.data = ",".join(tagset) return True
def validate(self): if not Form.validate(self): return False try: idInput = self.username.data pswInput = self.password.data hashed_psw = hashlib.sha256(pswInput).hexdigest() dataDict = [ dict(p.to_dict(), **dict(id=p.key.id())) for p in model.UserAccount.query( model.UserAccount.username == idInput) ] accountPsw = dataDict[0]['password'] if accountPsw == hashed_psw: return True else: self.username.errors.append("Invalid username or password") except: self.username.errors.append("Invalid username or password")
def validate(self): rv = FlaskForm.validate(self) if not rv: return False pw = self.password.data if len(pw) < 6: self.password.errors.append('Password must be\ at least 6 characters,\ contain upper and lower\ case letters, and at least,\ one number') return False elif len(set(string.ascii_lowercase).intersection(pw)) == 0: self.password.errors.append('Password must be\ at least 6 characters,\ contain upper and lower\ case letters, and at least,\ one number') return False elif len(set(string.ascii_uppercase).intersection(pw)) == 0: self.password.errors.append('Password must be\ at least 6 characters,\ contain upper and lower\ case letters, and at least,\ one number') return False elif len(set(string.digits).intersection(pw)) == 0: self.password.errors.append('Password must be\ at least 6 characters,\ contain upper and lower\ case letters, and at least,\ one number') return False user = User.query.filter_by(username=self.username.data).first() if user is not None: self.username.errors.append('Username already in use. \ Please choose another one') return False email = User.query.filter_by(email=self.email.data).first() if email is not None: self.email.errors.append('Email already in use') return False return True
def skip(): assert g.get('csrf_valid') # don't pass the token, then validate the form # this would fail if CSRFProtect didn't run form = FlaskForm(None) assert form.validate()
def validate(self): if not Form.validate(self): return False return True
def validate(self): if request.form.get('message'): # super simple bot test (advanced bots will get by this) log.warning("Suspect form submission from (put IP here), ignoring") abort(404) return FlaskForm.validate(self)