def test_validator_translation(self):
form = self.F2(a='hellobye')
self.assertFalse(form.validate())
self.assertEqual(form.a.errors[0], 'field cannot be longer than 5 characters.')
form = self.F(a='hellobye')
self.assertFalse(form.validate())
self.assertEqual(form.a.errors[0], 'Field cannot be longer than 5 characters.')
def test_blog_form_saving(self):
form = BlogForm(FakePost({"title": "new blog"}))
self.assertTrue(form.validate())
blog = Blog()
form.populate_obj(blog)
self.assertEqual(blog.title, "new blog")
# no new blogs were created
self.assertEqual(Blog.select().count(), 2)
# explicitly calling save will create the new blog
blog.save()
# make sure we created a new blog
self.assertEqual(Blog.select().count(), 3)
form = BlogForm(FakePost({"title": "a edited"}), obj=self.blog_a)
self.assertTrue(form.validate())
form.populate_obj(self.blog_a)
self.assertEqual(self.blog_a.title, "a edited")
self.blog_a.save()
# make sure no new blogs were created
self.assertEqual(Blog.select().count(), 3)
# grab it from the database
a = Blog.get(title="a edited")
def test_null_form_saving(self):
form = NullFieldsModelForm(FakePost({"c": ""}))
self.assertTrue(form.validate())
nfm = NullFieldsModel()
form.populate_obj(nfm)
self.assertEqual(nfm.c, None)
# this is a bit odd, but since checkboxes do not send a value if they
# are unchecked this will evaluate to false (and passing in an empty
# string evalutes to true) since the wtforms booleanfield blindly coerces
# to bool
self.assertEqual(nfm.b, False)
form = NullFieldsModelForm(FakePost({"c": "", "b": ""}))
self.assertTrue(form.validate())
nfm = NullFieldsModel()
form.populate_obj(nfm)
self.assertEqual(nfm.c, None)
# again, this is for the purposes of documenting behavior -- nullable
# booleanfields won't work without a custom field class
# Passing an empty string will evalute to False
# https://bitbucket.org/simplecodes/wtforms/commits/35c5f7182b7f0c62a4d4db7a1ec8719779b4b018
self.assertEqual(nfm.b, False)
form = NullFieldsModelForm(FakePost({"c": "test"}))
self.assertTrue(form.validate())
nfm = NullFieldsModel()
form.populate_obj(nfm)
self.assertEqual(nfm.c, "test")
def test_hidden_field_none(self):
class TestNullEntryForm(WTForm):
blog = HiddenQueryField(query=Blog.select())
form = TestNullEntryForm(FakePost({"blog": ""}))
# check the htmlz for the form's hidden field
html = form._fields["blog"]()
self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="">')
self.assertTrue(form.validate())
self.assertEqual(form.blog.data, None)
entry = NullEntry()
form.populate_obj(entry)
# ensure entry count hasn't changed
self.assertEqual(NullEntry.select().count(), 0)
entry.save()
self.assertEqual(NullEntry.select().count(), 1)
# make sure the blog object came through ok
self.assertEqual(entry.blog, None)
# edit entry a1
form = TestNullEntryForm(FakePost({"blog": None}), obj=self.entry_a1)
# check the htmlz for the form's hidden field
html = form._fields["blog"]()
self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="">')
self.assertTrue(form.validate())
def test_hidden_field(self):
class TestEntryForm(WTForm):
blog = HiddenQueryField(query=Blog.select())
title = wtfields.TextField()
content = wtfields.TextAreaField()
form = TestEntryForm(FakePost({"title": "new entry", "content": "some content", "blog": self.blog_b.get_id()}))
# check the htmlz for the form's hidden field
html = form._fields["blog"]()
self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="%s">' % self.blog_b.get_id())
self.assertTrue(form.validate())
self.assertEqual(form.blog.data, self.blog_b)
entry = Entry()
form.populate_obj(entry)
# ensure entry count hasn't changed
self.assertEqual(Entry.select().count(), 3)
entry.save()
self.assertEqual(Entry.select().count(), 4)
self.assertEqual(self.blog_a.entry_set.count(), 2)
self.assertEqual(self.blog_b.entry_set.count(), 2)
# make sure the blog object came through ok
self.assertEqual(entry.blog, self.blog_b)
# edit entry a1
form = TestEntryForm(
FakePost({"title": "a1 edited", "content": "a1 content", "blog": self.blog_b.get_id()}), obj=self.entry_a1
)
# check the htmlz for the form's hidden field
html = form._fields["blog"]()
self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="%s">' % self.blog_b.get_id())
self.assertTrue(form.validate())
form.populate_obj(self.entry_a1)
self.entry_a1.save()
self.assertEqual(self.entry_a1.blog, self.blog_b)
self.assertEqual(self.blog_a.entry_set.count(), 1)
self.assertEqual(self.blog_b.entry_set.count(), 3)
# pull from the db just to be 100% sure
a1 = Entry.get(title="a1 edited")
def test_form(self):
tcache = i18n_form.translations_cache
tcache.clear()
form = self.F()
assert ('en_US', 'en') in tcache
assert form._get_translations() is tcache[('en_US', 'en')]
assert not form.validate()
self.assertEqual(form.a.errors[0], 'This field is required.')
form = self.F(LANGUAGES=['es'])
assert ('es', ) in tcache
self.assertEquals(len(tcache), 2)
assert not form.validate()
self.assertEqual(form.a.errors[0], 'Este campo es obligatorio.')
def update(self):
if request.is_xhr:
status = "NOK"
ret_id = 0
if admin_per.require().can():
form = MenuViewForm(request.form)
myChoices = [('0', '...')] + [(str(page.id), page.translations[get_locale()].title) for page in
Pages.query.order_by(Pages.updated_on.desc()).all()]
form.page_view.choices = myChoices
if form.validate():
res = update_node(request.form['node_id'], request.form['page_view'])
if res is not None:
ret_id = request.form['node_id']
status = "OK"
else:
data = []
for field, errors in form.errors.items():
for error in errors:
data.append((getattr(form, field).label.text, error))
status = data
return jsonify({'status': status, 'id': ret_id})
else:
# redirect to home
return redirect(url_for('.index'))
def post(self):
next_url = self.request.params.get('next_url', webapp2.uri_for('main'))
form = MojangLoginForm(self.request.POST)
if form.validate():
username = form.username.data
password = form.password.data
try:
u, uuid, access_token = mojang_authentication(username, password)
if u:
email = None
if '@' in username:
email = username
auth_id = User.get_mojang_auth_id(uuid=uuid)
self.login_auth_id(auth_id, nickname=u, username=u, email=email)
self.redirect(next_url)
return
except MojangException as me:
message = u'Mojang authentication failed (Reason: {0}).'.format(me)
self.session.add_flash(message, level='error')
gae_login_uri = get_gae_login_uri(self, next_url)
context = {
'gae_login_uri': gae_login_uri,
'mojang_login_form': form,
'next_url': next_url
}
self.render_template('login.html', context=context)
def _common_test(self, expected_error, form_kwargs, form_class=None):
if not form_class:
form_class = self.F
form = form_class(**form_kwargs)
assert not form.validate()
self.assertEqual(form.a.errors[0], expected_error)
return form
def edit_view(self):
if (not request.args) or (not request.args.get('id')):
return abort(404)
id = request.args['id']
procurement = models.Procurement.query.get(id)
form = forms.ProcurementForm(request.form, procurement)
# check that the user has permission
if not g.user.is_admin:
if procurement.country_id != g.user.country_id:
return abort(401)
# set dynamic select choices
form.supplier.choices = forms.get_supplier_choices()
form.product.choices = forms.get_product_choices()
form.source.choices = forms.get_source_choices()
if request.form:
# update procurement details
if request.method == 'POST' and form.validate():
procurement = self.populate_procurement_from_form(procurement, form)
db.session.add(procurement)
db.session.commit()
flash("The details were updated successfully.", "success")
if request.args.get('host_url'):
target = get_redirect_target(param_name="host_url")
return redirect(HOST + target)
return redirect(url_for('.index_view'))
else:
# set field values that weren't picked up automatically
form.product.process_data(procurement.product_id)
form.country.process_data(procurement.country_id)
form.currency.process_data(procurement.currency_id)
form.incoterm.process_data(procurement.incoterm_id)
form.supplier.process_data(procurement.supplier_id)
form.source.process_data(procurement.source_id)
return self.render('admin/procurement.html', procurement=procurement, form=form, title="Edit procurement record", API_HOST=API_HOST)
def post(self, key):
try:
server_key = ndb.Key(urlsafe=key)
server = server_key.get()
if server is None:
self.abort(404)
form = ServerPropertiesForm(formdata=self.request.POST, server=server)
if form.validate():
if set_form_short_name(server, form):
server.is_gce = True
server.name = form.name.data
server.version = form.version.data
server.memory = form.memory.data
server.operator = form.operator.data or None
server.idle_timeout = form.idle_timeout.data
server.put()
mc_properties = server.mc_properties
for prop in form:
if prop.name not in ['name', 'version', 'memory', 'operator', 'idle_timeout']:
if prop.name == 'server_port':
if prop.data is not None:
setattr(mc_properties, prop.name, int(prop.data))
else:
setattr(mc_properties, prop.name, None)
elif prop.type == 'IntegerField' or prop.name in [
'gamemode', 'difficulty', 'op_permission_level'
]:
setattr(mc_properties, prop.name, int(prop.data))
else:
setattr(mc_properties, prop.name, prop.data)
mc_properties.put()
self.redirect(webapp2.uri_for('home', server_key=server.url_key))
except Exception, e:
logging.error(u"Error POSTing GCE server: {0}".format(e))
self.abort(404)
def post(self):
next_url = self.request.params.get('next_url', webapp2.uri_for('user_profile'))
form = UsernameClaimForm(self.request.POST)
if form.validate():
username = form.username.data
password = form.password.data
try:
u, uuid, access_token = mojang_authentication(username, password)
if u:
user = self.request.user
auth_id = User.get_mojang_auth_id(uuid=uuid)
existing_user = self.auth.store.user_model.get_by_auth_id(auth_id)
if existing_user is not None and user.key != existing_user.key:
user.merge(existing_user)
existing_user = User.lookup(username=u)
if existing_user is not None and user.key != existing_user.key:
user.merge(existing_user)
else:
user.add_username(u)
auth_id = User.get_mojang_auth_id(uuid=uuid)
user.add_auth_id(auth_id)
user.put()
except MojangException as me:
message = u'Mojang authentication failed (Reason: {0}).'.format(me)
logging.error(message)
self.session.add_flash(message, level='error')
self.redirect(next_url)
def post(self):
try:
form = ServerPropertiesForm(formdata=self.request.POST)
if form.validate():
server = Server.create(
name=form.name.data,
is_gce=True,
version=form.version.data,
memory=form.memory.data,
operator=form.operator.data or None,
idle_timeout=form.idle_timeout.data
)
mc_properties = server.mc_properties
for prop in form:
if prop.name not in ['name', 'version', 'memory', 'operator', 'idle_timeout']:
if prop.type == 'IntegerField' or prop.name in [
'gamemode', 'difficulty', 'op_permission_level'
]:
if prop.data is not None:
setattr(mc_properties, prop.name, int(prop.data))
else:
setattr(mc_properties, prop.name, prop.data)
mc_properties.put()
if not set_form_short_name(server, form):
message = "Short name '{0}' is already assigned to another world".format(form.short_name.data)
self.session.add_flash(message, level='warn')
self.redirect(webapp2.uri_for('home', server_key=server.url_key))
except Exception, e:
logging.error(u"Error POSTing GCE server: {0}".format(e))
self.abort(404)
def post(self, key=None):
server = self.get_server_by_key(key, abort=False)
if server is None:
self.redirect_to_server('home')
return
try:
form = CommandForm(self.request.POST)
if form.validate():
command = form.command.data
username = self.request.user.get_server_play_name(server.key)
if command and command.startswith(u'/say '):
if len(command) <= 5:
command = None
elif username:
command = u"/say <{0}> {1}".format(username, command[5:])
if command:
Command.push(server.key, username, command)
message = u'Command "{0}" sent to world "{1}".'.format(command, server.name)
logging.info(message)
self.session.add_flash(message, level='info')
time.sleep(1)
except Exception, e:
message = u'Command "{0}" could not be send to world "{1}" (Reason: {2}).'.format(command, server.name, e)
logging.error(message)
self.session.add_flash(message, level='error')
def post(self, key):
try:
server_key = ndb.Key(urlsafe=key)
server = server_key.get()
if server is None:
self.abort(404)
if not server.is_gce:
self.redirect(webapp2.uri_for('home', server_key=server.url_key))
form = ServerRestoreForm(
formdata=self.request.POST,
versions=gcs.get_versions(server.key.urlsafe()),
timezone=self.request.user.timezone
)
if form.validate():
gcs.restore_generation(server.key.urlsafe(), form.generation.data)
name = None
for choice in form.generation.choices:
if choice[0] == form.generation.data:
name = choice[1]
break
message = u"Saved game restored."
if name:
message = u"Saved game {0} restored.".format(name)
logging.info(message)
self.session.add_flash(message, level='info')
time.sleep(1)
self.redirect(webapp2.uri_for('home', server_key=server.url_key))
except Exception, e:
message = "Problem restoring game: {0}".format(e)
logging.error(message)
self.session.add_flash(message, level='error')
def register_view(self):
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate():
user = Users()
user.username = form.username.data
user.email = form.email.data
user.roles = ','.join(form.role.data)
# we hash the users password to avoid saving it as plaintext in the db,
# remove to use plain text:
user.password = generate_password_hash(form.password.data)
Session.add(user)
Session.commit()
login.login_user(user)
flash('Thanks for registering')
return redirect(url_for('.index'))
link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
form_roles = []
roles = Session.query(Role).all()
for role in roles:
form_roles.append((role.key, role.name))
form.role.choices = form_roles
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def register():
form = RegistrationForm(request.form)
#si el usuario esta registrado guardamos los datos
if request.method == 'POST' and form.validate() and ('username' in session):
#guardamos los datos nuevos o editados
form.databasesMongoUpdate(conn,session['username'])
#por si cambia el nombre de usuario
session['username']=form.username.data
#conn.insertData(form)
return render_template('perfil.html',usuario=form.username.data,form=form)
elif request.method == 'POST' and form.validate():
#grabamos los datos
form.databasesMongo(conn)
return render_template('hijo.html',usuario=form.username.data)
#devolvemos la pagina de registro
return render_template('register.html',form=form)
def login_view():
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
user = form.get_user()
login.login_user(user)
return redirect(url_for('index'))
return render_template('form.html', form=form)
def login_view():
form = LoginForm(request.form)
if request.method == "POST" and form.validate():
user = form.get_user()
login.login_user(user)
return redirect(url_for("index"))
return render_template("form.html", form=form)
def login():
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
# login and validate the user...
user = form.get_user()
login_user(user)
flash("Logged in successfully.")
return redirect(url_for("search"))
return render_template("login.html", form=form)
def profile(context, request):
form = ProfileForm(request.POST)
if request.method == 'POST' and form.validate():
profile = request.user.profile = form.profile.data
rev = UserProfileRevision(user=request.user, updated_by=request.user,
content=profile)
model.session.add(rev)
return {}
def loginaction() :
# handle user login
form = LoginForm(request.form)
if request.method == 'POST' and form.validate() :
user = form.get_user()
if login.login_user(user) :
session['user'] = user.login
print("User %s logged in successfully."%user.login)
return redirect(request.args.get('next') or url_for('vendor_page.index'))
return render_template('login.html', form=form)
def index(self):
if request.method == 'POST':
form = ProfileForm(request.form)
else:
form = ProfileForm()
form.title.data = Setting.query.filter_by(name='folio_title').first()
if request.method == 'POST' and form.validate():
flash('Your data has been saved successfully.', 'success')
return self.render('admin/profile.html', form=form)
def contact():
form = ContactForm()
if request.method == "POST":
if form.validate() == False:
flash("All fields are required.")
return render_template("contact.html", form=form)
else:
return "Form posted."
elif request.method == "GET":
return render_template("contact.html", form=form)
def register_view():
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate():
user = User()
form.populate_obj(user)
user.save()
login.login_user(user)
return redirect(url_for('index'))
return render_template('form.html', form=form)
def register_view():
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate():
user = User()
form.populate_obj(user)
user.save()
login.login_user(user)
return redirect(url_for('index'))
return render_template('form.html', form=form)
def login_view(self):
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
user = form.get_user()
login_user(user)
if current_user.is_authenticated:
return redirect(url_for('.index'))
link = '<p>Don\'t have an account? <a href="' + url_for(
'.register_view') + '">Click here to register.</a></p>'
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def post(self):
try:
form = ServerForm(formdata=self.request.POST)
if form.validate():
server = Server.create(name=form.name.data, is_gce=False)
if not set_form_short_name(server, form):
message = "Short name '{0}' is already assigned to another world".format(form.short_name.data)
self.session.add_flash(message, level='warn')
self.redirect(webapp2.uri_for('home', server_key=server.url_key))
except Exception, e:
logging.error(u"Error POSTing server: {0}".format(e))
self.abort(404)
def test_entry_form_with_obj(self):
form = EntryForm(obj=self.entry_a1)
self.assertEqual(
form.data,
{"title": "a1", "content": "a1 content", "pub_date": datetime.datetime(2011, 1, 1), "blog": self.blog_a},
)
self.assertTrue(form.validate())
# check that the options look right
self.assertEqual(
list(form.blog.iter_choices()), [(self.blog_a.get_id(), u"a", True), (self.blog_b.get_id(), u"b", False)]
)
def test_non_int_pk(self):
form = NonIntPKForm()
self.assertEqual(form.data, {"value": None, "id": None})
self.assertFalse(form.validate())
obj = NonIntPKModel(id="a", value="A")
form = NonIntPKForm(obj=obj)
self.assertEqual(form.data, {"value": "A", "id": "a"})
self.assertTrue(form.validate())
form = NonIntPKForm(FakePost({"id": "b", "value": "B"}))
self.assertTrue(form.validate())
obj = NonIntPKModel()
form.populate_obj(obj)
self.assertEqual(obj.id, "b")
self.assertEqual(obj.value, "B")
self.assertEqual(NonIntPKModel.select().count(), 0)
obj.save(True)
self.assertEqual(NonIntPKModel.select().count(), 1)
def test_non_int_pk(self):
form = NonIntPKForm()
self.assertEqual(form.data, {'value': None, 'id': None})
self.assertFalse(form.validate())
obj = NonIntPKModel(id='a', value='A')
form = NonIntPKForm(obj=obj)
self.assertEqual(form.data, {'value': 'A', 'id': 'a'})
self.assertTrue(form.validate())
form = NonIntPKForm(FakePost({'id': 'b', 'value': 'B'}))
self.assertTrue(form.validate())
obj = NonIntPKModel()
form.populate_obj(obj)
self.assertEqual(obj.id, 'b')
self.assertEqual(obj.value, 'B')
self.assertEqual(NonIntPKModel.select().count(), 0)
obj.save(True)
self.assertEqual(NonIntPKModel.select().count(), 1)
def forget_password_request():
form = EmailForm(request.form)
if request.method == 'POST':
if form.validate():
account_email = form.email.data
user = User.query.filter_by(email=account_email).first_or_404()
send_mail(form.email.data,
'重置你的密码',
'email/reset_password.html',
user=user,
token=user.generate_token())
flash("一封邮件已经发送至您的邮箱" + account_email + "，请及时查收！")
return render_template('auth/forget_password_request.html', form=form)
def login():
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
user = User.query.filter_by(email=form.email.data).first()
if user and user.check_password(form.password.data):
login_user(user, remember=True)
nexturl = request.args.get('next')
if not nexturl or not nexturl.startswith('/'):
nexturl = url_for('web.index')
return redirect(nexturl)
else:
flash('账号不存在或者密码错误！')
return render_template('auth/login.html', form=form)
def test_exclusive_minmax():
field = NumberParameters.from_json_field('test', True, {
"type": "integer",
"exclusiveMinimum": 2,
"exclusiveMaximum": 15
})
constraints = field.get_options()
hamcrest.assert_that(
constraints,
hamcrest.has_entries({
'validators':
hamcrest.contains_exactly(
hamcrest.instance_of(wtforms.validators.DataRequired),
hamcrest.instance_of(
jsonschema_wtforms.validators.NumberRange))
}))
assert field.required is True
assert field.get_factory() == wtforms.fields.IntegerField
form = wtforms.form.BaseForm({"test": field()})
form.process(data={'test': 1})
assert form.validate() is False
assert form.errors == {'test': ['Number must be over 2.']}
form.process(data={'test': 2})
assert form.validate() is False
assert form.errors == {'test': ['Number must be over 2.']}
form.process(data={'test': 16})
assert form.validate() is False
assert form.errors == {'test': ['Number must be under 15.']}
form.process(data={'test': 15})
assert form.validate() is False
assert form.errors == {'test': ['Number must be under 15.']}
form.process(data={'test': 10})
assert form.validate() is True
assert not form.errors
def dashboard():
form = AddEventForm(request.form)
if request.method == 'POST' and form.validate():
event_name = form.name.data
event_date = str(form.date.data)
engine.execute('INSERT INTO events (name, date, userid) VALUES (%s, %s, %s);',
(event_name, event_date, g.user.id))
return redirect(url_for('.dashboard'))
db_events = engine.execute('SELECT name, id, date FROM events WHERE userid = %s', (g.user.id,)).fetchall()
context = {
'events': db_events
}
return render_template("dashboard.html", form=form, **context)
def update_todolist():
form = UpdateTodolistForm(request.form)
if request.method != 'POST':
abort(405)
if request.method == 'POST' and form.validate():
if not (engine.execute('SELECT userid FROM events WHERE id = %s',
(form.eventid.data,)).fetchone()['userid'] == g.user.id):
abort(403)
engine.execute('UPDATE todolist SET eventid = %s, item = %s, completed = %s WHERE id=%s;',
(form.eventid.data, form.item.data,form.completed.data, form.todolistid.data))
return redirect(url_for('.todolists', event_id=form.eventid.data))
def post(self):
form = InstanceForm(self.request.POST)
if form.validate():
instance = gce.Instance.singleton()
instance.zone = form.zone.data
instance.machine_type = form.machine_type.data
instance.disk_size = form.disk_size.data
instance.backup_depth = form.backup_depth.data
instance.reserved_ip = form.reserved_ip.data
instance.put()
self.redirect(webapp2.uri_for('admin'))
context = {'form': form, 'instance': instance}
self.render_template('instance_configure.html', context=context)
def add_article():
form = ArticleForm(request.form)
if request.method == 'POST' and form.validate():
title = form.title.data
body = form.body.data
#create cursor
cur = mysql.connection.cursor()
cur.execute("INSERT INTO articles(title, body, author) VALUES(%s, %s, %s)", (title,body,session['username']))
mysql.connection.commit()
cur.close()
flash ('Article Created', 'success')
return redirect(url_for('dashboard'))
return render_template('templates/add_article.html', form=form)
def test_enum():
field = StringParameters.from_json_field('test', True, {
"type": "string",
"enum": ['foo', 'bar']
})
constraints = field.get_options()
hamcrest.assert_that(constraints, hamcrest.has_entries({
'validators': hamcrest.contains_exactly(
hamcrest.instance_of(wtforms.validators.DataRequired),
),
}))
assert field.required is True
assert field.get_factory() == wtforms.fields.SelectField
form = wtforms.form.BaseForm({"test": field()})
form.process(data={'test': 'Dagger'})
assert form.validate() is False
assert form.errors == {'test': ['Not a valid choice.']}
form.process(data={'test': 'foo'})
assert form.validate() is True
assert not form.errors
def register():
form = RegistrationForm(request.form)
#si el usuario esta registrado guardamos los datos
if request.method == 'POST' and form.validate() and ('username'
in session):
#guardamos los datos nuevos o editados
form.databasesMongoUpdate(conn, session['username'])
#por si cambia el nombre de usuario
session['username'] = form.username.data
#conn.insertData(form)
return render_template('perfil.html',
usuario=form.username.data,
form=form)
elif request.method == 'POST' and form.validate():
#grabamos los datos
if (conn.getUserData(form.username.data)) == True:
form.databasesMongo(conn)
return render_template('hijo.html', usuario=form.username.data)
else:
return render_template('errorRegister.html', usuario=None)
#devolvemos la pagina de registro
return render_template('register.html', form=form)
def forget_password_request():
form = EmailForm(request.form)
if request.method == 'POST':
if form.validate():
account_email = form.email.data
user = User.query.filter_by(email=account_email).first_or_404()
from app.libs.email import send_mail
send_mail(form.email.data,
'重置你的密码',
'email/reset_password.html',
user=user,
token=user.generate_token())
return redirect(url_for('web.index'))
return render_template('auth/forget_password_request.html', form=form)
def test_entry_form_with_obj(self):
form = EntryForm(obj=self.entry_a1)
self.assertEqual(form.data, {
'title': 'a1',
'content': 'a1 content',
'pub_date': datetime.datetime(2011, 1, 1),
'blog': self.blog_a,
})
self.assertTrue(form.validate())
# check that the options look right
self.assertEqual(list(form.blog.iter_choices()), [
(self.blog_a.get_id(), u'a', True), (self.blog_b.get_id(), u'b', False)
])
def test_hidden_field_none(self):
class TestNullEntryForm(WTForm):
blog = HiddenQueryField(query=Blog.select())
form = TestNullEntryForm(FakePost({
'blog': '',
}))
# check the htmlz for the form's hidden field
html = form._fields['blog']()
self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="">')
self.assertTrue(form.validate())
self.assertEqual(form.blog.data, None)
entry = NullEntry()
form.populate_obj(entry)
# ensure entry count hasn't changed
self.assertEqual(NullEntry.select().count(), 0)
entry.save()
self.assertEqual(NullEntry.select().count(), 1)
# make sure the blog object came through ok
self.assertEqual(entry.blog, None)
# edit entry a1
form = TestNullEntryForm(FakePost({
'blog': None,
}), obj=self.entry_a1)
# check the htmlz for the form's hidden field
html = form._fields['blog']()
self.assertEqual(html, u'<input id="blog" name="blog" type="hidden" value="">')
self.assertTrue(form.validate())
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
with db.auto_commit():
user = User()
user.set_attrs(form.data)
# user.password = generate_password_hash(form.password.data)
# user.nickname = form.nickname.data
# user.email = form.email.data
# user.password = form.password.data
db.session.add(user)
return redirect(url_for('web.login'))
return render_template('auth/register.html', form=form)
def changepass():
token = request.args.get('token', None)
user = None
if token is not None:
user = User.verify_token(token)
if token is None or user is None:
return redirect(url_for("resetpass"))
form = ChangePasswordForm(request.form)
if request.method == "POST" and form.validate():
user.password = hash_password(form.password.data)
db.session.commit()
return redirect(url_for("login"))
else:
return render_template("change_pass.html", form=form)
def login():
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
member_data = members.find_one({'name': form.name.data})
#validation stuff
# member returns dictionary of collection info
if not member_data == None:
user = member_from_dict(Member, member_data)
login_user(user)
flash(f"Logged in as {user['name']}")
return redirect('/')
# No result from member collection
flash("That username doesn't exist")
return redirect('/login')
return render_template('form.html', form=form)
def register_view(self):
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate():
user = User()
form.populate_obj(user)
user["password"] = bcrypt.generate_password_hash(user["password"]).decode('utf-8')
user.save()
login_user(user)
return redirect(url_for('.index'))
self._template_args['form'] = form
self._template_args['active'] = "Register"
self._template_args['intro'] = ""
self._template_args['link'] = '*Please do not enter a used username or password<p><p>Login? <a href="{}">Click here</a></p>'.format(url_for('.login_view'))
return super(CustomAdminIndexView, self).index()
def remove_tags(artwork, request):
form = RemoveTagForm(request.POST, artwork=artwork)
if not form.validate():
# FIXME when the final UI is figured out
return HTTPBadRequest()
for tag in form.tags.data:
artwork.tags.remove(tag)
if len(form.tags.data) == 1:
request.session.flash(u"Tag \"{0}\" has been removed".format(tag))
else:
request.session.flash(u"Tags have been removed")
return HTTPSeeOther(location=request.route_url('art.view', artwork=artwork))
def edit_patient(id):
# Create cursor
cur = mysql.connection.cursor()
# Get article by id
result = cur.execute("SELECT * FROM PatientList WHERE id = %s", [id])
article = cur.fetchone()
cur.close()
# Get form
form = PatientForm(request.form)
# Populate article form fields
form.PatientName.data = article['PatientName']
form.Address.data = article['Address']
form.ServID.data = article['ServID']
form.Price.data = article['Price']
if request.method == 'POST' and form.validate():
PatientName = str(request.form['PatientName'])
Address = str(request.form['Address'])
ServID = str(request.form['ServID'])
Price = str(request.form['Price'])
# Create Cursor
cur = mysql.connection.cursor()
app.logger.info(PatientName)
# Execute
cur.execute(
"UPDATE Patient SET PatientName=%s , Address=%s , ServID=%s,Price=%s WHERE id=%s",
(PatientName, Address, ServID, Price, id))
# Commit to DBDoctors/Doctor/MDetails?id=' + $('#vpatid').val()
mysql.connection.commit()
#Close connection
cur.close()
flash('Patient Updated', 'success')
return redirect(url_for('patient'))
cur = mysql.connection.cursor()
result = cur.execute("SELECT ID , ServName FROM ServList")
serv = cur.fetchall()
app.logger.info(type(serv))
app.logger.info(serv)
app.logger.info(serv[0]['ServName'])
return render_template('edit_patient.html', form=form)
def login_view(self):
# handle user login
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
user = form.get_user()
if user != None:
login_user(user)
if current_user.is_authenticated:
return redirect(request.args.get('next') or url_for('.index'))
self._template_args['form'] = form
self._template_args['active'] = "Login"
self._template_args['intro'] = ""
self._template_args['link'] = '<p>Register? <a href="{}">Click here</a></p>'.format(url_for('.register_view'))
return super(CustomAdminIndexView, self).index()
def addarticle():
form = ArticleForm(request.form)
if request.method == "POST" and form.validate():
title = form.title.data
content = form.content.data
cursor = mysql.connection.cursor()
sorgu = "Insert into articles(title,author,content) VALUES(%s,%s,%s)"
cursor.execute(sorgu, (title, session["username"], content))
mysql.connection.commit()
cursor.close()
flash("Makale Başarıyla Eklendi", "success")
return redirect(url_for("dashboard"))
return render_template("addarticle.html", form=form)
def remove_tags(artwork, request):
form = RemoveTagForm(request.POST, artwork=artwork)
if not form.validate():
# FIXME when the final UI is figured out
return HTTPBadRequest()
for tag in form.tags.data:
artwork.tags.remove(tag)
if len(form.tags.data) == 1:
request.session.flash(u"Tag \"{0}\" has been removed".format(tag))
else:
request.session.flash(u"Tags have been removed")
return HTTPSeeOther(
location=request.route_url('art.view', artwork=artwork))
def register_view(self):
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate():
user = User()
user.login = form.login.data
user.email = form.email.data
user.password = generate_password_hash(form.password.data)
db.session.add(user)
db.session.commit()
login_user(user)
return redirect(url_for('.index'))
link = '<p>Already have an account? <a href="' + url_for(
'.login_view') + '">Click here to log in.</a></p>'
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def register():
form = RegisterForm(request.form)
if request.method == "POST" and form.validate():
try:
user = User()
user.set_attrs(form.data)
db.session.add(user)
db.session.commit()
login_user(user, False)
except Exception as e:
db.session.rollback()
raise e
return redirect(url_for('web.index'))
return render_template('register.html', form=form)
def notes(event_id):
event = engine.execute('SELECT * FROM events WHERE id = %s', (int(event_id),)).fetchone()
notes = engine.execute('SELECT * FROM notepad WHERE eventid = %s', (int(event_id),)).fetchall()
if not (event['userid'] == g.user.id):
abort(403)
form = AddNoteForm(request.form)
if request.method == 'POST' and form.validate():
event_name = form.name.data
engine.execute('INSERT INTO notepad (name, eventid) VALUES (%s, %s);',
(event_name, event_id))
return redirect(url_for('.notes', event_id=event_id))
context = {
'event': event,
'notes': notes
}
return render_template('notes.html', **context)
def post(self):
user = self.user
if user and not user.active:
form = UserEmailForm(self.request.POST, user)
if form.validate():
user.email = form.email.data
user.put()
self.redirect(webapp2.uri_for('main'))
context = {
'title': main_config.TITLE,
'description': main_config.DESCRIPTION,
'form': form
}
self.render_template('main_inactive.html', context=context)
else:
self.redirect(webapp2.uri_for('main'))
def login_view(self):
try:
# handle user login
form = LoginForm(request.form)
if request.method == 'POST':
if form.validate():
user = form.get_user()
login.login_user(user)
if login.current_user.is_authenticated:
return redirect(url_for('.index'))
except validators.ValidationError as error:
flash(str(error))
self._template_args['form'] = form
return super(BaobabAdminIndexView, self).index()
def send_drift(gid):
current_gift = Gift.query.first_or_404()
if current_gift.is_yourself_gift(current_user.id):
flash('这本书是你自己的，不能像自己索要书籍哦')
return redirect(url_for('web.book_detail', isbn=current_gift.isbn))
can = current_user.can_send_drift()
if not can:
return render_template('not_enough_beans.html', beans=current_user.beans)
form = DriftForm(request.form)
if request.method == 'POST' and form.validate():
save_drift(form, current_gift)
send_mail(current_gift.user.email, '有人想要一本书', 'email/get_gift.html',
wisher=current_user,
gift=current_gift)
return redirect(url_for('web.pending'))
gifter = current_gift.user.summary
return render_template('drift.html', gifter=gifter, user_beans=current_user.beans, form=form)
def login_view(self):
# handle user login
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
user = form.get_user()
if user is not None:
if user and utils.verify_password(form.password.data, user.password):
login.login_user(user)
flash("Logged in successfully!", category='success')
return redirect(url_for('admin.index'))
flash("Wrong username or password!", category='error')
if login.current_user.is_authenticated:
return redirect(url_for('.index'))
link = '<p>Don\'t have an account? Too bad... </p>'
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def login_begin(context, request):
"""Step one of logging in with OpenID; redirect to the provider."""
form = LoginForm(request.POST)
if not form.validate():
return {'form': form}
# Ensure the return key, if present and valid, will be passed
# to openid_finish()
return_url = request.route_url('account.login_finish')
if form.return_key.data in get_stash_keys(request):
return_url = update_params(return_url,
return_key=form.return_key.data)
if request.user:
# Logged-in user trying to update their OpenID expiry time
sreg = False
settings = request.registry.settings
max_auth_age = settings.get('auth.openid.expiry_seconds',
DEFAULT_CONFIDENCE_EXPIRY)
else:
# Someone either logging in or registering
# Problem is that we don't want sreg (as part of opeinid_begin) unless
# the user is registering, but we don't know whether the user is
# registering or just logging in until we resolve their identity URL...
# which we do in openid_begin.
# Possibly use checkid_immediate instead
sreg = True
max_auth_age = False
try:
return HTTPSeeOther(location=openid_begin(
identifier=form.openid_identifier.data,
return_url=return_url,
request=request,
max_auth_age=max_auth_age,
sreg=sreg))
except OpenIDError as exc:
request.session.flash(exc.message,
level='error', icon='key--exclamation')
return {'form': form}