def send_offline_remind_sms(self):
logging.info("[CELERY] checkertask send offline remind sms started.")
try:
currenttime = int(time.time())
terminals = self.db.query("SELECT tid, alias, mobile, owner_mobile, offline_time"
" FROM T_TERMINAL_INFO"
" WHERE login = 0"
" AND service_status = 1"
" AND offline_time < %s",
(currenttime - 24*60*60))
for terminal in terminals:
sms_option = QueryHelper.get_sms_option_by_uid(terminal.owner_mobile, 'heartbeat_lost', self.db)
if sms_option == UWEB.SMS_OPTION.SEND:
ctime = get_terminal_time(currenttime)
ctime = safe_unicode(ctime)
alias = terminal['alias'] if terminal['alias'] else terminal['mobile']
sms = SMSCode.SMS_HEARTBEAT_LOST % (alias, ctime)
SMSHelper.send(terminal.owner_mobile, sms)
logging.info("[CELERY] Send offline remind sms to user:%s, tid:%s", terminal.owner_mobile, terminal.tid)
logging.info("[CELERY] checkertask send offline remind sms finished.")
except Exception as e:
logging.exception("[CELERY] Check terminal poweroff timeout exception.")
def notify_maintainer(db, redis, content, category):
"""Notify alarm info to maintainers.
:arg category: int, e.g.
1: gateway
2: eventer
"""
mobiles = []
emails = []
alarm_key = 'maintainer_alarm:%s' % category
alarm_interval = 60 * 5 # 5 minutes
alarm_flag = redis.getvalue(alarm_key)
if not alarm_flag:
maintainers = db.query(
"SELECT mid, mobile, email FROM T_MAINTAINER WHERE valid = 1")
for item in maintainers:
mobiles.append(item['mobile'])
emails.append(item['email'])
for mobile in mobiles:
SMSHelper.send(mobile, content)
for email in emails:
EmailHelper.send(email, content)
redis.setvalue(alarm_key, True, alarm_interval)
logging.info("[PUBLIC] Notify alarm to maintainers. content: %s, category: %s.",
content, category)
else:
logging.info("[PUBLIC] Notify alarm is ignored in 5 minutes. content: %s, category: %s.",
content, category)
def get(self):
status = ErrorCode.SUCCESS
try:
tid = self.get_argument('tid',None)
# check tid whether exist in request and update current_user
self.check_tid(tid)
terminal = self.db.get("SELECT id FROM T_TERMINAL_INFO"
" WHERE tid = %s"
" AND service_status = %s",
self.current_user.tid,
UWEB.SERVICE_STATUS.ON)
if terminal:
lq_sms_key = get_lq_sms_key(self.current_user.tid)
sms = SMSCode.SMS_LQ % SMS.LQ.WEB
biz_type = QueryHelper.get_biz_type_by_tmobile(self.current_user.sim, self.db)
if biz_type != UWEB.BIZ_TYPE.YDWS:
pass
else:
SMSHelper.send_to_terminal(self.current_user.sim, sms)
self.redis.setvalue(lq_sms_key, True, SMS.LQ_INTERVAL)
lq_interval_key = get_lq_interval_key(self.current_user.tid)
self.redis.setvalue(lq_interval_key, int(time.time()), (SMS.LQ.WEB*60 - 160))
logging.info("[UWEB] wake up, send %s to Sim: %s", sms, self.current_user.sim)
else:
status = ErrorCode.LOGIN_AGAIN
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] uid: %s wake up tid: %s failed. Exception: %s",
self.current_user.uid, self.current_user.tid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def sms_to_whitelist(self, sms, whitelist=None):
if not sms:
return
if whitelist:
for white in whitelist:
SMSHelper.send(white['mobile'], sms)
def notify(self):
content = SMSCode.SMS_GW_ERROR_REPORT % ConfHelper.UWEB_CONF.url_out
for mobile in self.mobiles:
SMSHelper.send(mobile, content)
for email in self.emails:
EmailHelper.send(email, content)
def check_service(self):
try:
base_id = self.get_lid_by_tid(self.tid)
while True:
time.sleep(600) # 10 minutes
new_lid = self.get_lid_by_tid(self.tid)
logging.info("[CK] simulator terminal location base_id:%s, new_lid:%s",
base_id, new_lid)
if new_lid > base_id:
base_id = new_lid
else:
for mobile in self.mobiles:
sms = SMSCode.SMS_SERVICE_EXCEPTION_REPORT % ConfHelper.UWEB_CONF.url_out
SMSHelper.send(mobile, sms)
logging.info("[CK] Notify Administrator:%s By SMS, service exception!",
mobile)
for email in self.emails:
content = SMSCode.SMS_SERVICE_EXCEPTION_REPORT % ConfHelper.UWEB_CONF.url_out
EmailHelper.send(email, content)
logging.info("[CK] Notify Administrator:%s By EMAIL, service exception!",
email)
except KeyboardInterrupt:
logging.error("Ctrl-C is pressed.")
except Exception as e:
logging.exception("[CK] Check service failed. Exception: %s",
e.args)
def post(self):
"""Insert new items."""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
content = data.get('content', '')
mobiles = data.get('mobiles', None)
logging.info("[UWEB] Announcement request: %s", data)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
return
try:
mobiles_ = u''
if mobiles is not None:
mobiles_ = ','.join(mobiles)
for mobile in mobiles:
SMSHelper.send(mobile, content)
announcement = dict(cid=self.current_user.cid,
content=content,
mobiles=mobiles_)
record_announcement(self.db, announcement)
self.write_ret(status)
except Exception as e:
status = ErrorCode.SERVER_BUSY
logging.exception(
"[UWEB] record share failed, Exception: %s", e.args)
self.write_ret(status)
def move_data():
db = DBConnection().db
mobiles = ['18310505991', '13693675352', '13581731204']
message = "数据库T_LOCATION已经完全转移到T_LOCATION_NEW,请及确认表信息的正确性和完整性。"
#max_row = 1000000000
max_row = 250000000
begin_time = time.gmtime(time.time())
for i in range(10000, max_row, 10000):
sql = "INSERT INTO T_LOCATION_NEW" \
" SELECT * FROM T_LOCATION WHERE id <=%d AND id > %d -10000" \
" and (timestamp between 0 and 1448899200)" % (i, i)
logging.info("exectue sql:%s", sql)
n = db.execute(sql)
#time.sleep(0.1)
logging.info("last record row id =%s", n)
break
# if i = 250000000:
if i == 240000000:
for mobile in mobiles:
SMSHelper.send(mobile, message)
print "send", mobile
end_time = time.gmtime(time.time())
L_bak = "alter table T_LOCATION rename to T_LOCATION_bak"
NEW_L = "alter table T_LOCATION_NEW rename to T_LOCATION"
for i in range(1, 5):
time.sleep(1)
logging.info("Will rename table neame after %d second", 5-i)
db.execute(L_bak)
db.execute(NEW_L)
logging.info("exchange tables T_LOCATION and T_LOCATION_NEW is accomplished ")
logging.info("Move table data begin_time:%s, end_time:%s", begin_time, end_time)
def login_sms_remind(self, uid, owner_mobile, terminals, login="******"):
sms_option = QueryHelper.get_sms_option_by_uid(uid, "login", self.db)
if sms_option == UWEB.SMS_OPTION.SEND:
login_time = time.strftime("%Y-%m-%d %H:%M:%S")
login_method = UWEB.LOGIN_WAY[login]
terminal_mobile = u"”，“".join(terminal.alias for terminal in terminals)
remind_sms = SMSCode.SMS_LOGIN_REMIND % (login_time, login_method, owner_mobile, terminal_mobile)
SMSHelper.send(owner_mobile, remind_sms)
def sms_to_user(self, dev_id, sms, mobile):
if not sms:
return
if not mobile:
return
if mobile:
SMSHelper.send(mobile, sms)
def send_domain_sms(db, redis, tid, mobile, domain):
"""Send domain sms to terminal..
"""
sms_domain = SMSCode.SMS_DOMAIN % domain
SMSHelper.send_to_terminal(mobile, sms_domain)
self.db.execute("UPDATE T_TERMINAL_INFO SET domain = %s"
" WHERE tid = %s",
domain_ip, tid)
logging.info("[PUBLIC] Send domain sms: %s to mobile: %s",
sms_domain, mobile)
def kqly(db, redis, tids):
"""Start bluetooth.
"""
for tid in tids:
terminal = QueryHelper.get_terminal_by_tid(tid, db)
kqly_key = get_kqly_key(tid)
kqly_value = redis.getvalue(kqly_key)
if not kqly_value:
interval = 30 # in minute
sms = SMSCode.SMS_KQLY % interval
SMSHelper.send_to_terminal(terminal.mobile, sms)
redis.setvalue(kqly_key, True, SMS.KQLY_SMS_INTERVAL)
def check_sms(self):
"""Notify administrators when sms to be send is more than alarm_size;
"""
res = self.db.get(
"SELECT count(id) as count FROM T_SMS where send_status = -1")
if res and res['count'] >= self.alarm_size:
content = SMSCode.SMS_SMS_REPORT % ConfHelper.UWEB_CONF.url_out
for mobile in self.mobiles:
SMSHelper.send(mobile, content)
for email in self.emails:
EmailHelper.send(email, content)
logging.info("[CK] Notify sms queue exception to administrator!")
def check_push(self):
"""
"""
res = self.db_push.get(
"SELECT count(id) as count FROM T_PUSH where status = 1")
if res and res['count'] >= self.alarm_size:
content = SMSCode.SMS_PUSH_REPORT % ConfHelper.UWEB_CONF.url_out
for mobile in self.mobiles:
SMSHelper.send(mobile, content)
for email in self.emails:
EmailHelper.send(email, content)
logging.info("[CK] Notify push queue exception to administrator!")
def alarm(self):
"""
#NOTE: Send alarm message if need.
"""
send_flag = self.redis.getvalue(self.alarm_key)
if (not send_flag):
content = SMSCode.SMS_GW_DELAY_REPORT % ConfHelper.UWEB_CONF.url_out
for mobile in self.mobiles:
SMSHelper.send(mobile, content)
for email in self.emails:
EmailHelper.send(email, content)
logging.info("[CK] Notify S packet delay to administrator!")
self.redis.setvalue(self.alarm_key, True, self.alarm_interval)
def send(content, mobile):
logging.info("Send %s to %s", content, mobile)
#NOTE: send encrypt sms to mobile
response = SMSHelper.send_to_terminal(mobile, content)
#NOTE: send general sms to mobile
#response = SMSHelper.send(mobile, content)
logging.info("Response: %s", response)
def post(self):
"""Send captcha to user's phone through sms.
"""
status = ErrorCode.SUCCESS
try:
mobile = self.get_argument('mobile','')
captcha = ''.join(random.choice(string.digits) for x in range(6))
ios_captcha_sms = SMSCode.SMS_IOS_CAPTCHA % (captcha)
ret = SMSHelper.send(mobile, ios_captcha_sms)
ret = DotDict(json_decode(ret))
if ret.status == ErrorCode.SUCCESS:
logging.info("[CLIENT] passenger get sms captcha: %s successfully, mobile: %s",
captcha, mobile)
captcha_key = get_captcha_key(mobile)
self.redis.setvalue(captcha_key, captcha, UWEB.SMS_CAPTCHA_INTERVAL)
else:
status = ErrorCode.SERVER_BUSY
logging.error("[CLIENT] passenger get sms captcha failed, mobile: %s", mobile)
self.write_ret(status)
except Exception as e:
logging.exception("[CLIENT] passenger get sms captcha failed, mobile: %s. Exception: %s",
mobile, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def post(self):
"""Reregist a pair of umobile and tmobile.
Send sms to terminal.
"""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
logging.info("[UWEB] Register request: %s", data)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
return
try:
tmobile = data.tmobile
user = QueryHelper.get_user_by_tmobile(tmobile, self.db)
if user:
umobile = user.owner_mobile
terminal = QueryHelper.get_terminal_by_tmobile(
tmobile, self.db)
if int(terminal.biz_type) == UWEB.BIZ_TYPE.YDWS:
register_sms = SMSCode.SMS_REGISTER % (umobile, tmobile)
ret = SMSHelper.send_to_terminal(tmobile, register_sms)
else:
activation_code = QueryHelper.get_activation_code(self.db)
register_sms = SMSCode.SMS_REGISTER_YDWQ % (
ConfHelper.UWEB_CONF.url_out, activation_code)
ret = SMSHelper.send(tmobile, register_sms)
ret = DotDict(json_decode(ret))
if ret.status == ErrorCode.SUCCESS:
logging.info("[UWEB] Reregist successfully. umobile: %s, tmobile: %s .",
umobile, tmobile)
else:
status = ErrorCode.REGISTER_FAILED
logging.error("[UWEB] Reregister failed. umobile: %s, tmobile: %s. Message: %s",
umobile, tmobile, ErrorCode.ERROR_MESSAGE[status])
else:
logging.exception("[UWEB] Terminal has no user, ignore it. tmobile: %s. ",
tmobile)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] Reregister failed. tmobile: %s , Exception: %s",
tmobile, e.args)
status = ErrorCode.REGISTER_FAILED
self.write_ret(status)
def send_cq_sms(db, redis, tid, mobile):
"""Send cq sms to terminal..
"""
sms_cq = SMSCode.SMS_CQ
if len(mobile) != 11:
logging.info("[PUBLIC] Mobile is valid, ignore it. mobile: %s", mobile)
return
biz_type = QueryHelper.get_biz_type_by_tmobile(mobile, db)
if biz_type != UWEB.BIZ_TYPE.YDWS:
logging.info(
"[PUBLIC] Biz_type is no need cq, ignore it. mobile: %s, biz_type: %s", mobile, biz_type)
return
SMSHelper.send_to_terminal(mobile, sms_cq)
logging.info("[PUBLIC] Send cq sms to terminal. mobile: %s", mobile)
def check_poweroff_timeout(self):
logging.info("[CELERY] checkertask check poweroff timeout started.")
try:
terminals = self.db.query("SELECT tpt.tid, tpt.sms_flag, tpt.timestamp"
" FROM T_POWEROFF_TIMEOUT as tpt, T_TERMINAL_INFO as tti"
" WHERE tti.tid = tpt.tid"
" AND tti.service_status = 1"
" AND tti.login = %s"
" AND tpt.sms_flag = %s"
" AND tpt.timestamp < %s",
GATEWAY.TERMINAL_LOGIN.OFFLINE, GATEWAY.POWEROFF_TIMEOUT_SMS.UNSEND, (time.time() - 2*60*60))
for terminal in terminals:
terminal_info = QueryHelper.get_terminal_info(terminal.tid, self.db, self.redis)
if int(terminal_info['pbat']) < 5:
user = QueryHelper.get_user_by_tid(terminal.tid, self.db)
sms = SMSCode.SMS_POWEROFF_TIMEOUT % terminal_info['alias']
SMSHelper.send(user.owner_mobile, sms)
self.update_sms_flag(terminal.tid)
logging.info("[CELERY] Send poweroff timeout sms to user:%s, tid:%s", user.owner_mobile, terminal.tid)
except Exception as e:
logging.exception("[CELERY] Check terminal poweroff timeout exception.")
def handle_unusual(info, address, connection, channel, exchange, gw_binding, db, redis):
"""Unusual activate report packet: owner_mobile changed.
S27
0: success, then record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
resend_key, resend_flag = get_resend_flag(redis, dev_id, head.timestamp, head.command)
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
command=head.command)
if resend_flag:
logging.warn("[GW] Recv resend packet, head: %s, body: %s and drop it!",
info.head, info.body)
else:
redis.setvalue(resend_key, True, GATEWAY.RESEND_EXPIRY)
uap = UnusualActivateParser(body, head)
t_info = uap.ret
terminal = db.get("SELECT mobile FROM T_TERMINAL_INFO"
" WHERE tid = %s LIMIT 1",
t_info['dev_id'])
if terminal:
sms = SMSCode.SMS_UNUSUAL_ACTIVATE % terminal['mobile']
SMSHelper.send(t_info['u_msisdn'], sms)
else:
logging.error("[GW] Terminal: %s is not existent, what's up?", t_info['dev_id'])
uac = UnusualActivateComposer(args)
request = DotDict(packet=uac.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Hand unusual activate report exception.")
GWException().notify()
def post(self):
"""Send sms to user's mobile."""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
mobile = data.mobile
captcha_sms = data.captcha_sms
captchahash_sms = self.get_secure_cookie("captchahash_sms")
category = data.category
logging.info("[UWEB] downloadsms request: %s", data)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[UWEB] Invalid data format. body:%s, Exception: %s",
self.request.body, e.args)
self.write_ret(status)
return
try:
m = hashlib.md5()
m.update(captcha_sms.lower())
m.update(UWEB.HASH_SALT)
hash_ = m.hexdigest()
if hash_.lower() != captchahash_sms.lower():
status = ErrorCode.WRONG_CAPTCHA
logging.info("[UWEB] downloadsms failed. Message: %s",
ErrorCode.ERROR_MESSAGE[status])
else:
# downloadurl = DOWNLOAD.URL.ANDROID % ConfHelper.UWEB_CONF.url_out
download_remind = SMSCode.SMS_DOWNLOAD_REMIND % (
ConfHelper.UWEB_CONF.url_out)
SMSHelper.send(mobile, download_remind)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] Smsdownload failed. Exception: %s. ",
e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def check_charge_remind(self):
logging.exception("[CELERY] checkertask charge remind started")
try:
terminals = self.db.query("SELECT tid, mobile, owner_mobile, begintime"
" FROM T_TERMINAL_INFO "
" WHERE service_status = 1")
for terminal in terminals:
begintime = int(terminal.begintime)
begintime = time.strftime("%Y,%m,%d", time.localtime(begintime)).split(",")
b_year = int(begintime[0])
b_month = int(begintime[1])
b_day = int(begintime[2])
currenttime = int(time.time())
currenttime = time.strftime("%Y,%m,%d", time.localtime(currenttime)).split(",")
c_year = int(currenttime[0])
c_month = int(currenttime[1])
c_day = int(currenttime[2])
# get days of current month
days = calendar.monthrange(c_year, c_month)[1]
if b_year > c_year:
continue
elif b_year == c_year and b_month == c_month:
# do not remind user on register month
continue
elif b_day < c_day:
continue
elif (b_day == c_day) or (b_day > days and c_day == days):
# 1. equal day
# 2. has no equal day on this month, send sms on the last day of this month
# send charge remind sms
if terminal.owner_mobile:
content = SMSCode.SMS_CHARGE_REMIND % terminal.mobile
SMSHelper.send(terminal.owner_mobile, content)
logging.info("[CELERY] Send charge remind sms to user: %s", terminal.owner_mobile)
except Exception as e:
logging.exception("[CELERY] Check charge remind exception: %s", e.args)
def send_lq_sms(self, sim, tid, interval):
"""Send LQ Message to terminal.
lq_sms_key: when send lq sms to terminal, keep it in redis
for 3 minutes. in 3 minutes, do not send lq sms twice.
lq_interval_key: when send lq sms to terminal, keep it in redis
for interval. in the period of interval, terminal is been awaken.
when the period of interval is past, lq_sms should be send again
"""
lq_sms_key = get_lq_sms_key(tid)
lq_interval_key = get_lq_interval_key(tid)
self.redis.setvalue(lq_interval_key, int(time.time()), (interval * 60 - 160))
if not self.redis.getvalue(lq_sms_key):
sms = SMSCode.SMS_LQ % interval
biz_type = QueryHelper.get_biz_type_by_tmobile(sim, self.db)
if biz_type != UWEB.BIZ_TYPE.YDWS:
pass
else:
SMSHelper.send_to_terminal(sim, sms)
logging.info("[UWEB] send %s to Sim: %s", sms, sim)
self.redis.setvalue(lq_sms_key, True, SMS.LQ_INTERVAL)
def send_jb_sms(self, tmobile, umobile, tid):
"""
#NOTE: deprecated. It should never be invoked.
"""
unbind_sms = SMSCode.SMS_UNBIND
biz_type = QueryHelper.get_biz_type_by_tmobile(tmobile, self.db)
if biz_type != UWEB.BIZ_TYPE.YDWS:
ret = DotDict(status=ErrorCode.SUCCESS)
else:
ret = SMSHelper.send_to_terminal(tmobile, unbind_sms)
ret = json_decode(ret)
status = ret["status"]
if status == ErrorCode.SUCCESS:
self.db.execute(
"UPDATE T_TERMINAL_INFO" " SET service_status = %s" " WHERE mobile = %s",
UWEB.SERVICE_STATUS.TO_BE_UNBIND,
tmobile,
)
terminals = self.db.query(
"SELECT id FROM T_TERMINAL_INFO" " WHERE owner_mobile = %s" " AND service_status = %s",
umobile,
UWEB.SERVICE_STATUS.ON,
)
# clear user
if len(terminals) == 0:
self.db.execute("DELETE FROM T_USER" " WHERE mobile = %s", umobile)
lastinfo_key = get_lastinfo_key(umobile)
lastinfo_time_key = get_lastinfo_time_key(umobile)
ios_id_key = get_ios_id_key(umobile)
ios_badge_key = get_ios_badge_key(umobile)
keys = [lastinfo_key, lastinfo_time_key, ios_id_key, ios_badge_key]
self.redis.delete(*keys)
logging.info("[UWEB] Delete User: %s", umobile)
logging.info("[UWEB] umobile: %s, tid: %s, tmobile: %s SMS unbind successfully.", umobile, tid, tmobile)
else:
logging.error(
"[UWEB] umobile: %s, tid: %s, tmobile: %s SMS unbind failed. Message: %s",
umobile,
tid,
tmobile,
ErrorCode.ERROR_MESSAGE[status],
)
return status
def send_sms(mobiles, message):
if mobiles is None:
return ErrorCode.SUCCESS
num = 0
try:
for mobile in mobiles:
ret = SMSHelper.send(mobile, message)
ret = json_decode(ret)
status = ret['status']
if status == ErrorCode.SUCCESS:
num += 1
if num != len(mobiles):
status = ErrorCode.FAILED
return status
else:
status = ErrorCode.SUCCESS
return status
except Exception as e:
logging.exception("[UWEB] Send sms to sms server failed. Exception: %s",
e.args)
status = ErrorCode.SERVER_BUSY
return status
def post(self):
status = ErrorCode.SUCCESS
try:
# {"tmobile":18810496308,"pmobile":18810496308}
data = DotDict(json_decode(self.request.body))
tmobile = data.tmobile
pmobile = data.pmobile
register_sms = SMSCode.SMS_REGISTER % (pmobile, tmobile)
ret = SMSHelper.send_to_terminal(tmobile, register_sms)
ret = DotDict(json_decode(ret))
if ret.status == ErrorCode.SUCCESS:
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET msgid = %s"
" WHERE mobile = %s",
ret['msgid'], tmobile)
self.write_ret(status)
else:
status = ErrorCode.FAILED
self.write_ret(status)
except Exception as e:
logging.exception("SMS register failed. Exception: %s", e.args)
status = ErrorCode.FAILED
self.write_ret(status)
def send(content, mobile):
logging.info("Send %s to %s", content, mobile)
response = SMSHelper.send(mobile, content)
logging.info("Response: %s", response)
def post(self):
"""Generate a captcha for retrieving the password."""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
umobile = data.mobile
captcha_psd = data.captcha_psd
logging.info("[UWEB] Get captcha request: %s", data)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[UWEB] Invalid data format. body: %s, Exception: %s",
self.request.body, e.args)
self.write_ret(status)
return
try:
status = self.check_privilege(umobile)
if status != ErrorCode.SUCCESS:
logging.error("[UWEB] User: %s is just for test, has no right to access the function.",
umobile)
self.write_ret(status)
return
captchahash = self.get_secure_cookie("captchahash_password")
m = hashlib.md5()
m.update(captcha_psd.lower())
m.update(UWEB.HASH_SALT)
hash_ = m.hexdigest()
if hash_.lower() != captchahash.lower():
status = ErrorCode.WRONG_CAPTCHA_IMAGE
logging.info("[UWEB] Come from browser, captcha-check failed.")
self.write_ret(status)
return
user = self.db.get("SELECT mobile"
" FROM T_USER"
" WHERE mobile = %s"
" LIMIT 1",
umobile)
if user:
remote_ip = self.request.remote_ip
remote_ip_key = "register_remote_ip:%s" % remote_ip
umobile_key = "register_umobile:%s" % umobile
remote_ip_times = self.redis.getvalue(remote_ip_key)
umobile_times = self.redis.getvalue(umobile_key)
if remote_ip_times is None:
remote_ip_times = 0
if umobile_times is None:
umobile_times = 0
logging.info("[UWEB] Register. umobile: %s, umobile_times: %s, remote_ip: %s, remote_ip_times: %s",
umobile, umobile_times, remote_ip, remote_ip_times)
#NOTE: In current day, the same remote_ip allows 10 times, the umobile, 3 times
current_time = int(time.time())
date = get_date_from_utc(current_time)
year, month, day = date.year, date.month, date.day
start_time_, end_time_ = start_end_of_day(year=year, month=month, day=day)
if umobile_times >= 3: # <= 3 is ok
status = ErrorCode.REGISTER_EXCESS
if remote_ip_times >= 10: # <= 10 is ok
status = ErrorCode.REGISTER_EXCESS
if status == ErrorCode.REGISTER_EXCESS:
body = u'管理员您好：检测到频繁注册，请查看. umobile: %s, umobile_times: %s, remote_ip: %s, remote_ip_times: %s' % (
umobile, umobile_times, remote_ip, remote_ip_times)
notify_maintainer(self.db, self.redis, body, 'password')
self.write_ret(status)
return
captcha = ''.join(random.choice(string.digits) for x in range(4))
getcaptcha_sms = SMSCode.SMS_CAPTCHA % (captcha)
ret = SMSHelper.send(umobile, getcaptcha_sms)
ret = DotDict(json_decode(ret))
if ret.status == ErrorCode.SUCCESS:
logging.info("[UWEB] user uid: %s get captcha success, the captcha: %s",
umobile, captcha)
captcha_key = get_captcha_key(umobile)
self.redis.setvalue(captcha_key, captcha, UWEB.SMS_CAPTCHA_INTERVAL)
self.redis.set(umobile_key, umobile_times+1)
self.redis.expireat(umobile_key, end_time_)
self.redis.set(remote_ip_key, remote_ip_times+1)
self.redis.expireat(remote_ip_key, end_time_)
else:
status = ErrorCode.SERVER_BUSY
logging.error("[UWEB] user uid: %s get captcha failed.", umobile)
else:
status = ErrorCode.USER_NOT_ORDERED
logging.error("[UWEB] user uid: %s does not exist, get captcha failed.",
umobile)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] user uid: %s retrieve password failed. Exception: %s",
umobile, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def post(self):
"""Turn on tracing."""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
tid = data.get('tid', None)
tids = data.get('tids', None)
flag = int(data.get('flag', 1))
# check tid whether exist in request and update current_user
self.check_tid(tid)
logging.info("[UWEB] track LQ request: %s, "
" uid: %s, tid: %s, tids: %s, flag: %s",
data, self.current_user.uid, tid, tids, flag)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
return
try:
tids = str_to_list(tids)
tids = tids if tids else [self.current_user.tid, ]
tids = [str(tid) for tid in tids]
if int(flag) == 1:
for tid in tids:
# NOTE: just send lqgz temporary
terminal = QueryHelper.get_terminal_by_tid(tid, self.db)
lqgz_key = get_lqgz_key(tid)
lqgz_value = self.redis.getvalue(lqgz_key)
lqgz_interval_key = get_lqgz_interval_key(tid)
if not lqgz_value:
interval = 30 # in minute
biz_type = QueryHelper.get_biz_type_by_tmobile(
terminal.mobile, self.db)
if biz_type != UWEB.BIZ_TYPE.YDWS:
self.write_ret(status)
return
sms = SMSCode.SMS_LQGZ % interval
SMSHelper.send_to_terminal(terminal.mobile, sms)
self.redis.setvalue(
lqgz_key, True, SMS.LQGZ_SMS_INTERVAL)
self.redis.setvalue(
lqgz_interval_key, True, SMS.LQGZ_INTERVAL * 2)
# END
track_key = get_track_key(tid)
track = self.redis.get(track_key)
logging.info("[UWEB] Get track: %s from redis", track)
if track and int(track) == 1:
# turn on track already
logging.info(
"[UWEB] Terminal: %s turn on track already.", tid)
else:
self.db.execute("UPDATE T_TERMINAL_INFO SET track = %s"
" WHERE tid = %s",
flag, tid)
self.redis.setvalue(track_key, 1, UWEB.TRACK_INTERVAL)
sessionID_key = get_terminal_sessionID_key(tid)
self.redis.delete(sessionID_key)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] uid: %s, tid: %s send lqgz failed. Exception: %s. ",
self.current_user.uid, self.current_user.tid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
