def settings():
form = SettingsForm()
if form.validate_on_submit():
device_choices = form.device.data
try:
for device in device_choices:
x = form.data
x['device'] = int(device)
# Record new data in MySQL
cur.execute("insert into flaskapp.device_settings (device_id, on_time, low_time, off_time, low, high, manual, created_on) values (%s,%s,%s,%s,%s,%s,%s,%s)", (device, request.form['on_time'], request.form['low_time'], request.form['off_time'], request.form['low'], request.form['high'], request.form['manual'], datetime.datetime.now(timezone('EST'))))
con.commit()
print('SQL Insert Success')
# Publish to MQTT Subscribers
client.publish(light_map(int(device)), json.dumps(x, default=to_serializable), qos=1)
client.publish('all_devices_monitor', json.dumps(x, default=to_serializable), qos=1)
except sql.Error as er:
con.rollback()
print("An error occurred: %".format(e.args[0]))
elif form.validate_on_submit() == False:
print(form.errors)
pass
if request.method == 'POST':
return redirect(url_for('settings'))
else:
if con.is_connected() == False:
con.reconnect()
# Go get the settings
cur.execute("select c.device_name, time_format(a.on_time, '%h:%i %p'), time_format(a.low_time, '%h:%i %p'), time_format(a.off_time, '%h:%i %p'), a.low, a.high, a.manual, a.created_on from flaskapp.device_settings a inner join (select device_id, max(id) as id from flaskapp.device_settings group by 1 ) b on a.device_id=b.device_id and a.id = b.id left join flaskapp.device_map c on a.device_id = c.device_id")
row = cur.fetchall()
return render_template('settings.html', form=form, rows=row, title='Light Control')
def settings(_id):
# Authentication
if current_user.id != _id and not current_user.is_admin():
flash("You are not authorised to edit user {}'s settings.".format(_id), "danger")
return redirect(request.referrer or url_for("index"))
# Check user exists
_user = User.query.filter(User.id == _id).first()
if _user is None:
flash("User {} not found.".format(_id), "danger")
return redirect(request.referrer or url_for("index"))
# Validate form, if submitted; else render it.
form = SettingsForm(_user, request.form)
if form.validate_on_submit():
_user.email = form.email.data
_user.show_ads = form.show_ads.data
db.session.add(_user)
db.session.commit()
return redirect(request.args.get("next") or url_for("users.user", _id=_user.id))
return render_template("users/settings.html",
title="Your settings - Dotabank",
user=_user,
form=form)
def settings():
avatars = {}
for filename in os.listdir('static/avatars'):
fullpath = 'avatars/' + filename
avatars[fullpath] = True if fullpath == current_user.avatar else False
if request.method == 'POST' and 'avatarForm' in request.form:
user = db.session.query(User).filter_by(id=current_user.id).one()
avatar = request.form['avatar']
user.avatar = avatar
db.session.commit()
flash('Avatar image changed!', "success")
return redirect(url_for('auth.settings'))
form = SettingsForm(username=current_user.name,
email=current_user.email,
bio=current_user.bio)
if form.validate_on_submit():
if current_user.check_password(form.password.data):
user = db.session.query(User).filter_by(id=current_user.id).one()
user.name = form.username.data
user.email = form.email.data
user.bio = form.bio.data
if form.new_password.data:
user.set_password(form.new_password.data)
db.session.commit()
flash('Account settings updated!', "success")
return redirect(
url_for('home.profile',
user_id=current_user.id,
username=current_user.name))
else:
flash('Incorrect password!', "error")
return render_template('settings.html',
current_user=current_user,
form=form,
avatars=avatars)
def settings(_id):
# Authentication
if current_user.id != _id and not current_user.is_admin():
flash("You are not authorised to edit user {}'s settings.".format(_id), "danger")
return redirect(request.referrer or url_for("index"))
# Check user exists
_user = User.query.filter(User.id == _id).first()
if _user is None:
flash("User {} not found.".format(_id), "danger")
return redirect(request.referrer or url_for("index"))
# Validate form, if submitted; else render it.
form = SettingsForm(_user, request.form)
if form.validate_on_submit():
_user.email = form.email.data
_user.show_ads = form.show_ads.data
db.session.add(_user)
db.session.commit()
return redirect(request.args.get("next") or url_for("users.user", _id=_user.id))
return render_template("users/settings.html",
title="Your settings - Dotabank",
user=_user,
form=form)
def settings():
form = SettingsForm(format_string = Setting.get("format_string"))
if request.method == 'POST':
if form.validate_on_submit():
Setting.set("format_string", form.format_string.data)
flash("Settings Updated")
return redirect("/")
return render_template('settings.html', form=form)
def settings():
form = SettingsForm()
if form.validate_on_submit():
set_settings(path=form.path.data, command=form.command.data, websettings=str(form.websettings.data), progress_file=form.progress_file.data)
path, command, websettings, progress_file = get_settings('path', 'command', 'websettings', 'progress_file')
if websettings.lower() == "false":
flash('websettings have been disabled, please edit config.ini on the server directly')
return redirect(url_for("index"))
return render_template('settings.html', form=form, path=path, command=command, websettings=websettings,
progress_file=progress_file)
def settings():
global config
# we need getattr for WTF
formdata = namedtuple('Struct', config.keys())(*config.values())
form = SettingsForm(obj=formdata, bait_session_retain=config['bait_session_retain'])
if form.validate_on_submit():
# the potential updates that we want to save to config file.
options = {'bait_session_retain': form.bait_session_retain.data,
'malicious_session_retain': form.malicious_session_retain.data,
'ignore_failed_bait_session': form.ignore_failed_bait_session.data}
update_config(options)
return render_template('settings.html', form=form, user=current_user)
def settings():
global config
form = SettingsForm(obj=MultiDict(config))
if form.validate_on_submit():
# the potential updates that we want to save to config file.
options = {'honeybee_session_retain': form.honeybee_session_retain.data,
'malicious_session_retain': form.malicious_session_retain.data,
'ignore_failed_honeybees': form.ignore_failed_honeybees.data}
update_config_file(app.config['BEEKEEPER_CONFIG'], options)
# update the global config dict.
config = get_config_dict(app.config['BEEKEEPER_CONFIG'])
return render_template('settings.html', form=form, user=current_user)
def settings():
bait_session_retain = send_config_request('{0} {1}'.format(Messages.GET_CONFIG_ITEM, 'bait_session_retain'))
ignore_failed_bait_session = ast.literal_eval(send_config_request('{0} {1}'.format(Messages.GET_CONFIG_ITEM, 'ignore_failed_bait_session')))
malicious_session_retain = send_config_request('{0} {1}'.format(Messages.GET_CONFIG_ITEM, 'malicious_session_retain'))
form = SettingsForm(bait_session_retain=bait_session_retain, malicious_session_retain=malicious_session_retain,
ignore_failed_bait_session=ignore_failed_bait_session)
if form.validate_on_submit():
# the potential updates that we want to save to config file.
options = {'bait_session_retain': form.bait_session_retain.data,
'malicious_session_retain': form.malicious_session_retain.data,
'ignore_failed_bait_session': form.ignore_failed_bait_session.data}
send_config_request('{0} {1}'.format(Messages.SET_CONFIG_ITEM, json.dumps(options)))
return render_template('settings.html', form=form, user=current_user)
def settings():
form = SettingsForm()
if form.validate_on_submit():
pass # TODO - Make this actually do something
elif request.method is not 'POST':
form.username.data = g.user.username
form.email.data = g.user.email
form.gender.data = g.user.gender # FIXME - Currently doesn't fill in radio button
form.location.data = g.user.location
form.about.data = g.user.about
return render_template(
'settings.html',
form=form
)
def settings():
pw_form = PasswordChangeForm()
set_form = SettingsForm()
if 'pw_change' in request.form and pw_form.validate_on_submit():
try:
g.user.set_password(pw_form.new_password.data)
db.session.commit()
flash(u'Passwort wurde geändert.')
except:
flash(u'Passwort konnte nicht geändert werden.')
if 'settings_change' in request.form and set_form.validate_on_submit():
g.user.name = set_form.name.data
db.session.commit()
flash(u'Einstellungen wurde geändert.')
return render_template('user/settings.html', pw_form=pw_form, set_form=set_form)
def settings():
'''
Configuration page (web GUI).
'''
cnfg = ConfigurationModel.find()
if cnfg is None:
abort(404)
form = SettingsForm()
#sets the values in the form
if request.method != 'POST':
form.dsgvo.default = cnfg.dsgvo
form.quiz.default = cnfg.quizmode
form.f.default = cnfg.global_f
form.p.default = cnfg.global_p
form.q.default = cnfg.global_q
form.process()
if form.validate_on_submit():
dsgvo = form.dsgvo.data
quiz = form.quiz.data
f = form.f.data
p = form.p.data
q = form.q.data
if not check_fpq(f, p, q):
print("Only values between 0 and 1 allowed for f,p,q!") #debug
flash("Only values between 0 and 1 allowed for f,p,q!")
return render_template('settings.html',
form=form,
cnfg=cnfg,
title='client settings')
cnfg.dsgvo = dsgvo
cnfg.quizmode = quiz
cnfg.global_f = f
cnfg.global_p = p
cnfg.global_q = q
try:
cnfg.save_to_db()
except:
return render_template(
'/error_pages/500.html',
title='error while trying to save inquiries.')
return render_template('settings.html',
form=form,
cnfg=cnfg,
title='client settings')
def account_settings():
form = SettingsForm(request.form)
if form.validate_on_submit():
current_user.email = form.email.data
if form.password.data:
current_user.password = form.password.data
flash("Settings Updated")
db.session.add(current_user)
db.session.commit()
form.email.data = current_user.email
flash_errors(form)
return render_template('users/account_settings.html',form =form)
def settings_page():
form = SettingsForm()
session = db_session.create_session()
if request.method == 'GET':
form.login.data = current_user.login
if form.validate_on_submit():
if form.login.data:
current_user.login = form.login.data
if form.password.data:
current_user.set_password(form.password.data)
session.merge(current_user)
session.commit()
session.close()
return redirect('/main')
resp = render_template('settings.html', title='Настройки', form=form)
session.close()
return resp
def settings():
if not g.user.can_create_ballot():
abort(403)
settings = db.session.query(Settings).get(g.user.id)
if settings is None:
settings = Settings(id=g.user.id, signature=default_signature())
form = SettingsForm(request.form, obj=settings)
if request.method == "POST" and form.validate_on_submit():
form.populate_obj(settings)
db.session.add(settings)
db.session.commit()
flash(u"Nastavení bylo uloženo.", "success")
return redirect(url_for("settings"))
return render_template('settings.html', form=form)
def settings():
if not g.user.can_create_ballot():
abort(403)
settings = db.session.query(Settings).get(g.user.id)
if settings is None:
settings = Settings(id=g.user.id, signature=default_signature())
form = SettingsForm(request.form, obj=settings)
if request.method == "POST" and form.validate_on_submit():
form.populate_obj(settings)
db.session.add(settings)
db.session.commit()
flash(u"Nastavení bylo uloženo.", "success")
return redirect(url_for("settings"))
return render_template('settings.html', form=form)
def settings():
message_box = ""
settings_form = SettingsForm()
#Only validate forms if the user pressed the submit button
if 'submit_button' in request.form and request.form['submit_button'] == 'Update':
if settings_form.validate_on_submit():
if request.form['old_password'].strip() != current_user.password:
message_box = message_box_html('The old password provided is incorrect.', error=True)
else:
current_user.email = request.form['email'].strip()
current_user.username = request.form['username'].strip()
current_user.password = request.form['password'].strip()
db.session.commit()
message_box = message_box_html('Your account settings have been changed.')
else: #Set error message to the first validation error.
message_box = get_form_error(settings_form)
return render_template('settings.html', settings_form=settings_form, message_box=message_box)
def settings():
form = SettingsForm()
if request.method == 'POST':
if form.validate_on_submit():
# get form data
test = form.test.data
# add to db
info = { "settings": {
'test': test,
}
}
db.users.update_one({
"username": session['username']
}, {
"$set": info
})
# return to add content page
app.logger.info('%s updated settings', session["username"])
flash("Settings updated")
return redirect("/dashboard")
return render_template('settings.html', form=form)
def settings(_id):
"""
A user's settings page.
Access restricted to the user themselves or admins.
:param _id: The user ID of the user whose knobs we are tweaking.
:return: Redirect if shit went wrong.
:return: Response
"""
# Check the visitor is the user whose settings we're trying to poke, or an admin.
if current_user.id != _id and not current_user.is_admin():
flash("You are not authorised to edit user {}'s settings.".format(_id), "error")
return redirect(request.referrer or url_for("index"))
# Get the user object for the given user ID.
_user = User.query.filter(User.id == _id).first()
if _user is None:
flash("User {} not found.".format(_id), "error")
return redirect(request.referrer or url_for("index"))
# Get settings form! Woop!
form = SettingsForm(_user, request.form)
# If the form was submitted, update the user's settings and send the visitor on their way.
if form.validate_on_submit():
_user.email = form.email.data
_user.show_ads = form.show_ads.data
db.session.add(_user)
db.session.commit()
return redirect(request.args.get("next") or url_for("users.user", _id=_user.id))
# Render the settings page.
return render_template("users/settings.html",
title="{} - {}".format(
"Your settings" if current_user.id == _id else "{}'s settings".format(_user.name),
app.config['SITE_NAME']),
user=_user,
form=form)
def settings():
bait_session_retain = send_config_request('{0} {1}'.format(
Messages.GET_CONFIG_ITEM.value, 'bait_session_retain'))
ignore_failed_bait_session = ast.literal_eval(
send_config_request('{0} {1}'.format(Messages.GET_CONFIG_ITEM.value,
'ignore_failed_bait_session')))
malicious_session_retain = send_config_request('{0} {1}'.format(
Messages.GET_CONFIG_ITEM.value, 'malicious_session_retain'))
form = SettingsForm(bait_session_retain=bait_session_retain,
malicious_session_retain=malicious_session_retain,
ignore_failed_bait_session=ignore_failed_bait_session)
if form.validate_on_submit():
# the potential updates that we want to save to config file.
options = {
'bait_session_retain': form.bait_session_retain.data,
'malicious_session_retain': form.malicious_session_retain.data,
'ignore_failed_bait_session': form.ignore_failed_bait_session.data
}
send_config_request('{0} {1}'.format(Messages.SET_CONFIG_ITEM.value,
json.dumps(options)))
return render_template('settings.html', form=form, user=current_user)
def settings():
if g.user is None or not g.user.is_authenticated():
return redirect(url_for('login'))
form = SettingsForm()
if form.validate_on_submit():
if (md5(form.oldpass.data).hexdigest() == md5(g.user.password).hexdigest()) and (form.newpass.data == form.passagain.data != None):
g.user.password = md5(form.newpass.data).hexdigest()
if ((form.newlogin.data != "") and (db.session.query(User).filter(User.nickname == form.newlogin.data).first() == None) and (md5(form.logpass.data).hexdigest() == md5(g.user.password).hexdigest())):
g.user.nickname = form.newlogin.data
if (form.title.data != ""):
g.user.title = form.title.data
if (form.description.data != ""):
g.user.about = form.description.data
if (form.userpic.data != ""):
g.user.style = form.userpic.data
if (form.backgr.data != ""):
g.user.background = form.backgr.data
db.session.add(g.user)
db.session.commit()
return redirect(url_for('settings'))
return render_template('settings.html',
form = form,
user = g.user)
def settings():
message_box = ""
settings_form = SettingsForm()
#Only validate forms if the user pressed the submit button
if 'submit_button' in request.form and request.form[
'submit_button'] == 'Update':
if settings_form.validate_on_submit():
if request.form['old_password'].strip() != current_user.password:
message_box = message_box_html(
'The old password provided is incorrect.', error=True)
else:
current_user.email = request.form['email'].strip()
current_user.username = request.form['username'].strip()
current_user.password = request.form['password'].strip()
db.session.commit()
message_box = message_box_html(
'Your account settings have been changed.')
else: #Set error message to the first validation error.
message_box = get_form_error(settings_form)
return render_template('settings.html',
settings_form=settings_form,
message_box=message_box)
def settings():
form = SettingsForm()
if request.method == 'POST':
if form.validate_on_submit():
pass
return render_template('settings.html', form=form)
def settings():
conf = CloudStackConfig()
if not conf.has_cloudstack_section():
flash(f'Please input Cloudstack credential first', 'success')
return redirect(url_for('editcredential'))
if not conf.has_tenant_section():
flash(f'Please complete the settings', 'success')
return redirect(url_for('editsettings'))
if not conf.has_autoscaling_section():
flash(f'Please complete the settings', 'success')
return redirect(url_for('editsettings'))
form = SettingsForm()
cs = CloudStackApiClient.get_instance()
if form.validate_on_submit():
return redirect(url_for('editsettings'))
tenant_lb_rule_uuid = conf.get_lb_rule_uuid()
tenant_zone_uuid = conf.get_zone_uuid()
tenant_template_uuid = conf.get_template_uuid()
tenant_serviceoffering_uuid = conf.get_serviceoffering_uuid()
autoscaling_autoscaling_vm = conf.get_autoscaling_vm()
autoscaling_upper_limit = conf.get_upper_limit()
autoscaling_lower_limit = conf.get_lower_limit()
tenant_zone_name = cs.get_zone_name(tenant_zone_uuid)
tenant_lb_rule_name = cs.get_lb_name(tenant_lb_rule_uuid)
tenant_template_name = cs.get_tp_name(tenant_template_uuid)
tenant_serviceoffering_name = cs.get_sv_name(tenant_serviceoffering_uuid)
networks_name_list = []
if conf.has_tenant_section():
for nw_uuid in conf.get_networks():
nw_name = cs.get_nw_name(nw_uuid)
networks_name_list.append(nw_name)
vms_name_list = []
if conf.has_vm_section():
for vm in conf.get_vm_list():
vm_uuid = conf.get_vm_uuid(vm)
vm_name = cs.get_vm_name(vm_uuid)
vms_name_list.append(vm_name)
timezone = dict(TIMEZONE).get(DEFAULT_TIMEZONE)
if conf.get_timezone() is not None:
timezone = dict(TIMEZONE).get(conf.get_timezone())
params = {}
params["title"] = 'Settings'
params["form"] = form
params["tenant_zone_name"] = tenant_zone_name
params["tenant_lb_rule_name"] = tenant_lb_rule_name
params["tenant_template_name"] = tenant_template_name
params["networks_name_list"] = networks_name_list
params["tenant_serviceoffering_name"] = tenant_serviceoffering_name
params["autoscaling_autoscaling_vm"] = autoscaling_autoscaling_vm
params["autoscaling_upper_limit"] = autoscaling_upper_limit
params["autoscaling_lower_limit"] = autoscaling_lower_limit
params["vms_name_list"] = vms_name_list
params["timezone"] = timezone
return render_template('settings.html', **params)
