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 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 flatten_json(form,
json,
parent_key='',
separator='-',
skip_unknown_keys=True):
"""Flattens given JSON dict to cope with WTForms dict structure.
:param form: WTForms Form object
:param json: json to be converted into flat WTForms style dict
:param parent_key: this argument is used internally be recursive calls
:param separator: default separator
:param skip_unknown_keys:
if True unknown keys will be skipped, if False throws InvalidData
exception whenever unknown key is encountered
Examples::
>>> flatten_json(MyForm, {'a': {'b': 'c'}})
{'a-b': 'c'}
"""
if not isinstance(json, collections.abc.Mapping):
raise InvalidData(
u'This function only accepts dict-like data structures.')
items = []
for key, value in json.items():
try:
unbound_field = getattr(form, key)
except AttributeError:
if skip_unknown_keys:
continue
else:
raise InvalidData(u"Unknown field name '%s'." % key)
try:
field_class = unbound_field.field_class
except AttributeError:
if skip_unknown_keys:
continue
else:
raise InvalidData(u"Key '%s' is not valid field class." % key)
new_key = parent_key + separator + key if parent_key else key
if isinstance(value, collections.abc.MutableMapping) and issubclass(
field_class, FormField):
nested_form_class = unbound_field.bind(Form(), '').form_class
items.extend(
flatten_json(nested_form_class, value, new_key).items())
elif (isinstance(value, collections.abc.MutableMapping)
or isinstance(value, list)
and not issubclass(field_class, FieldList)
or not isinstance(value, list)):
items.append((new_key, value))
else:
nested_unbound_field = unbound_field.bind(Form(), '').unbound_field
items.extend(
flatten_json_list(nested_unbound_field, value, new_key,
separator))
return dict(items)
def index():
protocol = os.getenv('PROTOCOL')
form = Form(request.form)
script = ""
div = ""
if request.method == 'POST':
keyword = request.form['keyword']
num_tweets = request.form['num_tweets']
since = request.form['since']
until = request.form['until']
tweet = Tweet(app)
list_of_tweets = tweet.get_list_of_tweets(keyword, since, until,
num_tweets)
nodes = tweet.get_nodes(list_of_tweets)
edges = tweet.get_edges(list_of_tweets)
# plot = renders_bokeh.render_custom_graph(nodes, edges)
plot = renders_bokeh.render_from_fb_combined()
script, div = components(plot)
return render_template("index.html",
form=form,
script=script,
div=div,
protocol=protocol)
def reviews(names=bus_name_list, ids=bus_id_list):
"""
Load the Riffle page and populate the variables used on the site
"""
session_init()
form = Form(request.form)
print request.form.getlist("business")
try:
bus_list = request.form.getlist("business")
bus_ids = [ids[names.index(x)] for x in bus_list]
except:
bus_list = ['Bellagio Hotel']
bus_ids = [ids[names.index(bus_list[0])]]
# Pull the list of Business Names and IDs
try:
session['www_tups'] = bus_data(bus_ids)
except:
print "There was an error!"
session['vis'] = 0
print session['www_tups']
return render_template('reviews.html', form=form, data=session['www_tups'],
bus_names=names, default_bus=bus_list,
vis=session['vis'])
def table(database,table):
global new_table
if new_table == None:
new_table = client.getDataBaseByName(database).getTable(table)
if request.method == 'POST':
if request.form['submit_button'] == 'Back':
new_table = None
return redirect(url_for('database',database=database))
elif request.form['submit_button'] == 'Save':
for i,row in enumerate(new_table.rows):
for j,cell in enumerate(row):
if str(i)+'.'+str(j) in request.form:
cell.data = request.form[str(i)+'.'+str(j)]
client.updateTable(database,table,new_table)
new_table = None
return redirect(url_for('database',database=database))
elif request.form['submit_button'] == 'Add row':
for i,row in enumerate(new_table.rows):
for j,cell in enumerate(row):
cell.data = request.form[str(i)+'.'+str(j)]
row = []
for column in new_table.columns:
cell = Cell()
cell.type = column.type
cell.optionalInfo = column.optionalInfo
row.append(cell)
new_table.rows.append(row)
print(new_table.__dict__)
form = Form(request.form)
form.table = new_table
return render_template('table.html',form=form)
def setUp(self):
self.form = Form()
with override_current_time(datetime.datetime(2015, 2, 11, 23, 3)):
field = TimeChoiceField(choices_callback=OPERATOR_HOURS.time_slots,
validators=[InputRequired()])
self.field = field.bind(self.form, "a")
self.field.process(None)
def predict():
if not current_user.is_authenticated:
#print(request.path)
return redirect(url_for('auth.login', messages=request.path))
#return redirect(url_for('auth.login'))
form = Form()
form.region.choices = [(region.id, region.name) for region in Region.query.all()]
form.region.default = '1'
if request.method == 'POST':
emplacement = Emplacement.query.filter_by(id=form.emplacement.data).first()
region = Region.query.filter_by(id=form.region.data).first()
municipality = Municipality.query.filter_by(id=form.municipality.data).first()
area = int(form.area.data)
roomNumber = int(form.roomNumber.data)
emp = emplacement.id
int_features = [emp, roomNumber, area]
final = np.array(transf(int_features)).reshape(-1, 59)
print("**" , final)
final[:,57:] = sc_X.transform(final[:,57:])
print("**" , final)
prediction = model.predict(final)
return render_template('price.html',price=round(prediction[0], 2))
return render_template('predict.html', form=form)
def index():
cwd1 = os.getcwd()
cwd2 = cwd1[0:-9]
name = None
email = None
#sequence = None
form = Form()
if form.validate_on_submit():
name = form.name.data
surname = form.surname.data
email = form.email.data
#sequence = form.sequence.data
database = form.database.data
#write_to_disk(name,surname, email)
filename = secure_filename(form.file.data.filename)
form.file.data.save("/var/www/html/Web-BLCA/mainLoop/" + filename)
open("/var/www/html/Web-BLCA/mainLoop/seqfile.fasta", "w+").write(database+"\n")
open("/var/www/html/Web-BLCA/mainLoop/preq.txt", "a").write(name + "\n" + email + "\n" + filename + "\n" + database+"\n")
form.name.data = ''
form.email.data = ''
#form.sequence.data = ''
form.surname.data = form.database.data = ''
flash("Thank you! Your Job has been submitted!", "success")
return render_template('home.html', form=form)
def register():
form = Form(request.form)
if request.method == 'GET':
return render_template('register.html')
if request.method == 'POST' or form.validate():
users = mongo.db.users
username = request.form['username']
firstname = request.form['firstname']
lastname = request.form['lastname']
birthdate = request.form['birthdate']
email = request.form['email']
password = bcrypt.hashpw(request.form['password'].encode('utf-8'),
bcrypt.gensalt())
if not users.find_one({'username': username}) or not users.find_one(
{'email': email}):
users.insert_one({
'firstname': firstname,
'lastname': lastname,
'username': username,
'birthdate': birthdate,
'email': email,
'password': password
})
return render_template('index.html')
def index():
form = Form()
if request.method == 'POST':
if form.validate_on_submit():
details = request.form
Emal = form.Email, sex = form.sex, age = form.age,
Marital = form.Marital, county = form.county,
Property = form.Property, PropertyStatus = form.PropertyStatus,
AmountPaid = form.AmountPaid, Rooms = form.Rooms,
People = form.People
db(
"INSERT INTO survey(Email, sex, age, Marital, county, Property, PropertyStatus, AmountPaid, Rooms, People) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)",
(Email, sex, age, Marital, county, Property, PropertyStatus,
AmountPaid, Rooms, People))
# db.connection.commit()
#cursor = db.cursor()
# db.close()
flash(u'Something went wrong!', 'success')
else:
flash(u'Thank you for your collaboration!', 'error')
return redirect(url_for('index'))
return render_template('index1.html', form=form)
def test_email_validator(self):
form = Form()
field = EmailField()
message = u"Email incorrect."
validator = EmailValidator(message=message)
field.data = "emailwithspace @example.com"
self.assertRaises(ValidationError, validator, form, field)
field.data = " [email protected]"
self.assertRaises(ValidationError, validator, form, field)
field.data = "email [email protected]"
self.assertRaises(ValidationError, validator, form, field)
field.data = "emailwithspace@ example.com"
self.assertRaises(ValidationError, validator, form, field)
field.data = "[email protected] "
self.assertRaises(ValidationError, validator, form, field)
field.data = "emailwith,[email protected]"
self.assertRaises(ValidationError, validator, form, field)
field.data = "*****@*****.**"
try:
validator(form, field)
except ValidationError:
self.fail(u"%s should not raise email validation error" %
field.data)
def zones():
name = TextField('Name:', validators=[validators.required()])
form = Form()
test = None
if request.method == 'POST':
name = request.form['name']
test = zonenames.convert(name)
return render_template("zones.html", form=form, name=name, test=test)
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_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 __init__(self):
"""Define self templates."""
self.template_list = self.template_list or self.app.ps.admin.cfg.template_list
self.template_item = self.template_item or self.app.ps.admin.cfg.template_item
# Prepare filters
self.columns_filters = list(map(self.filters_converter, self.columns_filters))
self.filter_form = Form(prefix=FILTERS_PREFIX)
for flt in self.columns_filters:
flt.bind(self.filter_form)
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 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 test_should_preserve_password_on_edition(self, app, db_session):
# given
user = User()
user.password = "******"
view = PartnerUserView(model=User, session=db_session)
# when
view.on_model_change(Form(), model=user, is_created=False)
# then
assert user.password == "OriginalPassword"
def test_a_partner_should_never_be_a_beneficiary(self, app, db_session):
# given
user = User()
user.add_beneficiary_role()
view = PartnerUserView(model=User, session=db_session)
# when
view.on_model_change(Form(), model=user, is_created=False)
# then
assert not user.has_beneficiary_role
def test_should_generate_a_random_password_on_creation(self, app, db_session):
# given
user = User()
user.password = None
view = PartnerUserView(model=User, session=db_session)
# when
view.on_model_change(Form(), model=user, is_created=True)
# then
assert user.password is not None
def flatten_json_list(field, json, parent_key='', separator='-'):
items = []
for i, item in enumerate(json):
new_key = parent_key + separator + str(i)
if (isinstance(item, dict)
and issubclass(getattr(field, 'field_class'), FormField)):
nested_class = field.field_class(*field.args, **field.kwargs).bind(
Form(), '').form_class
items.extend(flatten_json(nested_class, item, new_key).items())
else:
items.append((new_key, item))
return items
def predict():
form = Form(request.form)
print(form.errors)
if request.method == 'POST':
num_lab_procedures = request.form['num_lab_procedures']
number_inpatient = request.form['number_inpatient']
num_medications = request.form['num_medications']
time_in_hospital = request.form['time_in_hospital']
number_diagnoses = request.form['number_diagnoses']
num_procedures = request.form['num_procedures']
number_emergency = request.form['number_emergency']
number_outpatient = request.form['number_outpatient']
Discharged_to_home = request.form['Discharged_to_home']
Dicshared_to_rehab_fac = request.form['Dicshared_to_rehab_fac']
gender_Male = request.form['gender_Male']
payer_code_MC = request.form['payer_code_MC']
diag_1_Circulatory_System = request.form['diag_1_Circulatory_System']
diag_2_Circulatory_System = request.form['diag_2_Circulatory_System']
diag_3_Circulatory_System = request.form['diag_3_Circulatory_System']
age_70_80 = request.form['age_70_80']
age_60_70 = request.form['age_60_70']
race_Caucasian = request.form['race_Caucasian']
change_med_no = request.form['change_med_no']
age_80_90 = request.form['age_80_90']
medical_specialty_InternalMedicine = request.form[
'medical_specialty_InternalMedicine']
admission_type_id_Emergency = request.form[
'admission_type_id_Emergency']
diag_3_External_Causes = request.form['diag_3_External_Causes']
insulin_no = request.form['insulin_no']
insulin_Steady = request.form['insulin_Steady']
if form.validate():
flash('Your patient is likely to be readmitted: ' + score([
num_lab_procedures, number_inpatient, num_medications,
time_in_hospital, number_diagnoses, num_procedures,
number_emergency, number_outpatient, Discharged_to_home,
Dicshared_to_rehab_fac, gender_Male, payer_code_MC,
diag_1_Circulatory_System, diag_2_Circulatory_System,
diag_3_Circulatory_System, age_70_80, age_60_70,
race_Caucasian, change_med_no, age_80_90,
medical_specialty_InternalMedicine,
admission_type_id_Emergency, diag_3_External_Causes,
insulin_no, insulin_Steady
]))
else:
flash('All the form fields are required. ')
return render_template('index.html',
form=form,
feature_form_settings=feature_form_settings)
def test_should_create_the_public_name(self, app, db_session):
# given
user = User()
user.firstName = "Ken"
user.lastName = "Thompson"
user.publicName = None
view = PartnerUserView(model=User, session=db_session)
# when
view.on_model_change(Form(), model=user, is_created=False)
# then
assert user.publicName == "Ken Thompson"
def newDatabase():
form = Form(request.form)
global new_database
if new_database == None:
new_database = DataBase()
if request.method == 'POST':
new_database.name = request.form['name']
client.saveDataBase(new_database)
new_database = None
return redirect('/')
form.database = new_database
return render_template('newdatabase.html', form=form)
def form_check(Form):
if request.method == "GET":
form = request.args
else:
form = request.form
form = Form(form)
if form.validate():
request.validate_form = form
return
for error_filed, error_message in form.errors.iteritems():
if isinstance(error_message, list) and error_message:
error_message = error_message[0]
return failed_resp("%s: %s" % (error_filed, error_message),
httplib.BAD_REQUEST)
def index():
form = Form()
# form.No.choices = [(No.No) for No in earthWork.query.all()]
form.Name_materials.choices = [(Name_materials.Name_materials) for Name_materials in earthWork.query.all()]
# form.Units.choices = [(Units.Units) for Units in earthWork.query.all()]
# form.Quantity.choices = [(Quantity.Quantity) for Quantity in earthWork.query.all()]
# form.Name_materials =
Units = 'kg'
# form.Quantity =
# print(dict(form.No.choices).get(form.No.data))
# result_dict = [u.__dict__ for u in earthWork.query.all()]
# print(result_dict["Name_materials"])
return render_template('index.html', form=form)
def main():
form = Form(request.form)
new_table = None
new_database = None
if request.method == 'POST':
if request.form['submit_button'] == 'Delete selected databases':
client.deleteDataBases(request.form.getlist('selected_databases'))
form.databases = client.getAllDataBases()
print(form.errors)
return render_template('main.html', form=form)
def database(database):
form = Form(request.form)
if request.method == 'POST':
if request.form['submit_button'] == "Merge selected tables":
new_table = None
client.mergeTables(database,request.form.getlist('selected_table'))
elif request.form['submit_button'] == "Delete selected tables":
client.deleteTables(database,request.form.getlist('selected_table'))
elif request.form['submit_button'] == "Back":
return redirect('/')
form.database = client.getDataBaseByName(database)
return render_template('database.html',form=form)
def contact():
form = Form(request.form)
if request.method == 'GET':
return render_template('contacts.html', contact="active", form=form)
else:
name = request.form['name']
organisation = request.form['organisation']
phone = request.form['phone']
email = request.form['email']
message = request.form['message']
control(name, organisation, phone, email, message)
return render_template('contacts.html',
contact="active",
form=form,
success=True)
