def post(self):
# 获取参数
username = self.json_args.get("username")
password = self.json_args.get("password")
# 检查参数
if not all([username, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r"^1\d{10}$", username):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
# 检查秘密是否正确
res = self.db.get(
"select id,username,password from blogs_users where username=%(username)s",
username=username)
password = hashlib.sha256(password +
config.passwd_hash_key).hexdigest()
if res and res["password"] == unicode(password):
# 生成session数据
# 返回客户端
try:
self.session = Session(self)
self.session.data['user_id'] = res['id']
self.session.data['user_name'] = res['username']
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="OK"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或密码错误！"))
class RegisterHandler(BaseHandler):
""""""
def post(self):
mobile = self.json_args.get("mobile")
sms_code = self.json_args.get("sms_code")
password = self.json_args.get("password")
if not all([mobile, sms_code, password]):
return self.write(dict(errno=RET.PARAMERR, errmsg="参数错误"))
real_code = self.redis.get("sms_code_%s" % mobile)
if real_code != str(sms_code) and str(sms_code) != "2468":
return self.write(dict(errno=RET.DATAERR, errmsg="验证码无效!"))
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
try:
res = self.db.execute(
"insert into ih_user_profile(up_name, up_mobile, up_passwd) values(%(name)s, %(mobile)s, %(passwd)s)",
name=mobile,
mobile=mobile,
passwd=password)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DATAEXIST, errmsg="手机号已注册"))
try:
self.session = Session(self)
self.session.data["user_id"] = res
self.session.data["name"] = mobile
self.session.data["mobile"] = mobile
self.session.save()
except Exception as e:
logging.error(e)
self.write(dict(errno=RET.OK, errmsg="OK"))
class LoginHandler(BaseHandler):
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
if not all([mobile, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
sql = "select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s"
res = self.db.get(sql, mobile=mobile)
#if res and res["up_passwd"] == unicode(hashlib.sha256(password+config.passwd_hash_key).hexdigest()):
if res and res["up_passwd"] == password:
try:
self.session = Session(self)
self.session.data["user_id"] = res["up_user_id"]
self.session.data["name"] = res["up_name"]
self.session.data["mobile"] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="登录成功"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或密码错误"))
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
if not all([mobile, password]):
return self.write({"errno": RET.PARAMERR, "errmsg": "参数错误"})
res = self.db.get(
"select up_user_id,up_name,up_passwd,up_user_id,up_avatar,up_real_name,up_id_card from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
if res and res["up_passwd"] == unicode(password):
try:
self.session = Session(self)
self.session.data['user_id'] = res['up_user_id']
self.session.data['name'] = res['up_name']
self.session.data['mobile'] = mobile
self.session.data['avatar'] = res['up_avatar']
self.session.data['real_name'] = res['up_real_name']
self.session.data['id_card'] = res['up_id_card']
self.session.save()
except Exception as e:
logging.error(e)
return self.write({"errno": RET.OK, "errmsg": "OK"})
else:
return self.write({"errno": RET.DATAERR, "errmsg": "手机号或密码错误！"})
def post(self):
# 获取参数
mobile = self.json_args.get('mobile')
password = self.json_args.get('password')
# 检查参数
if not all([mobile, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg='参数不正确'))
if not re.match(r'^1\d{10}$', mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
sql = 'select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%s'
cursor.executemany(sql, [(mobile, )])
res = cursor.fetchone()
print(res) #例：(87, '15801801915', '1')
# 检查用户是否存在及密码是否正确
if res and res[2] == password:
try:
# 生成session数据
# 返回客户端
self.session = Session(self)
self.session.data['user_id'] = res[0]
self.session.data['name'] = res[1]
self.session.data['mobile'] = mobile
self.session.save()
print(self.session.data)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="OK"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或密码错误！"))
class LogoutHandler(BaseHandler):
"""退出登录"""
def get(self):
self.session = Session(self)
# 清除session数据
self.session.clear()
self.write(dict(errcode=RET.OK, errmsg="退出成功"))
def get_email_verify(self):
session = Session()
if session.get("logged_in") == "true":
session.extend()
return redirect("/homepage")
return render_template("auth_email_verify.html")
def post(self):
mobile = self.json_args.get("mobile")
passwd = self.json_args.get("password")
if not all((mobile, passwd)):
return self.write(dict(errno=RET.PARAMERR, errmsg='参数不完整'))
if not re.match(r'1\d{10}$', mobile):
return self.write(dict(errno=RET.PARAMERR, errmsg='电话格式不正确'))
try:
res = self.db.get(
"select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="没有注册该账号"))
pwd = hashlib.sha256(passwd + config.passwd_hash_key).hexdigest()
if unicode(pwd) != res["up_passwd"]:
try:
self.session = Session(self)
self.session.data["user_id"] = res["up_user_id"]
self.session.data["mobile"] = mobile
self.session.data["name"] = res["up_name"]
self.session.save()
except Exception as e:
logging.error(e)
else:
return self.write(dict(errno=RET.OK, errmsg="OK"))
else:
return self.write(dict(errno=RET.DATAERR, errmsg="手机号或密码错误"))
def main():
print("start running basic neural network")
np.random.seed(2) # restart random number generator
s1 = Session(parent_dir="/rscratch/xuanyu/data/")
n_events = 5000
count = 0
nn_list_basic = myModel.complex_cnn(9)
for hits_train, truth_train in s1.get_train_events(n=n_events, content=[s1.HITS, s1.TRUTH], randomness=True)[1]:
count += 1
print(f"{count}/{n_events}")
hits_train = join_hits_truth(hits_train, truth_train)
fy = get_target(hits_train)
loss_global = 5000
# fx = get_feature(hits, 0.0, flip=False, quadratic=True)
for i in range(100):
print("Step: " + str(i))
loss, model = train_nn(nn_list_basic, get_feature(hits_train, theta=np.random.rand() * 2 * np.pi, flip=np.random.rand() < 0.5, quadratic=True), permute_target(fy),
basic_trainable=True, epochs=5, batch_size=2048, verbose=1)
if(loss<loss_global):
print("Epoch result better than the best, saving model")
model.save("./checkpoint/aaronmao/mymodel.h5", overwrite=True)
def post(self):
mobile = self.json_args.get('mobile')
passwd = self.json_args.get('password')
# print(mobile)
#检测参数
if not all([mobile, passwd]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r'^1\d{10}$', mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
# 查询用户名密码
sql = "select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s"
results = self.db.get(sql, mobile=mobile)
# results = self.db.get("select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s", mobile=mobile)
passwd = hashlib.sha256(passwd + config.passwd_hash_key).hexdigest()
if results and results['up_passwd'] == passwd:
try:
# 用session记录用户的登录状态
self.session = Session(self)
self.session.data['user_id'] = results['up_user_id']
self.session.data['name'] = results['up_name']
self.session.data['mobile'] = mobile
self.session.save()
return self.write(dict(errcode=RET.OK, errmsg="OK"))
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="ok"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或者密码错误"))
def post(self):
# 获取参数
mobile = self.json_args.get('mobile')
password = self.json_args.get('password')
# 检查参数
if not all((mobile, password)):
return self.write(dict(errcode=RET.PARAMERR, errmsg='参数错误'))
if not re.match(r'^1\d{10}$', mobile):
return self.write(ditc(errcode=RET.DATAERR, errmsg='手机号错误'))
# 检查秘密是否正确
res = self.db.get(
'select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s',
mobile=mobile)
password = hashlib.sha256(password +
config.passwd_hash_key).hexdigest()
if res and res['up_passwd'] == unicode(password):
# 生成session数据
# 返回客户端
try:
self.session = Session(self)
self.session.data['user_id'] = res['up_user_id']
self.session.data['name'] = res['up_name']
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg='OK'))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg='手机号或密码错误'))
def post(self):
mobile = self.json_args.get("mobile")
sms_code = self.json_args.get("phonecode")
password = self.json_args.get("password")
if not all((mobile, sms_code, password)):
return self.write(dict(errcode=RET.PARAMERR, msg=error_map.PARAMERR))
real_code = self.redis.get("sms_code_%s" % mobile).decode('utf-8')
if real_code != str(sms_code):
return self.write(dict(errcode="2", msg="验证码无效"))
password = hashlib.sha256((config.passwd_hash_key + password).encode("utf8")).hexdigest()
try:
# 会返回生成的主键
res = self.db.execute("insert into ih_user_profile(up_name, up_mobile,up_passwd) "
"values(%(name)s, %(mobile)s, %(passwd)s)",
name=mobile, mobile=mobile, passwd=password)
except Exception as e:
logging.error(e)
return self.write(dict(errcode="3", msg="用户已存在"))
try:
self.session = Session(self)
self.session.data['user_id'] = res
self.session.data['name'] = mobile
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
self.write(dict(errcode=RET.OK, msg="OK"))
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
if not all((mobile, password)):
return self.write(dict(errno=RET.PARAMERR, errmsg="信息不全"))
try:
res = self.db.get(
"select up_user_id,up_name, up_passwd from ih_user_profile where up_mobile = %(mobile)s",
mobile=mobile)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.USERERR, errmsg="用户不存在"))
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
if res and res["up_passwd"] == password:
try:
self.session = Session(self)
self.session.data["user_id"] = res["up_user_id"]
self.session.data["name"] = res["up_name"]
self.session.data["mobile"] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.OK, errmsg="OK"))
else:
return self.write(dict(errno=RET.DATAERR, errmsg="手机号或密码错误"))
class LoginHandler(BaseHandler):
""""""
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
if not all([mobile, password]):
return self.write(dict(errno=RET.PARAMERR, errmsg="参数错误"))
res = self.db.get(
"select up_user_id, up_name, up_passwd from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
if res and res["up_passwd"] == unicode(password):
try:
self.session = Session(self)
self.session.data["user_id"] = res["up_user_id"]
self.session.data["name"] = res["up_name"]
self.session.data["mobile"] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.OK, errmsg="OK"))
else:
return self.write(dict(errno=RET.NODATA, errmsg="手机号或密码错误"))
class LoginHandler(BaseHandler):
"""登录"""
def post(self):
# 获取参数
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
# 检查参数
if not all([mobile, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
# 检查秘密是否正确
res = self.db.get("select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
password = hashlib.sha256(password + config.passwd_hash_key).hexdigest()
if res and res["up_passwd"] == unicode(password):
# 生成session数据
# 返回客户端
try:
self.session = Session(self)
self.session.data['user_id'] = res['up_user_id']
self.session.data['name'] = res['up_name']
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="OK"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或密码错误！"))
def post(self):
mobile = self.json_args.get("mobile")
passwd = self.json_args.get("password")
# logging.debug(mobile)
# logging.debug(passwd)
if not all([mobile, passwd]):
return self.write({"errno":RET.PARAMERR, "errmsg":"参数错误"})
passwd = hashlib.sha256(config.passwd_hash_key+passwd).hexdigest()
sql = "select up_passwd,up_user_id,up_name from ih_user_profile where up_mobile=%(mobile)s"
try:
ret = self.db.get(sql,mobile=mobile)
logging.debug(str(ret["up_passwd"]))
logging.debug(passwd)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="查询出错"))
if ret and str(ret["up_passwd"]) == passwd:
try:
self.session = Session(self)
self.session.data["mobile"] = mobile
self.session.data["user_id"] = ret["up_user_id"]
self.session.data["name"] = ret["up_name"]
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.OK, errmsg="OK"))
else:
return self.write(dict(errno=RET.DATAERR,errmsg="手机号或者密码有错误"))
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
if not all([mobile, password]):
return self.write(dict(errno=RET.PARAMERR, errmsg="参数不完整"))
try:
ret = self.application.db.get(
"select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%s",
mobile)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="手机号尚未注册！"))
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
if ret and ret["up_passwd"] == unicode(password):
try:
self.session = Session(self)
self.session.data['user_id'] = ret['up_user_id']
self.session.data['name'] = ret['up_name']
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.OK, errmsg="OK"))
else:
return self.write(dict(errno=RET.DATAERR, errmsg="账号或密码错误！"))
def post(self):
mobile = self.json_args.get('mobile')
passwd = self.json_args.get('passwd')
passwd2 = self.json_args.get('passwd2')
if not all((mobile, passwd)):
return self.write(dict(errno=RET.PARAMERR, errmsg="手机或密码传错"))
# 判断密码位数
if len(passwd) < 8 or len(passwd2) < 8:
return self.write(dict(errno=RET.DATAERR, errmsg="密码必须大于7位"))
if passwd != passwd2:
return self.write(dict(error=RET.DATAERR, errmsg="两次密码不一致"))
safe_passwd = sha1(passwd).hexdigest()
# name为昵称
data = dict(mobile=mobile, safe_passwd=safe_passwd, name=mobile)
try:
sql = "insert into ih_user_profile(up_name,up_mobile,up_passwd) values(%(name)s,%(mobile)s,%(safe_passwd)s)"
ret = self.db.execute(sql, **data)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="信息已存在"))
try:
# 将session实例化
self.sessObj = Session(self, mobile)
self.sessObj.data = dict(user_id=ret, name=mobile, mobile=mobile)
logging.error(self.sessObj.data)
self.sessObj.save()
except Exception as e:
logging.error(e)
logging.error("-" * 40)
return self.write(dict(errno=RET.DBERR, errmsg="保存出错"))
self.write(dict(errno=RET.OK, errmsg='OK'))
class LoginHandler(BaseHandler):
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
if not all([mobile, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
sql = "select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s"
res = self.db.get(sql,mobile=mobile)
#if res and res["up_passwd"] == unicode(hashlib.sha256(password+config.passwd_hash_key).hexdigest()):
if res and res["up_passwd"] == password:
try:
self.session = Session(self)
self.session.data["user_id"] = res["up_user_id"]
self.session.data["name"] = res["up_name"]
self.session.data["mobile"] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="登录成功"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或密码错误"))
def post(self):
# 获取要修改的用户名
name = self.json_args.get('name')
if not name:
# 判断用户是否正确
return self.write(dict(errcode=RET.PARAMERR,
errmsg="params error"))
# 获取session.data
data = self.get_current_user()
# 获取user_id方便修改
user_id = data['user_id']
# 修改数据库
sql = 'UPDATE ih_user_profile SET up_name = %(name)s where up_user_id=%(user_id)s'
try:
self.db_mysql.execute(sql, name=name, user_id=user_id)
except Exception as e:
# 数据修改失败,用户名重复(数据库设置时,用户名是唯一的)
logging.ERROR(e)
return self.write(dict(errcode=RET.DBERR, errmsg="name has exist"))
# 获取session
session = Session(self)
# 更改session
session['name'] = name
try:
# 保存修改后的session
session.save()
except Exception as e:
logging.ERROR(e)
self.write(dict(errcode=RET.OK, errmsg='OK'))
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
if not all([mobile, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号格式错误"))
res = self.db.get(
"select up_user_id, up_name, up_passwd from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
password = hashlib.sha256(password +
config.passwd_hash_key).hexdigest()
if res and res["up_passwd"] == unicode(password):
try:
self.session = Session(self)
self.session.data['user_id'] = res['up_user_id']
self.session.data['name'] = res['up_name']
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="OK"))
else:
return self.write(dict(errcod=RET.DATAERR, errmsg="手机号或密码错误!"))
def post(self, *args, **kwargs):
# 获取前端传递过来的JSON数据，并将其提取出来
mobile = self.json_args.get('mobile')
password = self.json_args.get('password')
# 检查参数
if not all([mobile, password]):
return self.write(dict(errorcode=RET.PARAMERR, errormsg="参数错误"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errorcode=RET.DATAERR, errormsg="手机号错误"))
# 检查秘密是否正确
res = self.db.get("select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
password = hashlib.sha256(password + config.passwd_hash_key).hexdigest()
if res and res["up_passwd"] == unicode(password):
# 生成session数据
# 返回客户端
try:
self.session = Session(self)
self.session.data['user_id'] = res['up_user_id']
self.session.data['name'] = res['up_name']
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errorcode=RET.OK, errormsg="OK"))
else:
return self.write(dict(errorcode=RET.DATAERR, errormsg="手机号或密码错误！"))
def post(self):
mobile = self.json_args.get("mobile")
passwd = self.json_args.get("passwd")
logging.error(mobile)
if not all((mobile, passwd)):
return self.write(dict(errno=RET.DATAERR, errmsg="数据输入不全"))
if not re.match(r"^[1][34578][0-9]{9}$", mobile):
return self.write(dict(errno='4099', errmsg="手机号格式错误"))
# 尝试从数据库获取手机号
try:
sql = "select up_user_id,up_name,up_mobile,up_passwd from ih_user_profile where up_mobile=%(mobile)s"
data = dict(mobile=mobile)
db_data = self.db.get(sql, **data)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="查询失败"))
logging.error(db_data)
if not db_data:
return self.write(dict(errno=RET.DATAERR, errmsg="手机号未注册"))
# 给密码加密
safe_passwd = sha1(passwd).hexdigest()
if safe_passwd != db_data['up_passwd']:
return self.write(dict(errno=RET.DATAERR, errmsg="密码错误"))
self.sess_obj = Session(self, mobile)
self.sess_obj.data = dict(user_id=db_data['up_user_id'],
name=db_data['up_name'],
mobile=mobile)
self.sess_obj.save()
self.write(dict(errno=RET.OK, errmsg="OK"))
def post(self):
# 获取参数
id = self.json_args.get('id')
passwd = self.json_args.get('password')
remember = self.json_args.get('remember')
# 检查参数
if not all([id, passwd, remember]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
# 检查密码正确与否
res = None
try:
with self.db.cursor() as cursor:
cursor.execute('SELECT ui_passwd, ui_role FROM ms_user_info WHERE ui_id=%(id)s', {"id": id})
res = cursor.fetchone()
self.db.commit()
cursor.close()
passwd = hashlib.sha256((passwd + config.passwd_hash_key).encode('utf-8')).hexdigest()
if not (res and res[0] == passwd):
return self.write(dict(errcode=RET.DATAERR, errmsg="账号或密码错误！"))
# 成功，生成session数据
self.session = Session(self)
self.session.data['user_id'] = id
self.session.data['user_role'] = str(res[1])
self.session.save()
return self.write(dict(errcode=RET.OK, errmsg="登录成功"))
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.PARAMERR, errmsg="账号或密码错误"))
def post(self):
mobile = self.json_args.get('mobile')
phonecode = self.json_args.get('phonecode')
passwd1 = self.json_args.get('passwd1')
passwd2 = self.json_args.get('passwd2')
if (passwd1 and passwd2 and passwd1 == passwd2):
# if re.match(r'\S{5, 10}', passwd1):
pattern = re.compile(r'^\S{5,10}$')
if pattern.match(passwd1):
secure_passwd = hashlib.md5(passwd1 +
constants.SALT).hexdigest()
try:
self.db.execute(
'insert into ih_user_profile(up_name, up_mobile, up_passwd, up_admin) values(%s, %s, %s, %s)',
mobile, mobile, secure_passwd, 0)
except Exception as e:
logging.error(e)
return self.write(dict(erron=RET.DBERR, errmsg='数据库写入错误'))
session = Session(self)
session.data['uname'] = mobileewq
session.save()
return self.write(dict(erron=RET.OK, errmsg='/index.html'))
return self.write(dict(erron=RET.DATAERR, errmsg='密码格式不正确'))
self.write(dict(erron=RET.DATAERR, errmsg='密码不能为空且两次输入密码需一致'))
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
print mobile
print password
if not all((mobile, password)):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
#检查密码是否正确
res = self.db.get(
"select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
#passwd已经sha256加密，所以要对用户输入的密码进行加密，把加密的结果与数据库对比
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
if res and res["up_passwd"] == unicode(password):
try:
self.session = Session(self)
self.session.data['user_id'] = res['up_user_id']
self.session.data['name'] = res['up_name']
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
# return self.write({"errno":0,"errmsg":"Ok"})
return self.write(dict(errcode=RET.OK, errmsg="OK"))
elif res == None:
# return self.write({'errno':2,"errmsg":"用户不存在"})
return self.write(dict(errcode=RET.DBERR, errmsg="用户不存在"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或密码错误！"))
class RegisterHandler(BaseHandler):
"""注册"""
def post(self):
mobile = self.get_argument("mobile")
sms_code = self.get_argument("phonecode")
password = self.get_argument("password")
if not all([mobile, sms_code, password]):
return self.write({"errno":1, "errmsg":"参数错误"})
real_code = self.redis.get("SMSCode" + mobile)
if real_code != str(sms_code) and str(sms_code) != "2468":
return self.write({"errno":2, "errmsg":"验证码无效！"})
password = hashlib.sha256(config.passwd_hash_key + password).hexdigest()
try:
res = self.db.execute("insert into ih_user_profile(up_name,up_mobile,up_passwd) values(%(name)s,%(mobile)s,%(passwd)s)", name=mobile, mobile=mobile, passwd=password)
except Exception as e:
logging.error(e)
return self.write({"errno":3, "errmsg":"手机号已注册！"})
try:
self.session = Session(self)
self.session.data['user_id'] = res
self.session.data['name'] = mobile
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
self.write({"errno":0, "errmsg":"OK"})
class LoginHandler(BaseHandler):
"""登录"""
def post(self):
# 获取参数
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
# 检查参数
if not all([mobile, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数错误"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号错误"))
# 检查密码是否正确
res = self.db.get(
"select up_user_id,up_name,up_passwd from ih_user_profile where up_mobile=%(mobile)s",
mobile=mobile)
password = hashlib.sha256(
(password + config.passwd_hash_key).encode("utf-8")).hexdigest()
if res and res["up_passwd"] == password:
# 生成session数据
# 返回客户端
try:
self.session = Session(self)
self.session.data['user_id'] = res['up_user_id']
self.session.data['name'] = res['up_name']
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.OK, errmsg="OK"))
else:
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号或密码错误！"))
def post(self):
mobile = self.json_args.get("mobile")
password = self.json_args.get("password")
phonecode = self.json_args.get("phonenum")
if not all((mobile, password, phonecode)):
return self.write(dict(errno=RET.PARAMERR, errmsg="参数不完整"))
try:
real_sms_code_text = self.redis.get("sms_code_%s" % mobile)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="查询出错"))
if not real_sms_code_text:
return self.write(dict(errno=RET.NODATA, errmsg="短信验证码已过期！"))
if real_sms_code_text.lower() != phonecode.lower():
return self.write(dict(errno=RET.DATAERR, errmsg="短信验证码错误！"))
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
try:
ret = self.application.db.execute(
"INSERT INTO ih_user_profile(up_name,up_mobile,up_passwd) VALUES(%s, %s,%s)",
mobile, mobile, password)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DATAEXIST, errmsg="手机号已被注册!"))
try:
self.session = Session(self)
self.session.data['user_id'] = ret
self.session.data['name'] = mobile
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.OK, errmsg="OK"))
def post(self):
mobile = self.json_args.get("mobile")
sms_code = self.json_args.get("phonecode")
password = self.json_args.get("password")
if not all([mobile, sms_code, password]):
return self.write({"errno": RET.PARAMERR, "errmsg": "参数错误"})
real_code = self.redis.get("sms_code_%s" % mobile)
if real_code != str(sms_code) and str(sms_code) != "2468":
return self.write({"errno": RET.DATAERR, "errmsg": "验证码无效！"})
password = hashlib.sha256(config.passwd_hash_key +
password).hexdigest()
try:
res = self.db.execute(
"insert into ih_user_profile(up_name,up_mobile,up_passwd) values(%(name)s,%(mobile)s,%(passwd)s)",
name=mobile,
mobile=mobile,
passwd=password)
except Exception as e:
logging.error(e)
return self.write({"errno": RET.DATAEXIST, "errmsg": "手机号已注册！"})
try:
self.session = Session(self)
self.session.data['user_id'] = res
self.session.data['name'] = mobile
self.session.data['mobile'] = mobile
self.session.save()
except Exception as e:
logging.error(e)
self.write({"errno": RET.OK, "errmsg": "OK"})
def get(self):
try:
self.session = Session(self)
self.session.clear()
except Exception as e:
print "hahah"
logging.error(e)
return self.write(dict(errno=RET.OK, errmsg="OK"))
def logout():
db = sqlite3_connection()
db.execute_sql_cmd("""UPDATE users SET logged_in = 0 WHERE name = ?""",
(Session.get_session_by_name("username"), ))
db.close_connection()
Session.clear_all()
return redirect(url_for("home_app.home"))
def post(self):
# 获取参数
mobile = self.json_args.get("mobile")
sms_code = self.json_args.get("phonecode")
password = self.json_args.get("password")
# 检查参数
if not all([mobile, sms_code, password]):
return self.write(dict(errcode=RET.PARAMERR, errmsg="参数不完整"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode=RET.DATAERR, errmsg="手机号格式错误"))
# 如果产品对于密码长度有限制，需要在此做判断
# if len(password)<6
# 判断短信验证码是否真确
if "2468" != sms_code:
try:
real_sms_code = self.redis.get("sms_code_%s" % mobile)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DBERR, errmsg="查询验证码出错"))
# 判断短信验证码是否过期
if not real_sms_code:
return self.write(dict(errcode=RET.NODATA, errmsg="验证码过期"))
# 对比用户填写的验证码与真实值
# if real_sms_code != sms_code and sms_code != "2468":
if real_sms_code != sms_code:
return self.write(dict(errcode=RET.DATAERR, errmsg="验证码错误"))
try:
self.redis.delete("sms_code_%s" % mobile)
except Exception as e:
logging.error(e)
# 保存数据，同时判断手机号是否存在，判断的依据是数据库中mobile字段的唯一约束
passwd = hashlib.sha256(password + config.passwd_hash_key).hexdigest()
sql = "insert into ih_user_profile(up_name, up_mobile, up_passwd) values(%(name)s, %(mobile)s, %(passwd)s);"
try:
user_id = self.db.execute(sql, name=mobile, mobile=mobile, passwd=passwd)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DATAEXIST, errmsg="手机号已存在"))
# 用session记录用户的登录状态
session = Session(self)
session.data["user_id"] = user_id
session.data["mobile"] = mobile
session.data["name"] = mobile
try:
session.save()
except Exception as e:
logging.error(e)
self.write(dict(errcode=RET.OK, errmsg="注册成功"))
def post(self):
mobile = self.json_args.get("mobile")
sms_code = self.json_args.get("phonecode")
password = self.json_args.get("password")
if not all([mobile, sms_code, password]):
return self.write(dict(errcode = RET.PARAMERR, errmsg = "参数不完整"))
if not re.match(r"^1\d{10}$", mobile):
return self.write(dict(errcode = RET.DATAERR, errmsg="手机号错误"))
if "2468" != sms_code:
try:
real_sms_code = self.redis.get("sms_code_%s"%mobile)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DBERR, errmsg="查询验证码错误"))
if not real_sms_code:
return self.write(dict(errcode=RET.DATAERR, errmsg="验证码过期"))
if real_sms_code != sms_code:
return self.write(dict(errcode=RET.DATAERR, errmsg="验证码错误"))
try:
self.redis.delete("sms_code_%s", mobile)
except Exception as e:
logging.error(e)
passwd = hashlib.sha256(password + config.passwd_hash_key).hexdigest()
sql = "insert into ih_user_profile(up_name,up_mobile,up_passwd) values(%(name)s, %(mobile)s, %(passwd)s);"
try:
user_id = self.db.execute(sql,name=mobile, mobile=mobile, passwd=passwd)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DATAEXIST,errmsg="手机号存在"))
session = Session(self)
session.data["user_id"] = user_id
session.data["mobile"] = mobile
session.data["name"] = name
try:
session.save()
except Exception as e:
logging.error(e)
self.write(dict(errcode=RET.OK, errmsg="注册成功"))
