def update_password():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
new_pass = request.forms.get('new_pass', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['verified'] = False
dict_for_return['message_str'] = "login failed"
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
dbMgr = MmrzSyncDBManager("USERS")
dbMgr.update_USERS_DB([username, new_pass])
dbMgr.closeDB()
dict_for_return['verified'] = True
dict_for_return['message_str'] = "password updated"
json_for_return = json.dumps(dict_for_return)
return json_for_return
python类forms()的实例源码
def upload_wordbook():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['verified'] = False
dict_for_return['message_str'] = "login failed"
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
rows = request.forms['wordbook']
rows = json.loads(rows)
dbMgr = MmrzSyncDBManager(username)
dbMgr.createDB()
dbMgr.pruneDB()
for row in rows:
dbMgr.insertDB(row)
dbMgr.closeDB()
dict_for_return['verified'] = True
dict_for_return['message_str'] = "upload done"
json_for_return = json.dumps(dict_for_return)
return json_for_return
def is_state_cache_available():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['mmrz_code'] = MMRZ_CODE_Universal_Verification_Fail
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
dbMgr = MongoDBManager()
userData = dbMgr.query_memorize_state(username)
dbMgr.closeDB()
state_cached = userData.get('state_cached', False)
dict_for_return['state_cached'] = state_cached
json_for_return = json.dumps(dict_for_return)
return json_for_return
def restore_remote_saved_state():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['mmrz_code'] = MMRZ_CODE_Universal_Verification_Fail
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
dbMgr = MongoDBManager()
userData = dbMgr.query_memorize_state(username)
dbMgr.closeDB()
dict_for_return['mmrz_code'] = MMRZ_CODE_Restore_State_OK
dict_for_return['current_cursor'] = int(userData['current_cursor'])
dict_for_return['max_size_this_turn'] = int(userData['max_size_this_turn'])
dict_for_return['data'] = userData['data']
json_for_return = json.dumps(dict_for_return)
return json_for_return
def clear_state_cached_flag_and_eiginvalue():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['mmrz_code'] = MMRZ_CODE_Universal_Verification_Fail
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
dbMgr = MongoDBManager()
dbMgr.clear_state_cached_flag_and_eiginvalue(username)
dbMgr.closeDB()
dict_for_return['mmrz_code'] = MMRZ_CODE_Universal_OK
json_for_return = json.dumps(dict_for_return)
return json_for_return
def update_row():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['verified'] = False
dict_for_return['message_str'] = "login failed"
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
row = request.forms['row']
update_whole_row = request.forms.get('update_whole_row', False)
row = json.loads(row)
dbMgr = MmrzSyncDBManager(username)
dbMgr.createDB()
dbMgr.updateDB(row, update_whole_row)
dbMgr.closeDB()
dict_for_return['verified'] = True
dict_for_return['message_str'] = "Update row success"
json_for_return = json.dumps(dict_for_return)
return json_for_return
def _request(request, request_fallback=None):
''' Extract request fields wherever they may come from: GET, POST, forms, fallback '''
# Use lambdas to avoid evaluating bottle.request.* which may throw an Error
all_dicts = [
lambda: request.json,
lambda: request.forms,
lambda: request.query,
lambda: request.files,
#lambda: request.POST,
lambda: request_fallback
]
request_dict = dict()
for req_dict_ in all_dicts:
try:
req_dict = req_dict_()
except KeyError:
continue
if req_dict is not None and hasattr(req_dict, 'items'):
for req_key, req_val in req_dict.items():
request_dict[req_key] = req_val
return request_dict
def addcrypted():
package = request.forms.get('referer', 'ClickAndLoad Package')
dlc = request.forms['crypted'].replace(" ", "+")
dlc_path = join(DL_ROOT, package.replace("/", "").replace("\\", "").replace(":", "") + ".dlc")
dlc_file = open(dlc_path, "wb")
dlc_file.write(dlc)
dlc_file.close()
try:
PYLOAD.addPackage(package, [dlc_path], 0)
except:
return HTTPError()
else:
return "success\r\n"
def set_sskey():
u = current_user
u.sskey = request.forms.get('sskey')
u.write()
import cron;
cd = cron.start()
if cd <= 0.5:
msg = "Your Shadowsocks key is changed!"
else:
msg = "The Shadowsocks key will be changed in %.2f sec" % cd
return get_home_content(msg)
# Website for Administrator
def log_in():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if verify_login(username, password):
dict_for_return['verified'] = True
dict_for_return['message_str'] = "logged in"
else:
dict_for_return['verified'] = False
dict_for_return['message_str'] = "username or password not correct"
json_for_return = json.dumps(dict_for_return)
return json_for_return
def sign_up():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not is_username_available(username):
dict_for_return['verified'] = False
dict_for_return['mmrz_code'] = MMRZ_CODE_Username_Not_Available_Error
dict_for_return['message_str'] = "Username not available"
elif not validate_username(username):
dict_for_return['verified'] = False
dict_for_return['mmrz_code'] = MMRZ_CODE_Username_Not_Valid
dict_for_return['message_str'] = "Username not valid"
elif not validate_password(password):
dict_for_return['verified'] = False
dict_for_return['mmrz_code'] = MMRZ_CODE_Password_Not_Valid
dict_for_return['message_str'] = "Password not valid"
else:
dbMgr = MmrzSyncDBManager("USERS")
dbMgr.insert_USERS_DB([username, password, "", "", "000000", 0, 0, 0])
dbMgr.closeDB()
dict_for_return['verified'] = True
dict_for_return['mmrz_code'] = MMRZ_CODE_Signup_OK
dict_for_return['message_str'] = "Signed up"
json_for_return = json.dumps(dict_for_return)
return json_for_return
def verify_eiginvalue():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['mmrz_code'] = MMRZ_CODE_Universal_Verification_Fail
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
dbMgr = MongoDBManager()
userData = dbMgr.query_memorize_state(username)
dbMgr.closeDB()
rows_length_fromDB = userData.get('rows_length', 0)
current_cursor_fromDB = userData.get('current_cursor', 0)
rows_length_from_client = request.forms.get('rows_length', 0)
current_cursor_from_client = request.forms.get('current_cursor', 0)
if rows_length_from_client == rows_length_fromDB and current_cursor_from_client == current_cursor_fromDB:
dict_for_return["mmrz_code"] = MMRZ_CODE_SaveState_Same_Eigenvalue
else:
dict_for_return["mmrz_code"] = MMRZ_CODE_SaveState_Diff_Eigenvalue
return json.dumps(dict_for_return)
def save_current_state():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['mmrz_code'] = MMRZ_CODE_Universal_Verification_Fail
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
current_state = request.forms.get('current_state', "[]")
current_state = json.loads(current_state)
rows_length_from_client = request.forms.get('rows_length', 0)
current_cursor_from_client = request.forms.get('current_cursor', 0)
max_size_this_turn_from_client = request.forms.get('max_size_this_turn', 0)
# not save state if state length is 0
if len(current_state) == 0:
dict_for_return['mmrz_code'] = MMRZ_CODE_Universal_Error # this error code better changed to something like: MMRZ_CODE_State_Length_Zero
json_for_return = json.dumps(dict_for_return)
return json_for_return
document = {
"username": username,
"state_cached": True,
"rows_length": rows_length_from_client,
"current_cursor": current_cursor_from_client,
"max_size_this_turn": max_size_this_turn_from_client,
"data": current_state,
}
dbMgr = MongoDBManager()
dbMgr.update_memorize_state(document)
dbMgr.closeDB()
dict_for_return['mmrz_code'] = MMRZ_CODE_SaveState_Save_OK
json_for_return = json.dumps(dict_for_return)
return json_for_return
def online_import():
username = request.forms.get('username', None)
password = request.forms.get('password', None)
is_smart = request.forms.get('is_smart', None)
is_smart = json.loads(is_smart)
quantity = request.forms.get('quantity', None)
quantity = int(quantity)
dict_for_return = dict(universal_POST_dict)
if not verify_login(username, password):
dict_for_return['verified'] = False
dict_for_return['message_str'] = "login failed"
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
dict_for_return['verified'] = True
dict_for_return['message_str'] = "Online import success"
fr = open("./WORDBOOK/{0}/data.pkl".format(username), "rb")
pkl = pickle.load(fr)
fr.close()
added = smart_import("./WORDBOOK/{0}/{1}".format(username, pkl["book_name"]), username, quantity, is_smart)
dict_for_return['added'] = added
json_for_return = json.dumps(dict_for_return)
return json_for_return
def tik_tik():
username = request.forms.get('username', None)
if not username:
return "username is None"
localtime = time.localtime()
timeStamp = int(time.time()) # ????
Year, Week, Day = datetime.date.fromtimestamp(timeStamp).isocalendar()
uniqMinute = timeStamp / 60 # ?????
uniqHour = uniqMinute / 60 # ?????
uniqDate = uniqHour / 24 # ????
theYear = localtime[0] # ?: 2017?
theMonth = localtime[1] # ??: 2 (2017?2?)
theDate = localtime[2] # ??: 22 (2?22)
theHour = localtime[3] # ???: 17 (17?)
theWeek = Week # ??: 8 (???)
theDay = Day # ??: 3 (?3)
tikMgr = TikTimeDBManager()
tikInfo = [username, timeStamp, uniqMinute, uniqHour, uniqDate, theYear, theMonth, theDate, theHour, theWeek, theDay]
if uniqMinute != tikMgr.getMaxUniqMinute(username):
tikMgr.insertDB(tikInfo)
else:
pass
tikMgr.closeDB()
return "tik_tik: OK"
def del_job():
# jid = request.forms['jid']
jid = request.query.jid
sched.stop(jid)
sched.qdel(jid)
return "OK"
def stop():
# jid = request.forms['jid']
jid = request.query.jid
sched.stop(jid)
return "OK"
def listfiles():
app = request.forms['app']
user = request.forms['user']
cid = request.forms['cid']
mypath = os.path.join(user_dir, user, app, cid)
return listdir(mypath)
def execute():
app = request.forms['app']
user = request.forms['user']
cid = request.forms['cid']
desc = request.forms['desc']
np = request.forms['np']
appmod = pickle.loads(request.forms['appmod'])
# remove the appmod key
del request.forms['appmod']
appmod.write_params(request.forms, user)
# if preprocess is set run the preprocessor
try:
if appmod.preprocess:
run_params, _, _ = appmod.read_params(user, cid)
base_dir = os.path.join(user_dir, user, app)
process.preprocess(run_params, appmod.preprocess, base_dir)
if appmod.preprocess == "terra.in":
appmod.outfn = "out"+run_params['casenum']+".00"
except:
return template('error', err="There was an error with the preprocessor")
# submit job to queue
try:
priority = db(users.user==user).select(users.priority).first().priority
uid = users(user=user).id
jid = sched.qsub(app, cid, uid, np, priority, desc)
return str(jid)
#redirect("http://localhost:"+str(config.port)+"/case?app="+str(app)+"&cid="+str(cid)+"&jid="+str(jid))
except OSError:
return "ERROR: a problem occurred"
def del_job():
# jid = request.forms['jid']
jid = request.query.jid
sched.stop(jid)
sched.qdel(jid)
return "OK"
def listfiles():
app = request.forms['app']
user = request.forms['user']
cid = request.forms['cid']
mypath = os.path.join(user_dir, user, app, cid)
return listdir(mypath)
def execute():
app = request.forms['app']
user = request.forms['user']
cid = request.forms['cid']
desc = request.forms['desc']
np = request.forms['np']
appmod = pickle.loads(request.forms['appmod'])
# remove the appmod key
del request.forms['appmod']
appmod.write_params(request.forms, user)
# if preprocess is set run the preprocessor
try:
if appmod.preprocess:
run_params, _, _ = appmod.read_params(user, cid)
base_dir = os.path.join(user_dir, user, app)
process.preprocess(run_params, appmod.preprocess, base_dir)
if appmod.preprocess == "terra.in":
appmod.outfn = "out"+run_params['casenum']+".00"
except:
return template('error', err="There was an error with the preprocessor")
# submit job to queue
try:
priority = db(users.user==user).select(users.priority).first().priority
uid = users(user=user).id
jid = sched.qsub(app, cid, uid, np, priority, desc)
return str(jid)
#redirect("http://localhost:"+str(config.port)+"/case?app="+str(app)+"&cid="+str(cid)+"&jid="+str(jid))
except OSError:
return "ERROR: a problem occurred"
def editplotdef(pltid):
user = root.authorized()
if user != 'admin':
return template('error', err="must be admin to edit plots")
app = request.forms.app
result = db(plots.id==pltid).select().first()
params = { 'app': app, 'user': user }
return template('plots/edit_plot', params, row=result)
def editplot(pltid):
user = root.authorized()
if user != 'admin':
return template('error', err="must be admin to edit plots")
app = request.forms.app
title = request.forms.title
ptype = request.forms.ptype
options = request.forms.options
print "updating plot ", pltid, "for app", app
plots(pltid).update_record(title=title, ptype=ptype, options=options)
db.commit()
redirect('/plots/edit?app='+app)
def edit_datasource_post(pltid, dsid):
"""update datasource for given plot"""
user = root.authorized()
if user != 'admin':
return template('error', err="must be admin to edit plots")
app = request.forms.get('app')
r = request.forms
datasource(id=dsid).update_record(label=r['label'], pltid=pltid, filename=r['fn'], cols=r['cols'],
line_range=r['line_range'], data_def=r['data_def'])
db.commit()
redirect ('/plots/' + str(pltid) + '/datasources?app='+app)
params = {'app': app, 'pltid': pltid, 'dsid': dsid}
return template('plots/edit_datasource', params)
def delete_datasource():
user = root.authorized()
if user != 'admin':
return template('error', err="must be admin to edit plots")
app = request.forms.get('app')
pltid = request.forms.get('pltid')
dsid = request.forms.get('dsid')
del db.datasource[dsid]
db.commit()
redirect ('/plots/' + str(pltid) + '/datasources?app='+app)
def create_plot():
user = root.authorized()
if user != 'admin':
return template('error', err="must be admin to edit plots")
app = request.forms.get('app')
r = request
plots.insert(appid=root.myapps[app].appid, ptype=r.forms['ptype'],
title=r.forms['title'], options=r.forms['options'])
db.commit()
redirect ('/plots/edit?app='+app)
def flashgot():
if request.environ['HTTP_REFERER'] != "http://localhost:9666/flashgot" and request.environ['HTTP_REFERER'] != "http://127.0.0.1:9666/flashgot":
return HTTPError()
autostart = int(request.forms.get('autostart', 0))
package = request.forms.get('package', None)
urls = filter(lambda x: x != "", request.forms['urls'].split("\n"))
folder = request.forms.get('dir', None)
if package:
PYLOAD.addPackage(package, urls, autostart)
else:
PYLOAD.generateAndAddPackages(urls, autostart)
return ""
def add_package():
name = request.forms.get("add_name", "New Package").strip()
queue = int(request.forms['add_dest'])
links = decode(request.forms['add_links'])
links = links.split("\n")
pw = request.forms.get("add_password", "").strip("\n\r")
try:
f = request.files['add_file']
if not name or name == "New Package":
name = f.name
fpath = join(PYLOAD.getConfigValue("general", "download_folder"), "tmp_" + f.filename)
destination = open(fpath, 'wb')
copyfileobj(f.file, destination)
destination.close()
links.insert(0, fpath)
except:
pass
name = name.decode("utf8", "ignore")
links = map(lambda x: x.strip(), links)
links = filter(lambda x: x != "", links)
pack = PYLOAD.addPackage(name, links, queue)
if pw:
pw = pw.decode("utf8", "ignore")
data = {"password": pw}
PYLOAD.setPackageData(pack, data)
def edit_package():
try:
id = int(request.forms.get("pack_id"))
data = {"name": request.forms.get("pack_name").decode("utf8", "ignore"),
"folder": request.forms.get("pack_folder").decode("utf8", "ignore"),
"password": request.forms.get("pack_pws").decode("utf8", "ignore")}
PYLOAD.setPackageData(id, data)
return {"response": "success"}
except:
return HTTPError()
