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():
if request.method == 'GET':
form = SettingsForm()
return render_template('settings.html',form=form)
else:
form = SettingsForm(request.form)
pass
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 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(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 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 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 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 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 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 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 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():
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 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 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_edit(request, response_format='html'):
"Settings edit"
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('account_settings_view'))
else:
return HttpResponseRedirect(reverse('account_settings_view'))
else:
form = SettingsForm(request.user.profile)
return render_to_response('account/settings_edit',
{'form': Markup(form.as_ul())},
context_instance=RequestContext(request),
response_format=response_format)
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():
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):
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 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 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 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 site_settings(request, template_name='account/settings.html'):
if request.method == 'POST':
form = SettingsForm(request.POST)
form.user = request.user
if form.is_valid():
request.user.cc_messages_to_email = form.cleaned_data['cc_email']
request.user.email_address = form.cleaned_data['email']
request.user.first_name = form.cleaned_data['first_name']
request.user.last_name = form.cleaned_data['last_name']
request.user.save()
request.user.message_set.create(
message=_("""Your settings were successfully updated.""") % {})
else:
form = SettingsForm(
initial={
'email': request.user.email_address,
'cc_email': request.user.cc_messages_to_email,
'first_name': request.user.first_name,
'last_name': request.user.last_name,
})
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
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, "settings.html", {'form': SettingsForm()})
else:
form = SettingsForm()
return render(request, 'settings.html', {
'form': 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 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 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
