def post(self):
# 获取参数
mobile = self.json_args.get("mobile")
image_code_id = self.json_args.get("image_code_id")
image_code_text = self.json_args.get("image_code_text")
if not all((mobile, image_code_id, image_code_text)):
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:
real_image_code_text = self.redis.get("image_code_%s" % image_code_id)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="查询出错"))
if not real_image_code_text:
return self.write(dict(errno=RET.NODATA, errmsg="验证码已过期！"))
if real_image_code_text.lower() != image_code_text.lower():
return self.write(dict(errno=RET.DATAERR, errmsg="验证码错误！"))
# 若成功：
# 生成随机验证码
sms_code = "%04d" % random.randint(0, 9999)
try:
self.redis.setex("sms_code_%s" % mobile, constants.SMS_CODE_EXPIRES_SECONDS, sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="生成短信验证码错误"))
# 发送短信
try:
ccp.sendTemplateSMS(mobile, [sms_code, constants.SMS_CODE_EXPIRES_SECONDS/60], 1)
# 需要判断返回值，待实现
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.THIRDERR, errmsg="发送失败！"))
self.write(dict(errno=RET.OK, errmsg="OK"))
def post(self):
"获取ajax传入的数据"
mobile = self.json_args.get("mobile")
image_code_id = self.json_args.get("image_code_id")
image_code_text = self.json_args.get("image_code_text")
"参数没有获取到，或者获取不全"
if not all((mobile, image_code_id, image_code_text)):
return self.write(dict(errno=RET.PARAMERR, errmsg="参数不完整"))
"手机号输入不正确返回手机号错误"
if not re.match(r"^[1][34578][0-9]{9}$", mobile):
return self.write(dict(errno='4099', errmsg="手机号错误"))
# 判断图片验证码
try:
"从redis查询验证码text，验证码获取，失败则返回查询错误"
real_image_code_text = self.redis.get("image_code_%s" %
image_code_id)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="查询出错"))
"从数据库拿出的信息为空，则说明验证码已经再redis中过期"
if not real_image_code_text:
return self.write(dict(errno=RET.NODATA, errmsg="验证码已过期！"))
"将redis中的验证码text和ajax传入的text，进去小写格式后比较,错误返回验证码错误"
if real_image_code_text.lower() != image_code_text.lower():
return self.write(dict(errno=RET.DATAERR, errmsg="验证码错误！"))
"判断手机号是否已经注册"
sql = "select up_mobile from ih_user_profile where up_mobile=%s" % mobile
try:
ret = self.db.get(sql)
except Exception as e:
logging.error(e)
if ret:
return self.write(dict(errno=RET.DATAEXIST, errmsg='手机号已存在'))
# 若成功：
# 生成随机验证码4位
sms_code = "%04d" % random.randint(0, 9999)
try:
"将生成的短信验证码放到数据库，失败返回验证码生成错误"
self.redis.setex("sms_code_%s" % mobile,
constants.SMS_CODE_EXPIRES_SECONDS, sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="生成短信验证码错误"))
# 发送短信
try:
"""
sendTemplateSMS(to,datas,tempId)
to目标手机号，datas发送数据int，时间，tempId模板编号
发送短信，成功则将状态返回为OK，失败则返回发送失败
"""
ccp.sendTemplateSMS(
mobile, [sms_code, constants.SMS_CODE_EXPIRES_SECONDS / 60], 1)
# 需要判断返回值，待实现
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.THIRDERR, errmsg="发送失败！"))
self.write(dict(errno=RET.OK, errmsg="OK"))
def post(self):
"""
1.判断三个参数是否齐全
2.对比验证码与redis中存储的是否一致，不一致，返回错误信息
3.如果一致,生成随机数
4.将随机数存储到redis中
5.将数据发送给用户
}
"""
mobile = self.json_args.get("mobile")
imageCode = self.json_args.get("imageCode")
codeId = self.json_args.get("codeId")
# 参数完整性验证
if not all((mobile, imageCode, codeId)):
return self.write(dict(errorno=RET.PARAMERR, errmsg=u'参数不完整'))
# 手机号相关验证
if not ReTools.isPhoneNum(mobile):
return self.write(dict(errorno=RET.PARAMERR, errmsg=u'请输入正确的手机号'))
# 验证手机号是否存在
else:
sql = "select up_mobile from ih_user_profile where up_mobile=%s"
try:
ret = self.db.get(sql, mobile)
except Exception as e:
return self.write(dict(errorno=RET.DBERR, errmsg=u'数据库查询错误'))
else:
if ret:
return self.write(dict(errorno=RET.DATAEXIST, errmsg=u'手机号已被注册'))
# 判断图片验证码
code = 'image_code_%s' % codeId
try:
redis_imgcode = self.redis.get(code)
except Exception as e:
logging.error(e)
return self.write(dict(errorno=RET.DBERR, errmsg=u'Redis数据库查询错误'))
else:
if not redis_imgcode:
return self.write(dict(errorno=RET.NODATA, errmsg=u'没有查询到的数据'))
if imageCode.lower() != redis_imgcode.lower():
return self.write(dict(errorno=RET.DATAERR, errmsg=u'验证码匹配错误'))
# 设置短信验证码
note = "%04d" % random.randint(0, 9999)
try:
self.redis.setex('sms_code_%s' % mobile, SMS_EXPIRE_SECONDS, note)
except Exception as e:
logging.error(e)
return self.write(dict(errorno=RET.DBERR, errmsg=u'数据库有误'))
else:
ccp.sendTemplateSMS(mobile, [note, SMS_EXPIRE_SECONDS / 60], 1)
return self.write(dict(errorno=RET.OK, errmsg=u'OK'))
def post(self):
#获取参数(json)
mobile = self.json_args.get("mobile")
image_code_id = self.json_args.get("image_code_id")
image_code_text = self.json_args.get("image_code_text")
#判断参数是否完整
if not all((mobile,image_code_id,image_code_text)):
return self.write(dict(errcode=RET.PARAMERR,errmsg="参数错误"))
#利用正则表达式判断号码输入是否正确
if not re.match(r"1\d{10}",mobile):
return self.write(dict(errcode=RET.PARAMERR,errmsg="手机号码输入错误"))
#判断图片验证码
try:
real_image_text = self.redis.get("image_code_%s"%image_code_id)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DBERR,errmsg="查询出错"))
#不成功 返回错误信息
#如果没有这个验证码
if not real_image_text:
return self.write(dict(errcode=RET.NODATA,errmsg="验证码过期"))
if real_image_text.lower() != image_code_text.lower():
return self.write(dict(errcode=RET.DATAERR,errmsg="验证码错误"))
#若成功 生成随机验证码
sms_code = "%04d" %random.randint(0,9999)
try:
#把验证码写进redis key:mobile 并设置过期时间，value:sms_code
self.redis.setex("sms_code_%s"%mobile,constants.SMS_CODE_EXPIRES_SECONDS,sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DBERR,errmsg="生成验证码错误"))
# 手机号是否存在检查
sql = "select count(*) counts from ih_user_profile where up_mobile=%s"
try:
ret = self.db.get(sql, mobile)
except Exception as e:
logging.error(e)
else:
if 0 != ret["counts"]:
return self.write(dict(errcode=RET.DATAEXIST, errmsg="手机号已注册"))
#发送短信
try:
ccp.sendTemplateSMS(mobile,[sms_code,constants.SMS_CODE_EXPIRES_SECONDS/60],1)
#需要判断返回值，待实现
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.THIRDERR,errmsg="发送失败"))
self.write(dict(errcode=RET.OK,errmsg="OK"))
def post(self):
# 获取参数
# mobile = self.json_args.get('mobile')
# print mobile
mobile = self.get_argument('mobile')
print mobile
# 判断有没有值
if not any(mobile):
print "mobile is empty"
return self.write(dict(error_code=RET.PARAMERR, error_msg='参数不完整'))
# 判断手机号格式
if len(mobile) != 11:
return self.write(dict(error_code=RET.PARAMERR, error_msg='手机号错误'))
if not re.match(r'^1[3|4|5|7|8][0-9]\d{4,8}$', mobile):
return self.write(
dict(error_code=RET.PARAMERR, error_msg='手机号格式错误'))
print "-" * 40
# 生产随机短信验证码
sms_code = '%04d' % random.randint(0, 9999)
# 把生成的验证码code存入redis
try:
self.redis.set('sms_code_%s' % mobile, sms_code,
SMS_CODE_EXPRIES_SECONDS * 60)
except Exception as e:
logging.error(e)
return self.write(dict(error_code=RET.DBERR,
error_msg='生产短信验证码错误'))
# 发送短信
try:
ccp.sendTemplateSMS(mobile, [sms_code, SMS_CODE_EXPRIES_SECONDS],
1)
except Exception as e:
logging.error(e)
return self.write(
dict(error_code=RET.THIRDERR, error_msg='发送短信验证码失败'))
# 返回成功
self.write(dict(error_code=RET.OK, error_msg='ok'))
def post(self):
# 获取参数
# mobile = self.json_args.get("mobile")
# image_code_id = self.json_args.get("image_code_id")
# image_code_text = self.json_args.get("image_code_text")
data = json.loads(self.get_argument("data"))
mobile = data.get('mobile')
image_code_id = data.get('image_code_id')
image_code_text = data.get('image_code_text')
# 参数校验
if not all((mobile, image_code_id, image_code_text)):
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:
real_image_code_text = self.redis.get("image_code_%s" %
image_code_id)
real_image_code_text = real_image_code_text.decode('ascii')
except Exception as e:
return self.write(dict(errno=RET.DBERR, errmsg="查询错误"))
if not real_image_code_text:
return self.write(dict(errno=RET.NODATA, errmsg="验证码过期"))
if real_image_code_text.lower() != image_code_text.lower():
return self.write(dict(errno=RET.DATAERR, errmsg="验证码错误"))
# 若成功
# 生成随机验证码
sms_code = "%04d" % random.randint(0, 9999)
try:
self.redis.setex(("sms_code_%s" % mobile),
constants.SMS_CODE_EXPIRES_SECONDS, sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="数据库出错"))
# 发送短信
try:
result = ccp.sendTemplateSMS(
mobile, 1, [sms_code, constants.SMS_CODE_EXPIRES_SECONDS / 60])
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.THIRDERR, errmsg="发送短信失败"))
if result:
self.write(dict(errcode=RET.OK, errmsg="发送成功"))
else:
self.write(dict(errcode=RET.UNKOWNERR, errmsg="发送失败"))
def post(self):
# usr_data = self.get_body_argument("")
# phone = usr_data["mobile"]
# ic_id = usr_data["image_code_id"]
# ic_text = usr_data["image_code_text"]
# if self.redis.get("ic_id") == ic_text:
# ccp = _CCP.instance()
# ccp.sendTemplateSMS(phone,[,5],1)
# 获取参数
mobile = self.json_args.get("mobile")
image_code_id = self.json_args.get("image_code_id")
image_code_text = self.json_args.get("image_code_text")
# 判断参数是否完整
if not all((mobile,image_code_id,image_code_text)):
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:
real_image_code_text = self.redis.get("image_code_%s"%image_code_id)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR,errmsg="查询出错"))
if not real_image_code_text:
return self.write(dict(errno=RET.NODATA,errmsg="验证码已过期！"))
if real_image_code_text.lower() != image_code_text.lower():
return self.write(dict(errno=RET.DATAERR,errmsg="验证码错误！"))
# 若验证成功，生成随机验证码
sms_code = "%04d"%random.randint(0,9999)
try:
self.redis.setex("sms_code_%s"%mobile,constants.SMS_CODE_EXPIRES_SECONDS,sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR,errmsg="生成短信验证码错误"))
# 发送短信
try:
ccp.sendTemplateSMS(mobile,[sms_code,constants.SMS_CODE_EXPIRES_SECONDS/60],1)
except Exception as e:
logging.error(e)
self.write(dict(errno=RET.OK,errmsg="OK"))
def post(self):
mobile = self.json_args.get("mobile")
image_code_id = self.json_args.get("image_code_id")
image_code_text = self.json_args.get("image_code_text")
if not all((mobile, image_code_id, image_code_text)):
return self.write(dict(errno=RET.PARAMERR, errmsg="参数不完整"))
if not re.match(r"1\d{10}",mobile):
return self.write(dict(errno=RET.RARAMERR, errmsg="手机号错误"))
try:
real_image_code_text = self.redis.get("image_code_%s"%image_code_id)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="数据库查询出错"))
if not real_image_code_text:
return self.write(dict(errno=RET.NODATA, errmsg="验证码已过期"))
if real_image_code_text.lower() != image_code_text.lower():
return self.write(dict(errno=RET.DATAERR, errmsg="验证码错误"))
#检查手机号是否存在:
try:
res = self.db.get("select count(*) counts from ih_user_profile where up_mobile=%(mobile)s",mobile=mobile)
except Exception as e:
logging.error(e)
else:
if 0 != res['counts']:
return self.write(dict(errno=RET.DATAEXIST, errmsg="该手机号已存在"))
sms_code = "%04d" % random.randint(0, 9999)
try:
self.redis.setex("sms_code_%s" % mobile, constants.SMS_CODE_EXPIRES_TIME, sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.BDERR, errmsg="生成短信验证码错误"))
try:
ccp.sendTemplateSMS(mobile, [sms_code, constants.SMS_CODE_EXPIRES_TIME], 1)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.THIRDERR, errmsg="发送失败!"))
self.write(dict(errno=RET.OK, errmsg="OK"))
def post(self):
# 获取参数
mobile = self.json_args.get("mobile")
image_code_id = self.json_args.get("image_code_id")
image_code_text = self.json_args.get("image_code_text")
if not all((mobile, image_code_text, image_code_id)):
return self.write(dict(errno=RET.PARAMERR, errmsg="参数不完整"))
if not match(r'1\d{10}', mobile):
return self.write(dict(errno=RET.PARAMERR, errmsg="手机号格式错误"))
# 判断手机号是否已经注册
sql = "SELECT up_user_id FROM ih_user_profile WHERE up_mobile = %s"
if self.db.get(sql, mobile):
return self.write(dict(errno=RET.DATAEXIST, errmsg="该手机号已经注册过"))
# 判断距上次成功发送是否超过60秒
try:
self.redis.get("sms_time_%s" % mobile)
except Exception as e:
logging.error(e)
logging.error("不到60秒,多次请求")
return self.write(dict(errno=RET.REQERR, errmsg="不到60秒"))
# 判断图片验证码
try:
real_image_code_text = self.redis.get("image_code_%s" %
image_code_id)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="查询出错"))
# 判断是否过期
if not real_image_code_text:
return self.write(dict(errno=RET.NODATA, errmsg="验证码失效"))
if real_image_code_text.lower() != image_code_text.lower():
return self.write(dict(errno=RET.DATAERR, errmsg="验证码错误！"))
# 若成功：
# 生成随机短信验证码
sms_code = "%04d" % randint(0, 9999)
try:
self.redis.setex("sms_code_%s" % mobile,
constants.SMS_CODE_EXPIRES_SECONDS, sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.DBERR, errmsg="生成验证码错误"))
# 发送短信
try:
json_sms_return_data = ccp.sendTemplateSMS(
mobile, [sms_code, constants.SMS_CODE_EXPIRES_SECONDS / 60], 1)
# 判断返回值
if not "000000" == json_sms_return_data["statusCode"]:
logging.error("yuntongxun SMS is error")
logging.error(json_sms_return_data.encode('utf8'))
logging.debug(type(json_sms_return_data))
return self.write(dict(errno=RET.THIRDERR, errmsg="短信发送错误"))
except Exception as e:
logging.error(e)
return self.write(dict(errno=RET.THIRDERR, errmsg="短信发送错误"))
self.redis.setex("sms_time_%s" % mobile,
constants.SMS_CODE_FORBIDDEN_EXPIRES, int(time()))
return self.write(dict(errno=RET.OK, errmsg="OK"))
def post(self):
print('json_dict为%s' % self.json_dict)
# 获取参数
mobile = self.json_dict['mobile']
piccode = self.json_dict['piccode']
piccode_id = self.json_dict['piccode_id']
# 参数校验
# if mobile and piccode and piccode_id
if not all((mobile, piccode, piccode_id)):
return self.write(dict(errcode=RET.DATAERR, errmsg='有未填的表单项'))
# 判断手机号
if not re.match(r'^1[3578][0-9]{9}$', mobile):
return self.write(dict(errcode=RET.PARAMERR, errmsg='手机号格式不正确'))
# 查询手机号是否已经注册
isregisted = self.db.get(
'select * from ih_user_profile where up_mobile=%s', mobile)
# print(isregisted)
if isregisted:
return self.write(
dict(errcode=RET.DATAEXIST, errmsg='此手机号已注册，直接登录即可'))
# 查询redis中的图片验证码
try:
redis_piccode = self.redis.get(
'%s%s' % (constants.IMAGE_CODE_REDIS_PREFIX, piccode_id))
print('redis_piccode为%s, piccode为%s, piccode.upper()为%s' %
(redis_piccode, piccode, piccode.upper()))
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DBERR, errmsg='数据库查询出错！'))
# 判断图片验证码
if not redis_piccode:
return self.write(dict(errcode=RET.NODATA, errmsg='图片验证码已过期'))
if redis_piccode != piccode.upper():
return self.write(dict(errcode=RET.DATAERR, errmsg='输入的图片验证码错误'))
# 输入的图片验证码正确
# 产生随机短信验证码
sms_code = random.randint(1, 999999)
sms_code = '%06d' % sms_code
print('code为%s' % sms_code)
# 保存生成的短信验证码
try:
self.redis.setex(
'%s%s' % (constants.SMS_CODE_REDIS_PREFIX, mobile),
constants.SMSCODE_EXPIRE, sms_code)
except Exception as e:
logging.error(e)
return self.write(dict(errcode=RET.DBERR, errmsg='数据库出错'))
# 发送短信验证码
try:
result = ccp.sendTemplateSMS(
mobile,
[sms_code, int(constants.SMSCODE_EXPIRE / 60)],
1) # 返回True或False
except Exception as e:
logging.error(e)
# 短信发送失败就需要把redis中已保存的短信验证码删除
self.redis.delete('%s%s' %
(constants.SMS_CODE_REDIS_PREFIX, mobile))
return self.write(dict(errcode=RET.THIRDERR, errmsg='短信发送失败'))
if not result:
# 短信发送失败就需要把redis中已保存的短信验证码删除
self.redis.delete('%s%s' %
(constants.SMS_CODE_REDIS_PREFIX, mobile))
return self.write(dict(errcode=RET.THIRDERR, errmsg='短信验证码发送失败'))
self.write(dict(errcode=RET.OK, errmsg='短信验证码已发送，请查收'))
ret = self.db.get(
'select up_mobile from ih_user_profile where up_mobile =%s' %
mobile)
except Exception, e:
logging.error(e)
# return self.write({"errno": RET.DBERR, "errmsg": "查询出错"})
else:
if ret:
return self.write({
"errno": RET.DATAEXIST,
"errmsg": "该手机号已被注册！"
})
# 如果图片验证码匹配成功，生成一个随机验证码
sms_code = "%04d" % random.randint(0, 9999)
try:
self.redis.setex("sms_code_%s" % mobile,
constants.SMS_CODE_EXPIRES_SECONDS, sms_code)
except Exception, e:
logging.error(e)
return self.write({"errno": RET.DBERR, "errmsg": "生成短信验证码错误！"})
# 发送短信
try:
ccp.sendTemplateSMS(
mobile, [sms_code, constants.SMS_CODE_EXPIRES_SECONDS / 60], 1)
except Exception, e:
return self.write({"errno": RET.THIRDERR, "errmsg": "发送失败！"})
self.write({"errno": RET.OK, "errmsg": "OK!"})
