def settings():
if request.method == 'GET':
form = SettingsForm()
return render_template('settings.html',form=form)
else:
form = SettingsForm(request.form)
pass
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( request, template = 'settings_form.html' ):
context = {}
user = request.user
if request.method == 'POST':
form = SettingsForm(request.POST.copy())
if form.is_valid():
# Cycle through the settings and save them
data = form.cleaned_data
for setting in USER_SETTINGS:
name = setting['name']
set_setting(user, name, data[name])
context['saved'] = True
else:
# Read user settings and build the form
settings = {}
for setting in USER_SETTINGS:
name = setting['name']
settings[name] = get_setting(user, name)
form = SettingsForm(settings)
context['form'] = form
return render_to_response(template,
context, context_instance=RequestContext(request))
def cms_settings(request):
# 1.默认User表里是没有avatar，所以用到了CMSUser表
# 2.CMSUser表和User表建立了一对一
# 3.我们先查找CMSUser里的用户id
# 4.如果用户存在则存储avatar，否则新建该用户并储存
if request.method == 'GET':
return render(request, 'cms_settings.html')
else:
form = SettingsForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username', None)
avatar = form.cleaned_data.get('avatar', None)
# 存储username
# user = User.objects.all().first()
user = request.user
user.username = username
user.save()
# 存储avatar
cms_user = CmsUserModel.objects.filter(user__pk=user.pk)
if cms_user:
cms_user.avatar = avatar
else:
CmsUserModel(user=user, avatar=avatar)
cms_user.save()
return myjson.json_result()
else:
return render(request, 'cms_settings.html',
{'error': form.get_error()})
def post(self):
if self.group != '1':
self.render("404.html", username=self.username, group=self.group)
arguments = {
"page_size": self.get_argument("pagesize"),
"status_name": self.get_argument("statusname"),
"group_name": self.get_argument("groupname"),
"type_name": self.get_argument("typename"),
}
settings = get_settings(self.session)
form = SettingsForm(self.request.arguments)
update_error = settings_update_validation(self.session)
if form.validate():
if update_error == "":
update_settings(self.session, settings, arguments)
self.redirect("/admin/settings")
else:
self.render("/admin/settings.html",
username=self.username,
group=self.group,
settings=settings,
form=form,
db_error=update_error)
else:
self.render("/admin/settings.html",
username=self.username,
group=self.group,
settings=settings,
form=form,
db_error=None)
def user_settings(request):
if request.method == 'POST':
form = SettingsForm(request.POST, request.FILES)
if form.is_valid():
im = Image.open(request.FILES['profile_pic'])
im = ImageOps.fit(im, (120, 120), Image.ANTIALIAS)
if not os.path.exists(os.path.join(settings.MEDIA_ROOT, "profile")):
os.makedirs(os.path.join(settings.MEDIA_ROOT, "profile"))
im.save(os.path.join(settings.MEDIA_ROOT, "profile/{}.png".format(request.user.netid)))
request.user.photo = "png"
request.user.save()
messages.success(request, 'Votre profil a été mis à jour.')
return render(request, "users/settings.html", {'form': SettingsForm()})
else:
form = SettingsForm()
return render(request, 'users/settings.html', {
'form': form,
'stream': actor_stream(request.user),
})
def front_settings(request):
if request.method == 'GET':
return render(request, 'front_settings.html')
else:
form = SettingsForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username', None)
realname = form.cleaned_data.get('realname', None)
qq = form.cleaned_data.get('qq', None)
avatar = form.cleaned_data.get('avatar', None)
signature = form.cleaned_data.get('signature', None)
gender = form.cleaned_data.get('gender', None)
# 用户登录之后只要获取当前用户的信息，然后就可以直接传入数据
user_model = request.user
# 只有用户名是必填项，其他如果没有可以不填，所以需要判断,而性别是有默认选项
user_model.username = username
user_model.gender = gender
if realname:
user_model.realname = realname
if qq:
user_model.qq = qq
if avatar:
user_model.avatar = avatar
if signature:
user_model.signature = signature
user_model.save()
return myjson.json_result()
else:
return render(request, 'cms_reset_email.html',
{'error': form.get_error()})
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(request.form)
if request.method == 'GET':
config = configparser.ConfigParser()
config.read('config.ini')
form.image_path.data = config['DEFAULT']['IMAGE_PATH']
form.suspected_user.data = config['DEFAULT']['SUSPECTED_USER']
form.classified_folder.data = config['DEFAULT']['CLASSIFIED_DATA_FOLDER']
form.es_host.data = config['ELASTIC_SEARCH']['HOST']
form.es_port.data = config['ELASTIC_SEARCH']['PORT']
form.regripper_path.data = config['3RD_PARTY']['REGRIPPER_PATH']
form.virustotal_api_key.data = config['3RD_PARTY']['VIRUSTOTAL_API_KEY']
form.webshrinker_api_key.data = config['3RD_PARTY']['WEBSHRINKER_API_KEY']
form.webshrinker_api_secret.data = config['3RD_PARTY']['WEBSHRINKER_API_SECRET']
if request.method == 'POST' and form.validate():
config = configparser.ConfigParser()
config['DEFAULT'] = {}
config['DEFAULT']['IMAGE_PATH'] = form.image_path.data
config['DEFAULT']["SUSPECTED_USER"] = form.suspected_user.data
config['DEFAULT']["CLASSIFIED_DATA_FOLDER"] = form.classified_folder.data
config['ELASTIC_SEARCH'] = {}
config['ELASTIC_SEARCH']['HOST'] = form.es_host.data
config['ELASTIC_SEARCH']['PORT'] = form.es_port.data
config['3RD_PARTY'] = {}
config['3RD_PARTY']["REGRIPPER_PATH"] = form.regripper_path.data
config['3RD_PARTY']["VIRUSTOTAL_API_KEY"] = form.virustotal_api_key.data
config['3RD_PARTY']["WEBSHRINKER_API_KEY"] = form.webshrinker_api_key.data
config['3RD_PARTY']["WEBSHRINKER_API_SECRET"] = form.webshrinker_api_secret.data
with open('config.ini', 'w') as configfile:
config.write(configfile)
return redirect('/')
return render_template('settings.html', title='Settings', 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():
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 save_settings(request, cid):
print 'update_settings request.method = %s' % request.method
if request.method == 'POST':
con = get_construct(request.user, cid)
if not con:
return JsonResponse({
'errors': {
'all': "Construct with id '%s' not found",
},
} % cid, ERROR)
form = SettingsForm(request.POST, instance=con.settings)
if form.is_valid():
form.save()
con.reset()
data = {}
for key, value in form.cleaned_data.items():
data[key] = str(value)
return JsonResponse({
'modified': con.last_modified(),
'fields': data
})
return JsonResponse({
'errors': form.errors,
}, ERROR)
raise Http404
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(request):
if request.method == "POST":
form = SettingsForm(request.POST)
if form.is_valid():
request.user.topic_set = form.cleaned_data["topics"]
return HttpResponseRedirect("/")
else:
form = SettingsForm()
return render(request, "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(request):
if request.POST:
settingsForm = SettingsForm(request.POST, instance=request.user)
if settingsForm.is_valid():
settingsForm.save()
messages.info(request, 'User settings saved.')
return redirect('dashboard')
else:
settingsForm = SettingsForm(instance=request.user)
return render(request, 'settings.html', {'settingsForm': settingsForm})
def settings(request, user_id):
user = get_object_or_404(User, id=user_id)
if request.user != user and not request.user.is_superuser:
return HttpResponseForbidden("Forbidden operation.")
form = SettingsForm(data=request.POST or None,
initial={"email": user.email, "intro": user.get_profile().intro})
if request.method == "POST" and form.is_valid():
form.save(user)
return redirect(reverse("user_profile", kwargs={"user_id": user_id}))
return render(request, "settings.html",
{"form": form, "settings_user": user})
def post(self):
args = self.request.arguments()
post_data = {}
for arg in args:
d = self.request.get(arg)
post_data[arg] = d
form = SettingsForm(post_data)
if form.is_valid():
form.save()
self.get(form=form)
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 edit_settings(request):
context = {}
settings = Settings.get_by_user(request.user)
if request.method == "POST":
form = SettingsForm(request.POST, instance=settings)
if form.is_valid():
form.save()
return HttpResponseRedirect("/settings")
else:
form = SettingsForm(instance=settings)
context["form"] = form
return r2r(request, "edit_settings", context)
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():
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():
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(request):
if request.method == 'POST':
form = SettingsForm(request.POST)
if form.is_valid():
try:
Alert.objects.get(user=request.user).delete()
except:
pass
data = form.cleaned_data
client_t = data['user_time']
server_t = datetime.now().strftime('%H')
tz_diff = int(server_t) - int(client_t)
as_time = datetime(2013, 1, 1, data['time'].hour, data['time'].minute)
as_time = as_time + timedelta(hours=tz_diff)
a = Alert(
user=request.user,
alert_server_time=as_time,
start=data['start'],
finish=data['finish'],
period=data['period'],
time=data['time'],
alert_email=data['alert_email'],
email=data['email'],
alert_sms=data['alert_sms'],
phone=data['phone']
)
alert = {}
try:
a.save()
alert['txt'] = 'Настройки сохранены'
alert['cls'] = 'alert-success'
except:
alert['txt'] = 'Не удалось сохранить настройки, попробуйте повторить позже'
alert['cls'] = 'alert-danger'
return render_to_response('settings.html', {'form': form, 'alert': alert}, RequestContext(request))
else:
try:
a = Alert.objects.get(user=request.user)
form = SettingsForm(instance=a)
except:
form = SettingsForm()
return render_to_response('settings.html', {'form': form}, RequestContext(request))
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_edit(request, response_format='html'):
"Settings"
if request.POST:
form = SettingsForm(request.user.profile, request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('changes_settings_view'))
else:
form = SettingsForm(request.user.profile)
context = _get_default_context(request)
context.update({'form': form})
return render_to_response('changes/settings_edit', context,
context_instance=RequestContext(request), response_format=response_format)
def settings(request, user_id):
user = get_object_or_404(User, id=user_id)
if request.user != user and not request.user.is_superuser:
return HttpResponseForbidden("Forbidden operation.")
form = SettingsForm(data=request.POST or None,
initial={
"email": user.email,
"intro": user.get_profile().intro
})
if request.method == "POST" and form.is_valid():
form.save(user)
return redirect(reverse("user_profile", kwargs={"user_id": user_id}))
return render(request, "settings.html", {
"form": form,
"settings_user": user
})
def profile(request):
if request.method == 'POST':
form = SettingsForm(request.POST, request.FILES)
if form.is_valid():
if request.user.check_password(request.POST['old_pass']):
if request.POST['username'] != '':
request.user.username = request.POST['username']
if request.POST['email'] != '':
request.user.email = request.POST['email']
if request.POST['pass_new'] != '':
request.user.password = request.POST['pass_new']
request.user.set_password(request.user.password)
request.user.save()
return home(request)
form = SettingsForm()
return render(request, 'external/profile.html', {'form': form})
def admin_settings():
if g.user.is_activated():
form = SettingsForm()
return render_template('admin/settings.html', form=form, user=g.user)
else:
flash(msgs['NOT_ACTIVATED'])
return redirect(url_for('.admin_index'))
def settings(request):
if not request.user.is_authenticated():
return redirect('/overview')
context = {}
context.update(csrf(request))
context['form'] = SettingsForm()
return render(request, 'settings.html', context)
def settings(request):
context_vars = {}
context_vars.update(csrf(request))
if request.method == 'POST':
form = SettingsForm(request.POST, request.FILES, instance=request.user.profile)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('profile', kwargs={"username": request.user.username}))
else:
form = SettingsForm(instance=request.user.profile)
context_vars.update({'form': form})
template = 'settings.html'
context = RequestContext(request)
return render_to_response(template, context_vars, context_instance=context)
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 index(request):
# Get course id from session
try:
courseid = request.session['LTI_LAUNCH']['custom_canvas_course_id']
except:
logger.error("Missing custom_canvas_course_id in LTI launch")
raise Http404("Course ID not found")
# Get content via API calls
syllabus = fetch_syllabus(courseid)
(dated, undated) = fetch_allevents(courseid)
groups = fetch_assigngroups(courseid)
# Check for initial load of page through presence of hidden field
if 'hidden_field' in request.GET:
form = SettingsForm(request.GET)
if form.is_valid():
settings = form.cleaned_data
else:
form = SettingsForm()
settings = {
'syllabus': True,
'dated_events': True,
'undated_events': False,
'descriptions': False,
'times': True,
'weights': False,
'hidden_field': "viewed"
}
# Populate events array based on toggled options
events = []
if settings['dated_events']:
events += dated
if settings['undated_events']:
events += undated
context = {
'syllabus': syllabus,
'events': events,
'groups': groups,
'form': form,
'settings': settings
}
return render(request, 'syllabuspdf/index.html', context)
def settings_edit(request, response_format='html'):
"Settings"
if not request.user.profile.is_admin('anaf.services'):
return user_denied(
request,
message=
"You don't have administrator access to the Service Support module"
)
if request.POST:
if 'cancel' not in request.POST:
form = SettingsForm(request.user.profile, request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('services_settings_view'))
else:
return HttpResponseRedirect(reverse('services_settings_view'))
else:
form = SettingsForm(request.user.profile)
context = _get_default_context(request)
context.update({'form': form})
return render_to_response('services/settings_edit',
context,
context_instance=RequestContext(request),
response_format=response_format)
def settings(request):
settings_form = SettingsForm()
next = request.REQUEST.get('next')
if request.method == 'POST':
settings_form = SettingsForm(request.POST)
if settings_form.is_valid():
username = settings_form.save()
request.session['username'] = username
if next:
return HttpResponseRedirect(next)
return HttpResponseRedirect('/')
context = {
'settings_form': settings_form,
'next': next,
}
return render_to_response('settings.html', context,
context_instance=RequestContext(request))
def settings():
"""
HR个人信息设置页面
:return:
"""
if request.method == 'GET':
return render_template('settings.html')
else:
form = SettingsForm(request.form)
if form.validate():
username = form.username.data
email = form.email.data
user = HrUser.query.get(g.user.id)
user.username = username
user.email = email
db.session.commit()
return restful.success()
else:
return restful.params_error(message=form.get_error())
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():
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 security():
setting = Settings.query.get(1)
pair_choices = [(i.name, i.name) for i in Symbol.query.all()]
form = SettingsForm(obj=setting)
form.allowed_pairs.choices = pair_choices
if request.method == 'POST':
form = SettingsForm(request.form)
form.allowed_pairs.choices = pair_choices
if form.validate():
setting.allowed_pairs = form.allowed_pairs.data
setting.allowed_actions = form.allowed_actions.data
setting.allowed_balance = form.allowed_balance.data
setting.test_mode = form.test_mode.data
db_session.commit()
flash('Settings have been updated.', 'success')
return redirect(url_for('dashboard'))
return render_template('security.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 save_settings(request, cid):
print 'update_settings request.method = %s' % request.method
if request.method == 'POST':
con = get_construct(request.user, cid)
if not con:
return JsonResponse({
'errors': {
'all':"Construct with id '%s' not found",
},} % cid, ERROR)
form = SettingsForm(request.POST, instance=con.settings)
if form.is_valid():
form.save()
con.reset()
data = {}
for key,value in form.cleaned_data.items():
data[key] = str(value);
return JsonResponse({'modified': con.last_modified(), 'fields': data})
return JsonResponse({'errors': form.errors,}, ERROR)
raise Http404
def render(settings_id, data=None):
settings = PaymentSettings.objects.get(id=settings_id)
dict={'LMI_PAYMENT_AMOUNT': data['amount'], 'LMI_PAYMENT_DESC': data['description'], \
'LMI_PAYMENT_NO': data['id'], 'LMI_PAYEE_PURSE': settings.purse, \
'LMI_SUCCESS_URL': settings.success_url, 'LMI_FAIL_URL': settings.fail_url}
form = SettingsForm(initial=dict)
form = mark_safe("<form action='https://merchant.webmoney.ru/lmi/payment.asp' method='post' id='web_money_redirect_form'>"+form.as_p()+\
"<input type='hidden' value='0' name='LMI_SIM_MODE'><input type='submit' value='"+_('Go to payment').decode()+"'></form>")
return form
def update_settings(request):
if request.method == 'POST':
form = SettingsForm(request.POST)
if form.is_valid():
show_on_rankings = form.cleaned_data['show_on_rankings']
user = UserProfile.objects.get(user = request.user)
if show_on_rankings:
user.show_on_rankings = True
else:
user.show_on_rankings = False
user.save()
messages.add_message(request, messages.SUCCESS, 'Your profile has been successfully updated.')
else:
messages.add_message(request, messages.ERROR, message = 'Error occured when trying to update your settings.')
return render_to_response('other/message.html', {}, context_instance = RequestContext(request))
def render(data=None):
text = ''
for settings in PaymentSettings.objects.filter(is_active=True):
dict={'LMI_PAYMENT_AMOUNT': data['amount'], 'LMI_PAYMENT_DESC': data['description'], \
'LMI_PAYMENT_NO': data['id'], 'LMI_PAYEE_PURSE': settings.purse, \
'LMI_SUCCESS_URL': data['link'], 'LMI_FAIL_URL': data['link'], 'SETTINGS_ID': settings.id
}
form = SettingsForm(initial=dict)
text += u"<h3>%s</h3><p>%s</p><form action='https://merchant.webmoney.ru/lmi/payment.asp' method='post' id='web_money_redirect_form'>%s\
<input type='hidden' value='0' name='LMI_SIM_MODE'><input type='submit' value='%s'></form>" % (settings.title, settings.description, form.as_p(), _('Go to payment'))
return mark_safe(text)
def settings(request):
if request.POST:
settingsForm = SettingsForm(request.POST, instance=request.user)
if settingsForm.is_valid():
settingsForm.save()
messages.info(request, 'User settings saved.')
return redirect('dashboard')
else:
settingsForm = SettingsForm(instance=request.user)
return render(request, 'settings.html', {'settingsForm': settingsForm})
def settings_edit(request, response_format='html'):
"Settings edit"
if request.POST:
if 'cancel' not in request.POST:
form = SettingsForm(
request.user.profile, request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('core_settings_view'))
else:
return HttpResponseRedirect(reverse('core_settings_view'))
else:
form = SettingsForm(request.user.profile)
return render_to_response('core/administration/settings_edit',
{
'form': form,
},
context_instance=RequestContext(request), response_format=response_format)
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 index(request):
# Get course id from session
try:
courseid = request.session['LTI_LAUNCH']['custom_canvas_course_id']
except:
logger.error("Missing custom_canvas_course_id in LTI launch")
raise Http404("Course ID not found")
# Get content via API calls
syllabus = fetch_syllabus(courseid)
(dated, undated) = fetch_allevents(courseid)
groups = fetch_assigngroups(courseid)
# Check for initial load of page through presence of hidden field
if 'hidden_field' in request.GET:
form = SettingsForm(request.GET)
if form.is_valid():
settings = form.cleaned_data
else:
form = SettingsForm()
settings = {
'syllabus':True,
'dated_events':True,
'undated_events':False,
'descriptions':False,
'times':True,
'weights':False,
'hidden_field':"viewed"
}
# Populate events array based on toggled options
events = []
if settings['dated_events']:
events += dated
if settings['undated_events']:
events += undated
context = {'syllabus': syllabus, 'events': events, 'groups': groups, 'form': form, 'settings': settings}
return render(request,'syllabuspdf/index.html', context)
def post(self):
if self.group != '1':
self.render("404.html", username=self.username, group=self.group)
arguments = {
"page_size": self.get_argument("pagesize"),
"status_name": self.get_argument("statusname"),
"group_name": self.get_argument("groupname"),
"type_name": self.get_argument("typename"),
}
settings = get_settings(self.session)
form = SettingsForm(self.request.arguments)
update_error = settings_update_validation(self.session)
if form.validate():
if update_error == "":
update_settings(self.session, settings, arguments)
self.redirect("/admin/settings")
else:
self.render(
"/admin/settings.html",
username = self.username,
group = self.group,
settings = settings,
form = form,
db_error = update_error
)
else:
self.render(
"/admin/settings.html",
username = self.username,
group = self.group,
settings = settings,
form = form,
db_error = None
)
def render(data=None):
text = ''
for settings in PaymentSettings.objects.filter(is_active=True):
dict={'PRO_CLIENT': settings.pro_client, 'PRO_RA': settings.pro_ra, \
'PRO_SUMMA': data['amount'], 'PRO_PAYMENT_DESC': data['description'], \
'PRO_SUCCESS_URL': data['link'], 'PRO_PAYMENT_NO': data['id'], \
'PRO_ORDER_ID': data['id'], 'PRO_SETTINGS_ID': settings.id
}
form = SettingsForm(initial=dict)
text += u"<h3>%s</h3><p>%s</p><form action=http://merchant.prochange.ru/pay.pro method=POST>%s\
<input type='submit' value='%s'></form>" % (settings.title, settings.description, form.as_p(), _('Go to payment'))
return mark_safe(text)
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 get(self, form=None):
current_settings = Settings.get_by_key_name(config.SETTINGS_KEY)
if current_settings:
current_settings = current_settings.to_dict()
current_settings['allowed_ips'] = ','.join(current_settings['allowed_ips'])
else:
current_settings = Settings.reset_auth(config.SETTINGS_KEY);
if form is None:
form = SettingsForm(current_settings)
self.response.out.write(template.render(os.path.join(config.APP_ROOT_DIR, "templates/index.html"),
{"no_settings" : (current_settings is None), "form" : form, "title" : "Mail Engine for App Engine"}))
def settings():
hasKey = False
form = SettingsForm(request.form)
if 'redcap_api_key' in session:
flash('REDcap API key entered successfully!', "info")
hasKey = True
theKey = session['redcap_api_key']
if (request.method == 'POST' and form.validate()):
session['redcap_api_key'] = form.redcap_api_key.data
theKey = session['redcap_api_key']
return render_template('settings.html',
form=form,
hasKey=hasKey,
key=theKey,
proj_data=getProjInfo(theKey))
else:
flash("Please enter your REDCap API key.", "info")
if request.method == 'POST' and form.validate():
session['redcap_api_key'] = form.redcap_api_key.data
flash('REDcap API key entered successfully!', "success")
return redirect(url_for('home'))
return render_template('settings.html', form=form, hasKey=hasKey)
def index(day):
form = SettingsForm()
new_capture, new_capture_date, capture_days = session['data']
res_x, res_y, rotation, effect = getsettings()
#this is the only way to set default values for select form inputs
form.res_x.default = res_x
form.res_y.default = res_y
form.rotation.default = rotation
form.effect.default = effect
form.process()
capture_objects = getcaptures(day.replace('_', ' '))
return render_template(
'index.html',
form=form,
new_capture=new_capture,
new_capture_date=new_capture_date,
capture_days=capture_days,
capture_objects=capture_objects,
res_x=res_x,
res_y=res_y,
rotation=rotation,
effect=effect,
)
def get(self):
if self.group != '1':
self.render("404.html", username=self.username, group=self.group)
settings = get_settings(self.session)
form = SettingsForm()
self.render("admin/settings.html",
username=self.username,
group=self.group,
settings=settings,
form=form,
db_error=None)
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)
