def login(self):
error = None
Form = self.get_login_form()
if request.method == 'POST':
form = Form(request.form)
next_url = request.form.get('next') or self.default_next_url
if form.validate():
authenticated_user = self.authenticate(
form.username.data,
form.password.data,
)
if authenticated_user:
self.login_user(authenticated_user)
return redirect(next_url)
else:
flash('Incorrect username or password')
else:
form = Form()
next_url = request.args.get('next')
return render_template(
'auth/login.html',
error=error,
form=form,
login_url=url_for('%s.login' % self.blueprint.name),
next=next_url)
def __init__(self, formdata=None, obj=None, prefix="", endpoint=None, **kwargs):
if endpoint:
kwargs.setdefault("provider", endpoint.provider)
kwargs.setdefault("description", endpoint.description)
kwargs.setdefault("service_key", endpoint.service_key)
kwargs.setdefault("alert_text", endpoint.alert_text)
Form.__init__(self, formdata, obj, prefix, **kwargs)
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.category = None
self.name.label.text = _(u'Category Name')
self.num.label.text = _(u'Position')
self.visible.label.text = _(u'Visible')
self.img.label.text = _(u'Icon')
def __init__(self, formdata=None, obj=None, prefix='', endpoint=None, **kwargs):
if endpoint:
kwargs.setdefault('provider', endpoint.provider)
kwargs.setdefault('description', endpoint.description)
kwargs.setdefault('service_key', endpoint.service_key)
kwargs.setdefault('alert_text', endpoint.alert_text)
Form.__init__(self, formdata, obj, prefix, **kwargs)
def AuthenticatedGet(self, org, event):
site_proj = db.Query(
Site,
projection=('county', 'state'),
distinct=True
).filter('event', event)
counties_and_states = {
site.county_and_state : (site.county, site.state) for site
in site_proj
}
Form = create_site_filter_form(counties_and_states)
form = Form(self.request.GET)
if not form.validate():
form = Form() # => use defaults
# construct query
query = Site.all().filter('event', event.key())
if form.county_and_state.data:
county, state = counties_and_states[form.county_and_state.data]
query = query.filter('county', county).filter('state', state)
if form.order.data:
query = query.order(form.order.data)
# run query
sites = list(query.run(
offset=form.page.data * self.SITES_PER_PAGE,
limit=self.SITES_PER_PAGE
))
self.response.out.write(template.render(dict(
page_db.get_page_block_dict(), **{
"form": form,
"sites": sites,
"sites_per_page": self.SITES_PER_PAGE,
})))
def __init__(self, formdata=None, obj=None, prefix='', **kwargs):
try:
kwargs.setdefault('season', kwargs["season_default"])
print kwargs
except:
pass
Form.__init__(self, formdata, obj, prefix, **kwargs)
def __init__(self, bible, fdata):
Form.__init__(self, fdata)
self.bookSel.choices = [ self.pair(x.name) for x in bible.canon ]
book = bible.book(self.bookSel.data) #Convert name to actual book
chpt = book.chapter(int(self.chapSel.data.split()[-1]))
self.chapSel.choices = [ self.cpair(x) for x in range(1, len(book)+1) ]
self.verseSel.choices = [ self.vpair(x) for x in range(1, len(chpt.verses)) ]
self.verses = chpt.verses
def __init__(self, formdata=None, obj=None, prefix='', **kwargs):
#kwargs.setdefault({'deploy_script': '', 'host_list': ''})
#kwargs.setdefault('host_list', '')
Form.__init__(self, formdata, obj, prefix, **kwargs)
script_list = query_script()
server_list = query_server()
self.deploy_script.choices = zip(script_list, script_list)
self.host_list.choices = zip(server_list, server_list)
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.product = None
self.name.label.text = _(u'Product Name')
self.memo.label.text = _(u'Memo')
self.img.label.text = _(u'Image')
self.price.label.text = _(u'Price')
self.category.label.text = _(u'Category')
self.category.choices = [(h.id, h.name) for h in Category.query.all()]
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.user = None
self.name.label.text = _(u'Name')
self.email.label.text = _(u'Email')
self.password.label.text = _(u'Password')
self.password2.label.text = _(u'Repeat Password')
self.lang.label.text = _(u'Language')
self.rank.label.text = _(u'Rank')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.key.label.text = _(u'Confirmation code')
self.emoney.label.text = _(u'Payment cards')
self.pdel.label.text = _(u'Driver paid')
self.phone.label.text = _(u'Phone')
self.email.label.text = u'Email'
self.link.label.text = u'ВКонтакте'
self.pdelcost.label.text = _(u'Cost of order')
def __init__(self, formdata=None, obj=None, prefix='', assign_default=True, **kwargs):
"""
Override init to provide default data to form
"""
if assign_default:
kwargs.setdefault('assigned_to', self.default())
Form.__init__(self, formdata, obj, prefix, **kwargs)
self.assigned_to.choices = self.choices()
def __init__(self, formdata=None, obj=None, prefix='', assign_default=True, **kwargs):
"""
Override init to provide default data to form
"""
if assign_default:
kwargs.setdefault('task_completion_status', task.completion_status)
Form.__init__(self, formdata, obj, prefix, **kwargs)
self.task_completion_status.choices = self.choices()
def validate(self):
"""
Validation for Login
:return:
"""
Form.validate(self)
if authenticate_user(self.net_id.data, self.password.data, self.instructor_type.data):
return True
self.password.errors.append('Password and Username do not match')
return False
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.category = None
self.name.label.text = _(u'Category Name')
self.num.label.text = _(u'Position')
self.visible.label.text = _(u'Visible')
self.paid.label.text = _(u'Paid')
self.dcost.label.text = _(u'Cost of delivery')
self.parentid.label.text = _(u'Parent category')
self.parentid.choices = [(0,_(u'No parent category'))]+[(h.id, get_full_lenght_name(h.id,h.name)) for h in Category.query.all()]
def __init__(self, request=None, obj=None, prefix='', formdata=None, **kwargs):
if request:
if isinstance(request, dict):
arguments = request
else:
arguments = request.arguments
formdata = MultiValueDict()
for name, values in arguments.items():
formdata.setlist(name, [sanitize_parameter_value(v) for v in values])
Form.__init__(self, formdata, obj=obj, prefix=prefix, **kwargs)
def __init__(self, *args, **kwargs):
today = datetime.date.today()
kwargs["monthEnd"] = session.get("monthEnd", today.month)
kwargs["yearEnd"] = session.get("yearEnd", today.year)
lastMonth = today - datetime.timedelta(days=30)
kwargs["monthStart"] = session.get("monthStart", lastMonth.month)
kwargs["yearStart"] = session.get("yearStart", lastMonth.year)
Form.__init__(self, *args, **kwargs)
def __init__(self, formdata=None, obj=None, prefix='', savedsearch=None, **kwargs):
if savedsearch:
kwargs.setdefault('id', savedsearch.id)
kwargs.setdefault('name', savedsearch.name)
kwargs.setdefault('terms', savedsearch.context['terms'])
kwargs.setdefault('inputs', savedsearch.context['inputs'])
kwargs.setdefault('devices', savedsearch.context.get('devices', [])) # devices may not be in context
Form.__init__(self, formdata, obj, prefix, **kwargs)
self.inputs.choices = get_input_choices()
self.devices.choices = get_device_choices()
def __init__(self, formdata=None, obj=None, prefix='', alert=None, **kwargs):
if alert:
kwargs.setdefault('name', alert.name)
kwargs.setdefault('description', alert.description)
kwargs.setdefault('saved_search', alert.saved_search)
kwargs.setdefault('threshold_operator', alert.threshold_operator)
kwargs.setdefault('threshold_count', alert.threshold_count)
kwargs.setdefault('threshold_time_secs', alert.threshold_time_secs)
kwargs.setdefault('sound', alert.sound)
kwargs.setdefault('endpoint', alert.endpoint)
Form.__init__(self, formdata, obj, prefix, **kwargs)
self.saved_search.choices = get_saved_search_choices()
self.endpoint.choices = get_endpoint_choices()
def validate(self):
"""
Validate user email and password is correct.
"""
if not Form.validate(self):
return False
user = User.query.filter(User.email == self.email.data).first()
if user is not None:
sha1 = hashlib.sha1()
sha1.update(self.password.data)
if user.password == sha1.hexdigest():
self.user = user
is_user_valid = True
else:
self.user = None
is_user_valid = False
flash(u'邮箱或密码错误', 'error')
else:
self.user = None
is_user_valid = False
flash(u'邮箱或密码错误', 'error')
return is_user_valid
def validate(self):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
# Query data from database
user = savvy_collection.find_one({ EMAIL: self.email.data.rstrip() })
if user:
email = user.get(EMAIL, None)
hash_password = user.get(PASSWORD, None)
user_password = self.password.data.rstrip()
account_token = user.get(TOKEN, '')
if User.validate_login(hash_password, user_password):
userObj = User(email)
login_user(userObj)
return True
else:
flash('Incorrect login credentials', 'error')
else:
flash('Incorrect login credentials', 'error')
return False
def validate(self):
"""
Validation for Registration Forms
Checks for type of user and checks if "net id" has already been registered
Performs sanity checks as well (same passwords)
If There are errors, appends errors to the form
:return: True if no Errors else False
"""
# Authenticate USER
if Form.validate(self) == False:
return False
if self.instructor_type.data == "TA":
if TA.check_in_ta_list(self.net_id.data) == False:
self.net_id.errors.append("This Net ID is not a valid TA")
elif TA.check_ta_registration(self.net_id.data) == True:
self.net_id.errors.append("This Net ID has already been registered")
else:
return True
elif self.instructor_type.data == "student":
if student.check_in_student_list(self.net_id.data) == False:
self.net_id.errors.append("This NETID is not a valid Student")
elif student.check_student_registration(self.net_id.data) == True:
self.net_id.errors.append("This Net ID has already been registered")
else:
return True
return False
def login(self):
error = None
Form = self.get_login_form()
if request.method == "POST":
form = Form(request.form)
if form.validate():
authenticated_user = self.authenticate(form.username.data, form.password.data)
if authenticated_user:
self.login_user(authenticated_user)
return redirect(request.args.get("next") or url_for(self.default_next_url))
else:
flash("Incorrect username or password")
else:
form = Form()
return render_template("auth/login.html", error=error, form=form)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(username=self.username.data).first()
if user and user.check_password(self.password.data):
return True
else:
self.username.errors.append('Invalid username or password')
return False
def validate(self,):
if not Form.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 email or password')
return False
def validate(form):
if not Form.validate(form):
return False
result = True
wp = wordpress.WordpressAPI()
if not wp.verify_nym(form.nym.data, form.email.data):
form.email.errors.append(form.verification_error)
result = False
return result
def validate(self):
if not Form.validate(self):
return False
if not(self.temperature_min_val.data.isdigit() and self.temperature_max_val.data.isdigit()):
return False
else:
if int(self.temperature_min_val.data)>int(self.temperature_max_val.data):
return False
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
u = self.get_user()
if not u:
return False
else:
return True
def validate(self) -> bool:
rv = Form.validate(self)
if not rv:
return False
current_pull_mirror = PullMirror.query.filter(
PullMirror.id == self.id.data).first()
project_name_exists = PullMirror.query.filter(
PullMirror.project_name == self.project_name.data,
PullMirror.id != current_pull_mirror.id).first()
if project_name_exists:
self.project_name.errors.append(
gettext('Project name %(project_name)s already exists.',
project_name=self.project_name.data))
return False
project_mirror_exists = PullMirror.query.filter(
PullMirror.project_mirror == self.project_mirror.data,
PullMirror.id != current_pull_mirror.id).first()
if project_mirror_exists:
self.project_mirror.errors.append(
gettext('Project mirror %(project_mirror)s already exists.',
project_mirror=self.project_mirror.data))
return False
if not GitRemote.detect_vcs_type(self.project_mirror.data):
self.project_mirror.errors.append(
gettext('Unknown VCS type or detection failed.'))
return False
try:
check_project_visibility_in_group(self.visibility.data,
self.group.data)
except VisibilityError as e:
self.visibility.errors.append(gettext(str(e)))
return False
if check_project_exists(self.project_name.data, self.group.data,
current_pull_mirror.project.gitlab_id):
if not self.is_force_create.data:
self.project_name.errors.append(
gettext(
'Project with name %(project_name)s already exists in selected group and "Create project in GitLab even if it already exists." is not checked in "Advanced options"',
project_name=self.project_name.data))
return False
if self.periodic_sync.data:
try:
ExpressionDescriptor(self.periodic_sync.data,
throw_exception_on_parse_error=True)
except (MissingFieldException, FormatException):
self.periodic_sync.errors.append(
gettext('Wrong cron expression.'))
return True
def validate(self):
if not Form.validate(self):
return False, str(self.errors)
if len(self.answers.data) < 1:
e = "Must provide at least one answer for the question"
self.errors["answers"] = e
return False,e
return True, "Valid"
def validate(self):
if not Form.validate(self):
return False
# Cusmtom Clave de 2 o más caracteres
if len(self.clave.data) < 3:
self.clave.errors.append('Clave muy Corta.')
return False
return True
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("That username is already taken")
return False
else:
return True
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(username=self.username.data).first()
if user and user.check_password(self.password.data):
return True
else:
self.username.errors.append("Invalid Username or Password")
return False
def validate(self):
if not Form.validate(self):
return False
if len(self.password.data) < 6:
self.password.errors.append(
"Password need to be min 6 characters of length")
return False
return True
def validate(self):
if not Form.validate(self):
return False
if db.session.query(User).filter_by(
username=self.username.data).count() > 0:
self.username.errors.append('User already exists')
return False
return True
def validate(self):
if not Form.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):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
return True
def validate(self, extra_validators=None):
if not Form.validate(self):
return False
if len(self.password.data) <= 4:
self.password.errors.append('Password is too short')
return False
return True
def test_a_partner_should_never_be_an_admin(self, app, db_session):
# given
user = User()
view = PartnerUserView(model=User, session=db_session)
# when
view.on_model_change(Form(), model=user, is_created=False)
# then
assert user.isAdmin == False
def validate(self):
if not Form.validate(
self): ## Recomendable primero las demas validaciones
return False
if len(self.password.data) < 3:
self.password.errors.append('El password es demasiado corto!')
return False
return True ## Obligatorio retornar un booleano
def validate(self):
# validamos todas las validaciones predifinidas
if not Form.validate(self):
return False
if len(self.password.data) < 3:
self.password.errors.append('El password es demasiado corto')
return False
return True
def test_a_partner_should_not_need_to_fill_cultural_survey(self, app, db_session):
# given
user = User()
view = PartnerUserView(model=User, session=db_session)
# when
view.on_model_change(Form(), model=user, is_created=True)
# then
assert user.needsToFillCulturalSurvey == False
def index():
name = TextField('Name:', validators=[validators.required()])
letter = MultiCheckboxField('Label', choices=letters)
form = Form()
cdata = Counter.query.filter_by(id=1).first()
return render_template('main.html',
name=name,
letter=letter,
form=form,
cdata=cdata.number)
def test_a_partner_should_not_need_to_see_beneficiaries_tutorial(self, app, db_session):
# given
user = User()
view = PartnerUserView(model=User, session=db_session)
# when
view.on_model_change(Form(), model=user, is_created=True)
# then
assert user.hasSeenTutorials == True
def reg():
form = Form(request.form)
if request.method == 'POST':
fid = request.form['id']
fpassword = request.form['password']
femail = request.form['email']
if form.validate():
cur = db1.cursor()
cur.execute(
"INSERT INTO user(id,email,password,active,cofirmed_at,roles) VALUES (%s,%s,%s,%s,%s,%s)",
(fid, femail, set_password(fpassword), 1,
datetime.datetime.now(), 'user'))
db1.commit()
flash('Thanks for registration ' + femail)
elif len(femail) < 1:
flash('Error: Too short email')
elif (len(fid) < 1) or (len(fpassword) < 1):
flash('Error: All the form fields are required. ')
return render_template('register.html', form=form)
def upgrade(self, shop):
rv = Form.validate(self)
if rv:
shop.name = self.name.data
shop.address = self.address.data
db.session.add(shop)
db.session.commit()
self.shop = shop
return True
return False
def validate(self):
if not Form.validate(self):
return False
# Validaciones propias
if len(self.password.data) < 4:
self.password.errors.append('El password es demasiado corto.')
return False
return True
def validate(self):
if not Form.validate(self):
return False
if len(self.password.data) < 3:
self.password.errors.append("El password es demaciado corto.")
return False
return True
def create_new(self):
rv = Form.validate(self)
if rv:
shop = Shop()
shop.init(self.name.data, self.address.data)
db.session.add(shop)
db.session.commit()
self.shop = shop
return True
return False
def validate(self):
if not Form.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 upgrade(self, shop):
rv = Form.validate(self)
if rv:
shop.name = self.name.data
shop.address = self.address.data
db.session.add(shop)
db.session.commit()
self.shop = shop
return True
return False
def create_new(self):
rv = Form.validate(self)
if rv:
shop = Shop()
shop.init(self.name.data, self.address.data)
db.session.add(shop)
db.session.commit()
self.shop = shop
return True
return False
def validate(self):
rv = Form.validate(self)
if not rv:
message = ''
for fieldName, errorMessages in self.errors.items():
for err in errorMessages:
message = message + fieldName + ': ' + err + '\n'
flash(message, 'error')
return False
user = savvy_collection.find_one({EMAIL: self.email.data.rstrip()})
if user:
flash('Email has already been taken', 'warning')
return False
else:
raw_token = self.email.data + 'verification code'
token = md5(raw_token.encode('utf-8')).hexdigest()
user = {
PASSWORD:
md5(self.password.data.rstrip().encode('utf-8')).hexdigest(),
EMAIL:
self.email.data.rstrip(),
CATEGORY:
self.category.data,
TOKEN:
token
}
# insert into database
employerId = savvy_collection.insert_one(user).inserted_id
if self.category.data == EMPL:
jobs_collection.insert({EMPLID: employerId})
# url = os.getenv('SCRIPT_URI') <----------------get this to work when server is up
# url = '127.0.0.1:5000'
# message = """
# Hi {},
#
# You need to confirm your account by clicking this link:
# {}/confirmEmail/{}/{}
#
# Best,
# Team SavvyHire
# """.format(self.username.data.rstrip(),url, self.username.data.rstrip(), token)
#
# cmd="""echo '{}' | mail -s 'Confirm account' {}""".format(message, self.email.data.rstrip())
# p=subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
# p.communicate()
# log in
userObj = User(user[EMAIL])
login_user(userObj)
return True
def validate(self):
rv = Form.validate(self)
if not rv:
return False
if self.language.data not in language_list:
self.language.errors.append(
"Please specify a valid language for the paste.")
return False
return True
def validate(self, data, isValid):
rv = Form.validate(self)
if not rv:
return False
if not data:
self.email.errors.append('Unknown Email')
return False
if not isValid:
self.password.errors.append('Invalid Password')
return False
return True
def validate(self):
if not Form.validate(self):
return None
user = User.query.filter_by(username=self.username.data).first()
if not user:
self.username.errors.append('User doesn\'t exist')
return None
if not user.check_password(self.password.data):
self.password.errors.append('Incorrect password')
return None
return user
def validate(self):
"""Sobrescribimos la funcion validate. Primero validamos las que estan utilizadas
en el formulario y luego las que sobreescribimos"""
if not Form.validate(self):
return False
if len(self.password.data) < 3:
self.password.errors.append("El password es demasiado Corto")
return False
return True
def validate_length(self, field1, field2, field3):
val = Form.validate(self)
if not val:
return False
if field3 == 'hamming':
if len(field1) != len(field2):
self.message = "The strings must be equal in length for Hamming distance"
#raise ValidationError("The two strings must be equal in length.")
self.str2.errors.append(self.message)
return False
def create_new(self):
rv = Form.validate(self)
if rv:
category = Category()
category.init(self.name.data, self.num.data, self.parentid.data,
self.visible.data, self.paid.data, self.dcost.data)
db.session.add(category)
db.session.commit()
self.category = category
return True
return False
def validate_on_submit(self):
print "hello there"
if not Form.validate(self):
print "not validated"
return False
# user = User.query.find(username = self.username)
# print user
# if user:
# self.username.errors.append("Username taken")
# return False
return True
