def verify_email():
username = request.params.get('username', None)
veriCode = request.params.get('veriCode', None)
dbMgr = MmrzSyncDBManager("USERS")
users = dbMgr.read_USERS_DB_DICT()
now = int(time.time())
veriCode_from_client = veriCode
veriCode_from_db = users[username]["veriCode"]
deadline = users[username]["deadline"]
if veriCode_from_client == veriCode_from_db:
if now < deadline:
dbMgr.update_USERS_DB_mailAddr(username, users[username]["mail_new"])
dbMgr.update_USERS_DB_mail_new(username, "")
dbMgr.update_USERS_DB_mailModTime(username)
message = "??, ??????"
else:
message = "??????, ????????"
else:
message = "?????, ???"
dbMgr.closeDB()
return message
python类get()的实例源码
def show_favoritebook():
username = request.params.get('username', None)
# username not available means username exist, connect it
if not is_username_available(username):
dbMgr = MmrzSyncDBManager(username)
rows = dbMgr.read_FAVOURITE_DB()
dbMgr.closeDB()
# else user name not exist, redirect to /
else:
redirect('/')
rows_for_return = []
for row in rows:
row = list(row)
wordID = row[0]
word = row[1]
pronounce = row[2]
favourite = row[3]
rows_for_return.append(row)
return_dict = dict(universal_ROUTE_dict)
return_dict.update(dict(rows=rows_for_return))
return return_dict
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 unmemorized_words():
username = request.params.get('username', None)
password = request.params.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"
dict_for_return['wordbook'] = []
dict_for_return['wordfavourite'] = []
json_for_return = json.dumps(dict_for_return)
return json_for_return
else:
timeStamp = int(time.time())
dbMgr = MmrzSyncDBManager(username)
dbMgr.createDB()
rows = dbMgr.readDB(timeStamp)
fav = dbMgr.read_WORD_FAVOURITE_DB(timeStamp)
dbMgr.closeDB()
dict_for_return['verified'] = True
dict_for_return['message_str'] = "Download success"
dict_for_return['wordbook'] = rows
dict_for_return['wordfavourite'] = fav
json_for_return = json.dumps(dict_for_return)
return json_for_return
def update_word_favourite():
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']
row = json.loads(row)
dbMgr = MmrzSyncDBManager(username)
dbMgr.createDB()
is_favourite = row[1]
if is_favourite == 0:
dbMgr.delete_FAVOURITE_DB(row[0])
dict_for_return['message_str'] = "???????"
else:
count = dbMgr.insert_CHECK_FAVOURITE_DB(row[0])
if count == 0 :
dbMgr.insert_FAVOURITE_DB(row)
dict_for_return['message_str'] = "?????"
else:
dict_for_return['message_str'] = "??????????"
dbMgr.closeDB()
dict_for_return['verified'] = True
dict_for_return['verified_info'] = row
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 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 database_info():
username = request.params.get('username', None)
dbMgr = MmrzSyncDBManager(username)
rows = dbMgr.readAllDB()
dbMgr.closeDB()
return json.dumps(rows)
def get_shortest_remind():
username = request.params.get('username', None)
if not is_username_available(username):
dbMgr = MmrzSyncDBManager(username)
rows = dbMgr.getNearestRemindRow()
maxID = dbMgr.getMaxWordID()
dbMgr.closeDB()
if maxID == 0:
return "?????????"
rows = sorted(rows, key=lambda row: row[3]) # from small to big
word = rows[0][0]
pronounce = rows[0][1]
memTimes = rows[0][2]
remindTime = rows[0][3]
remindTimeStr = rows[0][4]
wordID = rows[0][5]
remindTime -= int(time.time())
days, hours, mins, secs = split_remindTime(remindTime, True)
remindTimeStr = "{0}d-{1}h-{2}m".format(days, hours, mins)
remindTimeStr = "???? {0} ???".format(remindTimeStr)
else:
remindTimeStr = "??????"
return remindTimeStr
def get_next_approximate_words_count():
username = request.params.get('username', None)
if not is_username_available(username):
dbMgr = MmrzSyncDBManager(username)
rows = dbMgr.readUnMemDB()
dbMgr.closeDB()
if not rows:
return ""
rows = sorted(rows, key=lambda row: row[3]) # from small to big
words_count = 1
for i in range(len(rows) - 1):
remindTime_next = rows[i + 1][3]
remindTime_this = rows[i][3]
if remindTime_next - remindTime_this <= 30 * 60:
words_count += 1
else:
break
words_count_string = "?? {0} ???".format(words_count)
else:
words_count_string = "??????"
return words_count_string
def get_weekly_mmrz_time():
username = request.params.get('username', None)
tikMgr = TikTimeDBManager()
weekly_data = tikMgr.getMiniutesDetailsByWeek(username, int(time.time()))
tikMgr.closeDB()
return json.dumps(weekly_data)
def add_organization_html(ending):
"""Submit an organization for scraping.
This shows an html page with a link to the status of the organization.
"""
organization = request.forms.get('organization')
scraper.scrape_organization(organization)
if ending == "json":
return {"status": "ok", "urls": api.get_organization_urls(organization)}
return template("added-organization.html", organization=organization)
def get_all_organizations(ending):
"""List all organizations with links to their statuses."""
start = int(request.query.get("offset", 0))
count = min(int(request.query.get("limit", DEFAULT_PAGINATION_COUNT)), MAX_PAGINATION_COUNT)
if ending == "json":
return api.get_organizations(start, count)
return template("organizations.html", start=start, count=count)
def add_repository(ending):
"""Sumbit a repository for scraping
This shows an html page with a link to the status of the repository.
"""
repository = request.forms.get('repository')
organization_name, repository_name = repository.split("/")
scraper.scrape_repository(repository)
if ending == "json":
return {"status": "ok", "urls": api.get_repository_urls(organization_name, repository_name)}
return template("added-repository.html", repository=repository)
def add_authentication():
"""Add `username` and `password` to those usable to scrape github.
They will be tried and removed if invalid.
"""
# http://bottlepy.org/docs/dev/tutorial.html#http-request-methods
username = request.forms.get('username')
password = request.forms.get('password')
if check_login((username, password)):
credentials.add((username, password))
return static("add-github-authentication-success.html")
return static("add-github-authentication-failure.html")
def get_media():
page = int(request.params.get('page', 0))
media_dir = app._config['henet']['media_dir']
files, total_pages = parse_files(media_dir, page)
return {'files': files, 'page': page,
'now': datetime.datetime.now(),
'total_pages': total_pages,
'current_page': page,
'csrf_token': request.csrf_token}
def login_handler():
msg = bottle.request.query.get('msg', '')
return handler_util.render('login.html', {'msg': msg})
def profile_handler():
user = handler_util.get_current_user()
msg = bottle.request.query.get('msg', '')
return handler_util.render('profile.html', {'user': user, 'msg': msg})
