def handle_fob_info(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S19
NOTE: deprecated
fob info packet: add or remove fob
0: success, then record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
else:
fp = FobInfoParser(body, head)
fobinfo = fp.ret
update_terminal_status(redis, head.dev_id, address)
update_fob_info(db, redis, fobinfo)
fc = FobInfoRespComposer(args)
request = DotDict(packet=fc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle fob info report exception.")
GWException().notify()
def handle_acc_status_report(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S31
ACC_status_report:
0: success, then record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
command=head.command)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
logging.error("[GW] Invalid sessionID, terminal: %s", head.dev_id)
else:
uap = ACCStatusReportParser(body, head)
t_info = uap.ret
#NOTE: Just record it in db.
db.execute("INSERT INTO T_ACC_STATUS_REPORT(tid, category, timestamp)"
" VALUES(%s, %s, %s)",
t_info['dev_id'], t_info['category'], t_info['timestamp'])
asc = ACCStatusReportComposer(args)
request = DotDict(packet=asc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle acc status report exception.")
GWException().notify()
def handle_sleep(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S21
sleep status packet: 0-sleep, 1-LQ
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)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
is_sleep = False
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
else:
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)
hp = AsyncParser(body, head)
sleep_info = hp.ret
if sleep_info['sleep_status'] == '0':
sleep_info['login'] = GATEWAY.TERMINAL_LOGIN.SLEEP
#self.send_lq_sms(head.dev_id)
#logging.info("[GW] Recv sleep packet, LQ it: %s", head.dev_id)
is_sleep = True
elif sleep_info['sleep_status'] == '1':
sleep_info['login'] = GATEWAY.TERMINAL_LOGIN.ONLINE
else:
logging.info("[GW] Recv wrong sleep status: %s", sleep_info)
del sleep_info['sleep_status']
update_terminal_info(db, redis, sleep_info)
update_terminal_status(redis, dev_id, address, is_sleep)
if args['success'] == GATEWAY.RESPONSE_STATUS.SUCCESS:
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info and (not acc_status_info['t2_status']): # T2(query) is need
args['success'] = 3 # acc_status is changed
logging.info("[GW] ACC_status is changed, dev_id: %s, acc_status_info: %s",
dev_id, acc_status_info)
hc = AsyncRespComposer(args)
request = DotDict(packet=hc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle sleep status report exception.")
GWException().notify()
def handle_fob_status(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S22
NOTE: deprecated
fob status packet: 0-no fob near, 1-have fob near
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)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
else:
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)
hp = AsyncParser(body, head)
fob_info = hp.ret
info = DotDict(fob_status=fob_info['fob_status'],
dev_id=fob_info['dev_id'])
update_terminal_info(db, redis, fob_info)
update_terminal_status(redis, head.dev_id, address)
hc = AsyncRespComposer(args)
request = DotDict(packet=hc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle fob status report exception.")
GWException().notify()
def handle_acc_status(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S30
ACC_status:
0: success, then record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
command=head.command)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
logging.error("[GW] Invalid sessionID, terminal: %s", head.dev_id)
else:
uap = ACCStatusParser(body, head)
t_info = uap.ret
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info:
acc_status_info['op_status'] = 1 # success
redis.setvalue(acc_status_info_key, acc_status_info, UWEB.ACC_STATUS_EXPIRY)
WSPushHelper.pushS8(dev_id, 1, db, redis)
else: # It should never occur.
logging.error("[GW] ACC_status can not be found. dev_id: %s",
dev_id)
pass
asc = ACCStatusComposer(args)
request = DotDict(packet=asc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle acc status exception.")
GWException().notify()
def handle_misc(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S28
misc: debugging for terminal.
0: success, then record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
command=head.command)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
logging.error("[GW] Invalid sessionID, terminal: %s", head.dev_id)
else:
uap = MiscParser(body, head)
t_info = uap.ret
db.execute("UPDATE T_TERMINAL_INFO"
" SET misc = %s"
" WHERE tid = %s ",
t_info['misc'], head.dev_id)
if args['success'] == GATEWAY.RESPONSE_STATUS.SUCCESS:
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info and (not acc_status_info['t2_status']): # T2(query) is need
args['success'] = 3 # acc_status is changed
logging.info("[GW] ACC_status is changed, dev_id: %s, acc_status_info: %s",
dev_id, acc_status_info)
uac = MiscComposer(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] Handle misc report exception.")
GWException().notify()
def handle_heartbeat(info, address, connection, channel, exchange, gw_binding,db, redis):
"""
S2
heartbeat packet
0: success, then record new terminal's address
1: invalid SessionID
3: acc_status is changed
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS)
old_softversion = False # if version < 2.4.0, true; else false.
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
else:
hp = HeartbeatParser(body, head)
heartbeat_info = hp.ret
is_sleep = False
if heartbeat_info['sleep_status'] == '0':
heartbeat_info['login'] = GATEWAY.TERMINAL_LOGIN.SLEEP
is_sleep = True
elif heartbeat_info['sleep_status'] == '1':
heartbeat_info['login'] = GATEWAY.TERMINAL_LOGIN.ONLINE
is_sleep = False
elif heartbeat_info['sleep_status'] == '2': # query mode
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info and int(acc_status_info['op_status']) == 0:
args.timestamp = acc_status_info['timestamp']
args.op_type = acc_status_info['op_type']
# modify t2_status in acc_status_info
acc_status_info['t2_status'] = 1 # T2 query occurs
redis.setvalue(acc_status_info_key, acc_status_info, UWEB.ACC_STATUS_EXPIRY)
else: # if acc_status_info['op_status'] is 1, or no acc_status_info, set op_type is 2
args.timestamp = ''
args.op_type = 2 # wait
else: #NOTE: it should never occur
logging.error("[GW] Recv wrong sleep status: %s", heartbeat_info)
del heartbeat_info['sleep_status']
update_terminal_status(redis, head.dev_id, address, is_sleep)
update_terminal_info(db, redis, heartbeat_info)
if args['success'] == GATEWAY.RESPONSE_STATUS.SUCCESS:
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info and (not acc_status_info['t2_status']): # T2(query) is need
args['success'] = 3 # acc_status is changed
logging.info("[GW] ACC_status is changed, dev_id: %s, acc_status_info: %s",
dev_id, acc_status_info)
#NOTE: check the version.
# if version is less than 2.4.0(not include 2.4.0), only has success in args
softversion = heartbeat_info['softversion']
item = softversion.split(".")
if int(item[0]) > 2:
pass
else: # A.B.C A <= 2
if int(item[1]) < 4: # A.B.C B <= 4
old_softversion = True
else:
pass
if old_softversion:
logging.info("[GW] Old softversion(<2.4.0): %s, only success is provided in S2",
softversion)
args = dict(success=args['success'])
hc = HeartbeatRespComposer(args)
request = DotDict(packet=hc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Hand heartbeat failed.")
GWException().notify()
def handle_config(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S17
Config packet
0: success, then record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
domain="",
freq="",
trace="",
static_val="",
move_val="",
trace_para="",
vibl="",
use_scene="",
stop_interval="",
test="",
gps_enhanced="",
tracking_interval="")
sessionID = QueryHelper.get_terminal_sessionID(head.dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
else:
update_terminal_status(redis, head.dev_id, address)
#TODO:
terminal = db.get("SELECT track, freq, trace, mannual_status,"
" trace_para, vibl, domain,"
" use_scene, stop_interval, test,"
" gps_enhanced, tracking_interval"
" FROM T_TERMINAL_INFO"
" WHERE tid = %s", head.dev_id)
args.domain = terminal.domain
args.freq = terminal.freq
args.trace = terminal.trace
args.use_scene = terminal.use_scene
args.stop_interval = terminal.stop_interval
args.test = terminal.test
args.gps_enhanced = terminal.gps_enhanced
args.tracking_interval = terminal.tracking_interval
if terminal.track == 1: # turn on track
args.trace_para = "60:1"
else:
args.trace_para = terminal.trace_para
args.vibl = terminal.vibl
#NOTE: get move_val and static_val according to mannual_status
if int(terminal.mannual_status) != UWEB.DEFEND_STATUS.YES: # 撤防，智能设防
move_val = 0
static_val = 180
else: # 强力设防
move_val = 60
static_val = 0
args.move_val = move_val
args.static_val = static_val
#NOTE: check the version.
# if version is after 2.4, add tracking-interval in S17
softversion = head['softversion']
item = softversion.split(".")
old_softversion = False
if int(item[0]) < 2: # 1.x.x
old_softversion = True
elif int(item[0]) == 2: # 2.x.x
if int(item[1]) < 4: # 2.3.x
old_softversion = True
else: # 2.4.x
old_softversion = False
else: # 3.x
old_softversion = False
if old_softversion:
del args['tracking_interval']
if args['success'] == GATEWAY.RESPONSE_STATUS.SUCCESS:
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info and (not acc_status_info['t2_status']): # T2(query) is need
args['success'] = 3 # acc_status is changed
logging.info("[GW] ACC_status is changed, dev_id: %s, acc_status_info: %s",
dev_id, acc_status_info)
hc = ConfigRespComposer(args)
request = DotDict(packet=hc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Hand query config exception.")
GWException().notify()
def handle_locationdesc(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S10
locationdesc packet
0: success, then return locationdesc to terminal and record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
body = info.body
dev_id = head.dev_id
if len(body) == 6:
body.append(20)
logging.info("[GW] old version is compatible, append locate_error")
resend_key, resend_flag = get_resend_flag(redis, dev_id, head.timestamp, head.command)
go_ahead = False
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
locationdesc="",
ew="E",
lon=0.0,
ns="N",
lat=0.0)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
logging.error("[GW] Invalid sessionID, terminal: %s", head.dev_id)
else:
if resend_flag:
logging.warn("[GW] Recv resend packet, head: %s, body: %s and drop it!",
info.head, info.body)
else:
go_ahead = True
#NOTE: Check ydcw or ajt
ajt = QueryHelper.get_ajt_whitelist_by_mobile(head.dev_id, db)
if ajt:
url_out = ConfHelper.UWEB_CONF.ajt_url_out
else:
url_out = ConfHelper.UWEB_CONF.url_out
if go_ahead:
redis.setvalue(resend_key, True, GATEWAY.RESEND_EXPIRY)
ldp = LocationDescParser(body, head)
location = ldp.ret
logging.info("[GW] T10 packet parsered:%s", location)
if not location.has_key('gps_time'):
location['gps_time'] = int(time.time())
logging.info("[GW] what's up? location:%s hasn't gps_time.", location)
location['t'] = EVENTER.INFO_TYPE.POSITION
if location['valid'] != GATEWAY.LOCATION_STATUS.SUCCESS:
cellid = True
else:
cellid = False
location = lbmphelper.handle_location(location, redis, cellid=cellid, db=db)
location.name = location.get('name') if location.get('name') else ""
location.name = safe_unicode(location.name)
user = QueryHelper.get_user_by_tid(head.dev_id, db)
tname = QueryHelper.get_alias_by_tid(head.dev_id, redis, db)
dw_method = u'GPS' if not cellid else u'基站'
if location.cLat and location.cLon:
if user:
current_time = get_terminal_time(int(time.time()))
sms = SMSCode.SMS_DW_SUCCESS % (tname, dw_method,
location.name,
safe_unicode(current_time))
url = url_out + '/wapimg?clon=' +\
str(location.cLon/3600000.0) + '&clat=' + str(location.cLat/3600000.0)
tiny_id = URLHelper.get_tinyid(url)
if tiny_id:
base_url = url_out + UWebHelper.URLS.TINYURL
tiny_url = base_url + '/' + tiny_id
logging.info("[GW] get tiny url successfully. tiny_url:%s", tiny_url)
redis.setvalue(tiny_id, url, time=EVENTER.TINYURL_EXPIRY)
sms += u"点击 " + tiny_url + u" 查看定位器位置。"
else:
logging.info("[GW] get tiny url failed.")
SMSHelper.send(user.owner_mobile, sms)
else:
if user:
sms = SMSCode.SMS_DW_FAILED % (tname, dw_method)
SMSHelper.send(user.owner_mobile, sms)
if not (location.lat and location.lon):
args.success = GATEWAY.RESPONSE_STATUS.CELLID_FAILED
else:
insert_location(location, db, redis)
lc = LocationDescRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=dev_id)
update_terminal_status(redis, head.dev_id, address)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle locationdesc exception.")
GWException().notify()
def foward_packet_to_si(self, info, packet, address, connection, channel, db):
"""
Response packet or position/report/charge packet
0: success, then forward it to SIServer and record new terminal's address
1: invalid SessionID
"""
try:
head = info.head
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
command=head.command)
dev_id = head.dev_id
resend_key, resend_flag = get_resend_flag(self.redis, dev_id, head.timestamp, head.command)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, self.redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
logging.error("[GW] Invalid sessionID, Terminal: %s", dev_id)
else:
seq = str(int(time.time() * 1000))[-4:]
uargs = DotDict(seq=seq,
dev_id=dev_id,
content=packet)
content = UploadDataComposer(uargs).buf
logging.info("[GW] Forward message to SI:\n%s", content)
if resend_flag:
logging.warn("[GW] Recv resend packet: %s, and drop it!", packet)
else:
append_si_request(content, connection, channel, self.exchange, self.si_binding)
update_terminal_status(self.redis, dev_id, address)
#NOTE: Handle the packet.
if head.command in (GATEWAY.T_MESSAGE_TYPE.POSITION, GATEWAY.T_MESSAGE_TYPE.MULTIPVT,
GATEWAY.T_MESSAGE_TYPE.CHARGE, GATEWAY.T_MESSAGE_TYPE.ILLEGALMOVE,
GATEWAY.T_MESSAGE_TYPE.POWERLOW, GATEWAY.T_MESSAGE_TYPE.ILLEGALSHAKE,
GATEWAY.T_MESSAGE_TYPE.EMERGENCY, GATEWAY.T_MESSAGE_TYPE.POWERDOWN,
GATEWAY.T_MESSAGE_TYPE.STOP):
logging.info("[GW] Head command: %s.", head.command)
if args['success'] == GATEWAY.RESPONSE_STATUS.SUCCESS:
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = self.redis.getvalue(acc_status_info_key)
if acc_status_info and (not acc_status_info['t2_status']): # T2(query) is need
logging.info("[GW] ACC_status is changed, dev_id: %s, acc_status_info: %s",
dev_id, acc_status_info)
args['success'] = 3 # acc_status is changed
#NOTE: composer response for terminal
rc = AsyncRespComposer(args)
request = DotDict(packet=rc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, self.exchange, self.gw_binding)
# resend flag
if not resend_flag:
self.redis.setvalue(resend_key, True, GATEWAY.RESEND_EXPIRY)
elif head.command == GATEWAY.T_MESSAGE_TYPE.UNBIND: # S24-->T24
logging.info("[GW] Head command: %s.", head.command)
up = UNBindParser(info.body, info.head)
status = up.ret['status']
if status == GATEWAY.STATUS.SUCCESS:
delete_terminal_new(dev_id, db, self.redis)
else:
logging.exception("[GW] Invalid command: %s.", head.command)
except:
logging.exception("[GW] Handle SI message exception.")
GWException().notify()
def handle_defend(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S18
defend status report packet
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)
# old version is compatible
if len(body) == 1:
body.append('0')
logging.info("[GW] old version is compatible, append mannual status 0")
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
command=head.command)
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
else:
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)
hp = AsyncParser(body, head)
defend_info = hp.ret
defend_info['mannual_status'] = defend_info['defend_status']
if defend_info['defend_source'] != 0:
# come from sms or web
if defend_info['defend_source'] == "1":
_status = u"设防" if defend_info['defend_status'] == "1" else u"撤防"
tname = QueryHelper.get_alias_by_tid(head.dev_id, redis, db)
sms = SMSCode.SMS_DEFEND_SUCCESS % (tname, _status)
user = QueryHelper.get_user_by_tid(head.dev_id, db)
if user:
SMSHelper.send(user.owner_mobile, sms)
del defend_info['defend_status']
del defend_info['defend_source']
update_mannual_status(db, redis, head.dev_id, defend_info['mannual_status'])
update_terminal_status(redis, head.dev_id, address)
if args['success'] == GATEWAY.RESPONSE_STATUS.SUCCESS:
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info and (not acc_status_info['t2_status']): # T2(query) is need
args['success'] = 3 # acc_status is changed
logging.info("[GW] ACC_status is changed, dev_id: %s, acc_status_info: %s",
dev_id, acc_status_info)
hc = AsyncRespComposer(args)
request = DotDict(packet=hc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle defend status report exception.")
GWException().notify()
def handle_old_login(t_info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S1
Login response packet:
0 - success, then get a sessionID for terminal and record terminal's address
1 - illegal format of sim
2 - expired, service stop or endtime < now
3 - illegal sim, a mismatch between imsi and sim
4 - psd wrong. HK
5 - dev_id is empty
6 - not whitelist
"""
sms = None
args = DotDict(success=GATEWAY.LOGIN_STATUS.SUCCESS,
sessionID='')
dev_id = t_info['dev_id']
resend_key, resend_flag = get_resend_flag(redis, dev_id, t_info.timestamp, t_info.command)
logging.info("[GW] Checking terminal mobile: %s and owner mobile: %s, Terminal: %s",
t_info['t_msisdn'], t_info['u_msisdn'], t_info['dev_id'])
if not (check_phone(t_info['u_msisdn']) and check_phone(t_info['t_msisdn'])):
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
logging.error("[GW] Login failed! Invalid terminal mobile: %s or owner_mobile: %s, dev_id: %s",
t_info['t_msisdn'], t_info['u_msisdn'], t_info['dev_id'])
return
t_status = db.get("SELECT service_status"
" FROM T_TERMINAL_INFO"
" WHERE mobile = %s",
t_info['t_msisdn'])
if t_status and t_status.service_status == GATEWAY.SERVICE_STATUS.OFF:
args.success = GATEWAY.LOGIN_STATUS.EXPIRED
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
logging.error("[GW] Login failed! terminal service expired! mobile: %s, dev_id: %s",
t_info['t_msisdn'], t_info['dev_id'])
return
logging.info("[GW] Checking imsi: %s and mobile: %s, Terminal: %s",
t_info['imsi'], t_info['t_msisdn'], t_info['dev_id'])
tmobile = db.get("SELECT imsi FROM T_TERMINAL_INFO"
" WHERE mobile = %s", t_info['t_msisdn'])
if tmobile and tmobile.imsi and tmobile.imsi != t_info['imsi']:
# check terminal and give a appropriate HK notification
terminal = db.get("SELECT id FROM T_TERMINAL_INFO WHERE tid=%s", t_info['dev_id'])
if terminal:
alias = QueryHelper.get_alias_by_tid(t_info['dev_id'], redis, db)
else:
alias = t_info['t_msisdn']
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
sms = SMSCode.SMS_TERMINAL_HK % alias
SMSHelper.send(t_info['u_msisdn'], sms)
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
logging.error("[GW] Login failed! Illegal SIM: %s for Terminal: %s",
t_info['t_msisdn'], t_info['dev_id'])
return
terminal = db.get("SELECT id, mobile, owner_mobile, service_status"
" FROM T_TERMINAL_INFO"
" WHERE tid = %s", t_info['dev_id'])
if terminal:
if terminal.mobile != t_info['t_msisdn']:
logging.info("[GW] Terminal: %s changed mobile, old mobile: %s, new mobile: %s",
t_info['dev_id'], terminal.mobile,
t_info['t_msisdn'])
if (terminal.owner_mobile == t_info['u_msisdn'] or
terminal.service_status == UWEB.SERVICE_STATUS.TO_BE_UNBIND):
# delete old terminal!
logging.info("[GW] Delete old tid bind relation. tid: %s, owner_mobile: %s, service_status: %s",
t_info['dev_id'], t_info['u_msisdn'],
terminal.service_status)
delete_terminal_new(t_info['dev_id'], db, redis, del_user=False)
exist = db.get("SELECT tid, owner_mobile, service_status FROM T_TERMINAL_INFO"
" WHERE mobile = %s LIMIT 1",
t_info['t_msisdn'])
if exist:
# cannot send unbind packet to dev_id
t_status = None
logging.info("[GW] Delete old tmobile bind relation. tid: %s, mobile: %s",
exist.tid, t_info['t_msisdn'])
delete_terminal_new(exist.tid, db, redis, del_user=False)
if exist.service_status == UWEB.SERVICE_STATUS.TO_BE_UNBIND:
logging.info("[GW] Terminal: %s of %s is to_be_unbind, delete it.",
exist.tid, t_info['t_msisdn'])
elif exist.owner_mobile != t_info['u_msisdn']:
sms = SMSCode.SMS_DELETE_TERMINAL % t_info['t_msisdn']
SMSHelper.send(exist.owner_mobile, sms)
terminal = None
else:
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
sms = SMSCode.SMS_TID_EXIST % t_info['dev_id']
SMSHelper.send(t_info['u_msisdn'], sms)
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
logging.error("[GW] Login failed! Terminal: %s already bound by %s, new mobile: %s",
t_info['dev_id'], terminal.mobile, t_info['t_msisdn'])
return
#NOTE: Check ydcw or ajt
ajt = QueryHelper.get_ajt_whitelist_by_mobile(t_info['t_msisdn'], db)
if ajt:
url_out = ConfHelper.UWEB_CONF.ajt_url_out
else:
url_out = ConfHelper.UWEB_CONF.url_out
logging.info("[GW] Terminal: %s, login url is: %s", t_info['t_msisdn'], url_out)
if t_info['psd']:
flag = 0
# check terminal exist or not when HK
if not terminal:
args.success = GATEWAY.LOGIN_STATUS.UNREGISTER
sms = SMSCode.SMS_TID_NOT_EXIST
SMSHelper.send(t_info['u_msisdn'], sms)
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
logging.error("[GW] Login failed! Terminal %s execute HK, but tid is not exist",
t_info['dev_id'])
return
# HK, change terminal mobile or owner mobile
logging.info("[GW] Checking password. Terminal: %s",
t_info['dev_id'])
owner = db.get("SELECT id FROM T_USER"
" WHERE mobile = %s"
" AND password = password(%s)",
terminal.owner_mobile, t_info['psd'])
if not owner:
# psd wrong
sms = SMSCode.SMS_PSD_WRONG
args.success = GATEWAY.LOGIN_STATUS.PSD_WRONG
logging.error("[GW] Login failed! Password invalid. Terminal: %s",
t_info['dev_id'])
else:
if terminal:
if terminal.mobile != t_info['t_msisdn']:
# terminal HK
logging.info("[GW] Terminal: %s HK started.", t_info['dev_id'])
# unbind old tmobile
old_bind = db.get("SELECT id, tid FROM T_TERMINAL_INFO"
" WHERE mobile = %s"
" AND id != %s",
t_info['t_msisdn'], terminal.id)
if old_bind:
# clear db
db.execute("DELETE FROM T_TERMINAL_INFO"
" WHERE id = %s",
old_bind.id)
# clear redis
sessionID_key = get_terminal_sessionID_key(old_bind.tid)
address_key = get_terminal_address_key(old_bind.tid)
info_key = get_terminal_info_key(old_bind.tid)
lq_sms_key = get_lq_sms_key(old_bind.tid)
lq_interval_key = get_lq_interval_key(old_bind.tid)
keys = [sessionID_key, address_key, info_key, lq_sms_key, lq_interval_key]
redis.delete(*keys)
logging.info("[GW] Delete old bind Terminal: %s, SIM: %s",
t_info['dev_id'], t_info['t_msisdn'])
# update new tmobile
db.execute("UPDATE T_TERMINAL_INFO"
" SET mobile = %s,"
" imsi = %s"
" WHERE id = %s",
t_info['t_msisdn'],
t_info['imsi'], terminal.id)
# clear redis
sessionID_key = get_terminal_sessionID_key(t_info['dev_id'])
address_key = get_terminal_address_key(t_info['dev_id'])
info_key = get_terminal_info_key(t_info['dev_id'])
lq_sms_key = get_lq_sms_key(t_info['dev_id'])
lq_interval_key = get_lq_interval_key(t_info['dev_id'])
keys = [sessionID_key, address_key, info_key, lq_sms_key, lq_interval_key]
redis.delete(*keys)
# HK sms
sms = SMSCode.SMS_TERMINAL_HK_SUCCESS % (terminal.mobile, t_info['t_msisdn'])
# subscription LE for new sim
thread.start_new_thread(subscription_lbmp, (t_info,))
logging.info("[GW] Terminal: %s HK success!", t_info['dev_id'])
if terminal.owner_mobile != t_info['u_msisdn']:
logging.info("[GW] Owner HK started. Terminal: %s", t_info['dev_id'])
# owner HK
user = db.get("SELECT id FROM T_USER"
" WHERE mobile = %s",
t_info['u_msisdn'])
if user:
logging.info("[GW] Owner already existed. Terminal: %s", t_info['dev_id'])
sms = SMSCode.SMS_USER_ADD_TERMINAL % (t_info['t_msisdn'],
url_out)
else:
logging.info("[GW] Create new owner started. Terminal: %s", t_info['dev_id'])
psd = get_psd()
user_info = dict(umobile=t_info['u_msisdn'],
password=psd)
add_user(user_info, db, redis)
sms = SMSCode.SMS_USER_HK_SUCCESS % (t_info['u_msisdn'],
url_out,
t_info['u_msisdn'],
psd)
db.execute("UPDATE T_TERMINAL_INFO"
" SET owner_mobile = %s"
" WHERE id = %s",
t_info['u_msisdn'], terminal.id)
logging.info("[GW] Owner of %s HK success!", t_info['dev_id'])
else:
logging.error("[GW] What happened? Cannot find old terminal by dev_id: %s",
t_info['dev_id'])
else:
flag = 1
# login or JH
if terminal:
# login
logging.info("[GW] Terminal: %s Normal login started!",
t_info['dev_id'])
else:
# SMS JH or admin JH or change new dev JH
logging.info("[GW] Terminal: %s, mobile: %s JH started.",
t_info['dev_id'], t_info['t_msisdn'])
exist = db.get("SELECT id FROM T_USER"
" WHERE mobile = %s",
t_info['u_msisdn'])
if exist:
logging.info("[GW] Owner already existed. Terminal: %s", t_info['dev_id'])
sms = SMSCode.SMS_USER_ADD_TERMINAL % (t_info['t_msisdn'],
url_out)
else:
# get a new psd for new user
logging.info("[GW] Create new owner started. Terminal: %s", t_info['dev_id'])
psd = get_psd()
user_info = dict(umobile=t_info['u_msisdn'],
password=psd,
uname=t_info['u_msisdn'])
add_user(user_info, db, redis)
sms = SMSCode.SMS_JH_SUCCESS % (t_info['t_msisdn'],
url_out,
t_info['u_msisdn'],
psd)
admin_terminal = db.get("SELECT id, tid FROM T_TERMINAL_INFO"
" WHERE tid = %s",
t_info['t_msisdn'])
if admin_terminal:
# admin JH
db.execute("UPDATE T_TERMINAL_INFO"
" SET tid = %s,"
" dev_type = %s,"
" owner_mobile = %s,"
" imsi = %s,"
" imei = %s,"
" factory_name = %s,"
" keys_num = %s,"
" softversion = %s"
" WHERE id = %s",
t_info['dev_id'],
t_info['dev_type'],
t_info['u_msisdn'],
t_info['imsi'],
t_info['imei'],
t_info['factory_name'],
t_info['keys_num'],
t_info['softversion'],
admin_terminal.id)
db.execute("UPDATE T_CAR SET tid = %s"
" WHERE tid = %s",
t_info['dev_id'], t_info['t_msisdn'])
logging.info("[GW] Terminal %s by ADMIN JH success!", t_info['dev_id'])
else:
exist_terminal = db.get("SELECT id, tid FROM T_TERMINAL_INFO"
" WHERE mobile = %s",
t_info['t_msisdn'])
if exist_terminal:
# unbind old tmobile
db.execute("DELETE FROM T_TERMINAL_INFO"
" WHERE id = %s",
exist_terminal.id)
# clear redis
sessionID_key = get_terminal_sessionID_key(exist_terminal.tid)
address_key = get_terminal_address_key(exist_terminal.tid)
info_key = get_terminal_info_key(exist_terminal.tid)
lq_sms_key = get_lq_sms_key(exist_terminal.tid)
lq_interval_key = get_lq_interval_key(exist_terminal.tid)
keys = [sessionID_key, address_key, info_key, lq_sms_key, lq_interval_key]
redis.delete(*keys)
logging.info("[GW] Terminal %s change dev, old dev: %s!",
t_info['dev_id'], exist_terminal.tid)
# send JH sms to terminal. default active time
# is one year.
begintime = datetime.datetime.now()
endtime = begintime + relativedelta(years=1)
terminal_info = dict(tid=t_info['dev_id'],
dev_type=t_info['dev_type'],
tmobile=t_info['t_msisdn'],
owner_mobile=t_info['u_msisdn'],
imsi=t_info['imsi'],
imei=t_info['imei'],
factory_name=t_info['factory_name'],
softversion=t_info['softversion'],
keys_num=t_info['keys_num'],
login=GATEWAY.TERMINAL_LOGIN.ONLINE,
service_status=UWEB.SERVICE_STATUS.ON,
group_id=-1,
mannual_status=UWEB.DEFEND_STATUS.YES,
begintime=int(time.mktime(begintime.timetuple())),
endtime=4733481600,
offline_time=int(time.mktime(begintime.timetuple())),
biz_type=UWEB.BIZ_TYPE.YDWS)
add_terminal(terminal_info, db, redis)
# record the add action, enterprise or individual
bind_info = dict(tid=t_info['dev_id'],
tmobile=t_info['t_msisdn'],
umobile=t_info['u_msisdn'],
group_id=-1,
cid='',
add_time=int(time.time()))
record_add_action(bind_info, db)
logging.info("[GW] Terminal %s by SMS JH success!", t_info['dev_id'])
# subscription LE for new sim
thread.start_new_thread(subscription_lbmp, (t_info,))
if args.success == GATEWAY.LOGIN_STATUS.SUCCESS:
# get SessionID
if resend_flag:
args.sessionID = QueryHelper.get_terminal_sessionID(t_info['dev_id'], redis)
logging.warn("[GW] Recv resend login packet: %s and use old sessionID: %s!", t_info, args.sessionID)
if not args.sessionID:
args.sessionID = get_sessionID()
else:
args.sessionID = get_sessionID()
terminal_sessionID_key = get_terminal_sessionID_key(t_info['dev_id'])
redis.setvalue(terminal_sessionID_key, args.sessionID)
redis.setvalue(resend_key, True, GATEWAY.RESEND_EXPIRY)
# record terminal address
update_terminal_status(redis, t_info["dev_id"], address)
# set login
info = DotDict(login=GATEWAY.TERMINAL_LOGIN.ONLINE,
mobile=t_info['t_msisdn'],
keys_num=t_info['keys_num'],
login_time=int(time.time()),
dev_id=t_info["dev_id"])
update_terminal_info(db, redis, info)
logging.info("[GW] Terminal %s login success! SIM: %s",
t_info['dev_id'], t_info['t_msisdn'])
#NOTE: wspush to cient
if flag != "1": # normal login
WSPushHelper.pushS4(t_info["dev_id"], db, redis)
else: # JH
pass
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
if sms and t_info['u_msisdn']:
SMSHelper.send(t_info['u_msisdn'], sms)
# unbind terminal of to_be_unbind
if t_status and t_status.service_status == UWEB.SERVICE_STATUS.TO_BE_UNBIND:
logging.info("[GW] Terminal: %s is unbinded, send unbind packet.", t_info["dev_id"])
seq = str(int(time.time()*1000))[-4:]
args = DotDict(seq=seq,
tid=t_info["dev_id"])
ubc = UNBindComposer(args)
request = DotDict(packet=ubc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
def handle_new_login(t_info, address, connection, channel, exchange, gw_binding, db, redis):
"""Handle the login packet with version bigger than 2.2.0
S1
t_info:{'dev_id' // tid
't_msisdn' // tmobile
'u_msisdn' // umobile
'imei' // sim's id
'imsi' // track's id
'dev_type'
'softversion' // version of terminal, like 2.3.0
'timestamp'
'psd'
'keys_num'
'sessionID'
'command'
'factory_name'
}
flag(t_info['psd']):
0 - boot_normally
1 - active_terminal
2 - assert_reboot
3 - network_uncovered
4 - server_no_response
5 - config_changed
6 - session_expired
7 - terminal_unactived
8 - package_send_fail
9 - simcard_error
10 - gprs_error
11 - mcu_timeout
12 - reboot_by_sms
100 - script_reload
workflow:
if normal login:
if sn and imsi exist, but msisdn and msisdn are empty:
send register sms again
normal login, check [SN,PHONE,IMSI,USER] is matching or not.
else: #JH
delete old bind relation of tid, and send message to old user.
update new bind relation of tmobile, and send message to new user.
login response packet:
0 - success, then get a sessionID for terminal and record terminal's address
1 - unregister, terminal login first.
3 - illegal sim, a mismatch between [SN,PHONE,IMSI,USER]
6 - not whitelist
"""
args = DotDict(success=GATEWAY.LOGIN_STATUS.SUCCESS,
sessionID='')
tid = t_info.dev_id
resend_key, resend_flag = get_resend_flag(redis, tid, t_info.timestamp, t_info.command)
sms = ''
t_status = None
#NOTE: new softversion, new meaning, 1: active; othter: normal login
flag = t_info['psd']
terminal = db.get("SELECT tid, group_id, mobile, imsi, owner_mobile, service_status,"
" defend_status, mannual_status, icon_type, login_permit, "
" alias, vibl, use_scene, push_status, speed_limit, stop_interval,"
" distance_current"
" FROM T_TERMINAL_INFO"
" WHERE mobile = %s LIMIT 1",
t_info['t_msisdn'])
cnum = QueryHelper.get_cnum_by_terminal(tid, t_info['t_msisdn'], redis, db)
#NOTE: normal login
if flag != "1": # normal login
#NOTE: no tmobile and ower_mobile
if (not t_info['t_msisdn']) and (not t_info['u_msisdn']):
t = db.get("SELECT tid, group_id, mobile, imsi, owner_mobile, service_status"
" FROM T_TERMINAL_INFO"
" WHERE service_status=1"
" AND tid = %s "
" AND imsi = %s LIMIT 1",
t_info['dev_id'], t_info['imsi'])
if t:
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
t_info['t_msisdn'] = t.mobile
t_info['u_msisdn'] = t.owner_mobile
register_sms = SMSCode.SMS_REGISTER % (t.owner_mobile, t.mobile)
SMSHelper.send_to_terminal(t.mobile, register_sms)
logging.info("[GW] A crash terminal tid:%s, imei:%s has no tmobile: %s, umobile:%s in login packet, so send %s again.",
t_info['dev_id'], t_info['imei'], t_info['t_msisdn'], t_info['u_msisdn'], register_sms)
else:
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
logging.info("[GW] A crash terminal:%s login without umobile and tmobile, and there is no record in db.", t_info['dev_id'])
else:
#NOTE: no tmobile
if not t_info['t_msisdn']:
# login first.
tid_terminal = db.get("SELECT tid, mobile, owner_mobile, service_status"
" FROM T_TERMINAL_INFO"
" WHERE tid = %s LIMIT 1", t_info['dev_id'])
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
if tid_terminal:
#NOTE: mobile is not not JH, send caution to owner
sms_ = SMSCode.SMS_NOT_JH % tid_terminal.mobile
SMSHelper.send(tid_terminal.owner_mobile, sms_)
logging.warn("[GW] terminal: %s login at first time.",
t_info['dev_id'])
#NOTE: tmobile is exist
elif terminal:
alias = QueryHelper.get_alias_by_tid(terminal['tid'], redis, db)
if terminal['tid'] != t_info['dev_id']:
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
sms = SMSCode.SMS_TERMINAL_HK % alias
logging.warn("[GW] Terminal changed dev, mobile: %s, old_tid: %s, new_tid: %s",
t_info['t_msisdn'], terminal['tid'], t_info['dev_id'])
elif terminal['imsi'] != t_info['imsi']:
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
sms = SMSCode.SMS_TERMINAL_HK % alias
logging.warn("[GW] Terminal imsi is wrong, tid: %s, mobile: %s, old_imsi: %s, new_imsi: %s",
t_info['dev_id'], t_info['t_msisdn'], terminal['imsi'], t_info['imsi'])
elif terminal['owner_mobile'] != t_info['u_msisdn']:
register_sms = SMSCode.SMS_REGISTER % (terminal['owner_mobile'], terminal['mobile'])
SMSHelper.send_to_terminal(terminal['mobile'], register_sms)
logging.warn("[GW] Terminal owner_mobile is wrong, tid: %s, old_owner_mobile: %s, new_owner_mobile: %s, send the regist sms: %s again",
t_info['dev_id'], terminal['owner_mobile'], t_info['u_msisdn'], register_sms)
elif terminal['service_status'] == UWEB.SERVICE_STATUS.TO_BE_UNBIND:
t_status = UWEB.SERVICE_STATUS.TO_BE_UNBIND
logging.warn("[GW] Terminal is unbinded. tid: %s, mobile: %s",
t_info["dev_id"], t_info['t_msisdn'])
else:
logging.info("[GW] Terminal normal login successfully. tid: %s, mobile: %s",
t_info['dev_id'], t_info['t_msisdn'])
else:
args.success = GATEWAY.LOGIN_STATUS.UNREGISTER
logging.error("[GW] Terminal login failed, unregister. tid: %s, mobile: %s",
t_info['dev_id'], t_info['t_msisdn'])
#NOTE: JH
else: # JH
logging.info("[GW] Terminal JH started. tid: %s, mobile: %s",
t_info['dev_id'], t_info['t_msisdn'])
# 0. Initialize the valus keeps same as the default value in database.
group_id = -1
login_permit = 1
mannual_status = UWEB.DEFEND_STATUS.YES
defend_status = UWEB.DEFEND_STATUS.YES
icon_type = 0
alias = ''
push_status = 1
vibl = 1
use_scene = 3
speed_limit = 120
stop_interval = 0
distance_current = 0
# send JH sms to terminal. default active time is one year.
begintime = datetime.datetime.now()
endtime = begintime + relativedelta(years=1)
# 1. check data validation
logging.info("[GW] Checking terminal mobile: %s and owner mobile: %s, Terminal: %s",
t_info['t_msisdn'], t_info['u_msisdn'], t_info['dev_id'])
if not (check_phone(t_info['u_msisdn']) and check_phone(t_info['t_msisdn'])):
args.success = GATEWAY.LOGIN_STATUS.ILLEGAL_SIM
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info['dev_id'])
if t_info['u_msisdn']:
# send JH failed caution to owner
sms = SMSCode.SMS_JH_FAILED
SMSHelper.send(t_info['u_msisdn'], sms)
logging.error("[GW] Login failed! Invalid terminal mobile: %s or owner_mobile: %s, tid: %s",
t_info['t_msisdn'], t_info['u_msisdn'], t_info['dev_id'])
append_gw_request(request, connection, channel, exchange, gw_binding)
# 2. delete to_be_unbind terminal
if terminal and terminal.service_status == UWEB.SERVICE_STATUS.TO_BE_UNBIND:
logging.info("[GW] Delete terminal which is to_be_unbind. tid: %s, mobile: %s",
terminal['tid'], terminal['mobile'])
delete_terminal_new(terminal['tid'], db, redis)
terminal = None
# 3. add user info
exist = db.get("SELECT id FROM T_USER"
" WHERE mobile = %s",
t_info['u_msisdn'])
#NOTE: Check ydcw or ajt
ajt = QueryHelper.get_ajt_whitelist_by_mobile(t_info['t_msisdn'], db)
if ajt:
url_out = ConfHelper.UWEB_CONF.ajt_url_out
else:
url_out = ConfHelper.UWEB_CONF.url_out
logging.info("[GW] Login url is: %s, tid: %s, mobile: %s ",
url_out, t_info['dev_id'], t_info['t_msisdn'])
if exist:
logging.info("[GW] Owner already existed. tid: %s, mobile: %s",
t_info['dev_id'], t_info['t_msisdn'])
sms = SMSCode.SMS_USER_ADD_TERMINAL % (t_info['t_msisdn'],
url_out)
else:
# get a new psd for new user
logging.info("[GW] Create new owner started. tid: %s, mobile: %s", t_info['dev_id'], t_info['t_msisdn'])
psd = get_psd()
user_info = dict(umobile=t_info['u_msisdn'],
password=psd,
uname=t_info['u_msisdn'])
add_user(user_info, db, redis)
sms = SMSCode.SMS_JH_SUCCESS % (t_info['t_msisdn'],
url_out,
t_info['u_msisdn'],
psd)
# 4. JH existed tmobile
is_refurbishment = False
if terminal:
if (terminal['tid'] == t_info['dev_id']) and \
(terminal['imsi'] == t_info['imsi']) and \
(terminal['owner_mobile'] == t_info['u_msisdn']):
# 4.1 SCN: Refurbishment, the terminal-info has existed in platform. JH it again.
is_refurbishment = True
# check the login packet whether is send again
if resend_flag:
sms = ''
logging.info("[GW] Recv resend packet, do not send sms. tid: %s, mobile: %s",
t_info['dev_id'], t_info['t_msisdn'])
else:
sms = SMSCode.SMS_USER_ADD_TERMINAL % (t_info['t_msisdn'],
url_out)
logging.info("[GW] Terminal is refurbishment. tid: %s, mobile: %s",
t_info['dev_id'], t_info['t_msisdn'])
else:
# 4.2 existed tmobile changed dev or corp terminal login first, get the old info(group_id, login_permit and so on) before change
group_id = terminal.group_id
login_permit = terminal.login_permit
mannual_status = terminal.mannual_status
defend_status = terminal.defend_status
icon_type = terminal.icon_type
alias = terminal.alias
vibl = terminal.vibl
use_scene = terminal.use_scene
push_status = terminal.push_status
speed_limit = terminal.speed_limit
stop_interval = terminal.stop_interval
distance_current = terminal.distance_current
if terminal.tid == terminal.mobile:
# corp terminal login first, keep corp info
db.execute("UPDATE T_REGION_TERMINAL"
" SET tid = %s"
" WHERE tid = %s",
t_info['dev_id'], t_info['t_msisdn'])
logging.info("[GW] Corp terminal login first, tid: %s, mobile: %s.",
t_info['dev_id'], t_info['t_msisdn'])
elif terminal.tid != t_info['dev_id']:
logging.info("[GW] Terminal changed dev, mobile: %s, new_tid: %s, delete old_tid: %s.",
t_info['t_msisdn'], t_info['dev_id'], terminal.tid)
else:
# Refurbishment, change user
logging.info("[GW] Terminal change user, tid: %s, mobile: %s, new_owner_mobile: %s, old_owner_mobile: %s",
t_info['dev_id'], t_info['t_msisdn'], t_info['u_msisdn'],
terminal.owner_mobile)
#NOTE: If terminal has exist, firt remove the terminal
logging.info("[GW] Terminal is deleted, tid: %s, mobile: %s.",
terminal['tid'], terminal['mobile'])
del_user = True
if terminal.owner_mobile != t_info['u_msisdn']:
# send message to old user of dev_id
sms_ = SMSCode.SMS_DELETE_TERMINAL % terminal.mobile
SMSHelper.send(terminal.owner_mobile, sms_)
if terminal.tid == t_info['dev_id']:
# clear data belongs to the terminal
clear_data(terminal.tid, db, redis)
logging.info("[GW] Send delete terminal message: %s to user: %s",
sms_, terminal.owner_mobile)
else:
del_user = False
delete_terminal_new(terminal.tid, db, redis, del_user=del_user)
#NOTE: Normal JH.
if not is_refurbishment:
# 5. delete existed tid
tid_terminal = db.get("SELECT tid, mobile, owner_mobile, service_status"
" FROM T_TERMINAL_INFO"
" WHERE tid = %s LIMIT 1",
t_info['dev_id'])
if tid_terminal:
logging.info("[GW] Terminal is deleted, tid: %s, mobile: %s.",
tid_terminal['tid'], tid_terminal['mobile'])
del_user = True
if tid_terminal['owner_mobile'] != t_info['u_msisdn']:
if tid_terminal['service_status'] == UWEB.SERVICE_STATUS.TO_BE_UNBIND:
logging.info("[GW] Terminal is to_be_unbind, tid: %s, mobile: %s, delete it.",
tid_terminal['tid'], tid_terminal['mobile'])
else:
# send message to old user of dev_id
sms_ = SMSCode.SMS_DELETE_TERMINAL % tid_terminal['mobile']
SMSHelper.send(tid_terminal['owner_mobile'], sms_)
logging.info("[GW] Send delete terminal message: %s to user: %s",
sms_, tid_terminal['owner_mobile'])
# user changed, must clear history data of dev_id
clear_data(tid_terminal['tid'], db, redis)
else:
del_user = False
delete_terminal_new(tid_terminal['tid'], db, redis, del_user=del_user)
# 6 add terminal info
# check use sence
ttype = get_terminal_type_by_tid(t_info['dev_id'])
logging.info("[GW] Terminal's type is %s. tid: %s, mobile: %s",
ttype, t_info['dev_id'], t_info['t_msisdn'])
terminal_info = dict(tid=t_info['dev_id'],
group_id=group_id,
dev_type=t_info['dev_type'],
tmobile=t_info['t_msisdn'],
owner_mobile=t_info['u_msisdn'],
imsi=t_info['imsi'],
imei=t_info['imei'],
factory_name=t_info['factory_name'],
softversion=t_info['softversion'],
keys_num=t_info['keys_num'],
login=GATEWAY.TERMINAL_LOGIN.ONLINE,
service_status=UWEB.SERVICE_STATUS.ON,
mannual_status=mannual_status,
push_status=push_status,
icon_type=icon_type,
begintime=int(time.mktime(begintime.timetuple())),
endtime=4733481600,
offline_time=int(time.mktime(begintime.timetuple())),
cnum=cnum,
login_permit=login_permit,
bt_mac=t_info['bt_mac'],
bt_name=t_info['bt_name'],
vibl=vibl,
use_scene=use_scene,
biz_type=UWEB.BIZ_TYPE.YDWS,
alias=alias,
speed_limit=speed_limit,
stop_interval=stop_interval,
distance_current=distance_current)
add_terminal(terminal_info, db, redis)
# record the add action, enterprise or individual
corp = QueryHelper.get_corp_by_gid(group_id, db)
bind_info = dict(tid=t_info['dev_id'],
tmobile=t_info['t_msisdn'],
umobile=t_info['u_msisdn'],
group_id=group_id,
cid=corp.get('cid', '') if corp else '',
add_time=int(time.time()))
record_add_action(bind_info, db)
logging.info("[GW] Terminal JH success! tid: %s, mobile: %s.",
t_info['dev_id'], t_info['t_msisdn'])
# subscription LE for new sim
thread.start_new_thread(subscription_lbmp, (t_info,))
if args.success == GATEWAY.LOGIN_STATUS.SUCCESS:
# get SessionID
if resend_flag:
logging.warn("[GW] Recv resend login packet and use old sessionID! packet: %s, tid: %s, mobile: %s.",
t_info, t_info['dev_id'], t_info['t_msisdn'])
args.sessionID = QueryHelper.get_terminal_sessionID(t_info['dev_id'], redis)
if not args.sessionID:
args.sessionID = get_sessionID()
else:
#NOTE: generate a sessionid and keep it in redis.
args.sessionID = get_sessionID()
terminal_sessionID_key = get_terminal_sessionID_key(t_info['dev_id'])
redis.setvalue(terminal_sessionID_key, args.sessionID)
redis.setvalue(resend_key, True, GATEWAY.RESEND_EXPIRY)
# record terminal address
update_terminal_status(redis, t_info["dev_id"], address)
#NOTE: When termianl is normal login, update some properties to platform.
info = DotDict(login=GATEWAY.TERMINAL_LOGIN.ONLINE,
mobile=t_info['t_msisdn'],
keys_num=t_info['keys_num'],
softversion=t_info['softversion'],
login_time=int(time.time()),
dev_id=t_info["dev_id"],
bt_mac=t_info['bt_mac'],
bt_name=t_info['bt_name'],
dev_type=t_info['dev_type'])
update_terminal_info(db, redis, info)
logging.info("[GW] Terminal login success! tid: %s, mobile: %s",
t_info['dev_id'], t_info['t_msisdn'])
#NOTE: wspush to cient
if flag != "1": # normal login
WSPushHelper.pushS4(t_info["dev_id"], db, redis)
else: # JH
pass
lc = LoginRespComposer(args)
request = DotDict(packet=lc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
if sms and t_info['u_msisdn']:
logging.info("[GW] Send sms to owner. mobile: %s, content: %s",
t_info['u_msisdn'], sms)
SMSHelper.send(t_info['u_msisdn'], sms)
if t_status == UWEB.SERVICE_STATUS.TO_BE_UNBIND:
seq = str(int(time.time()*1000))[-4:]
args_ = DotDict(seq=seq,
tid=t_info["dev_id"])
ubc = UNBindComposer(args_)
request = DotDict(packet=ubc.buf,
address=address,
dev_id=t_info["dev_id"])
append_gw_request(request, connection, channel, exchange, gw_binding)
logging.warn("[GW] Terminal is unbinded, tid: %s, send unbind packet.", t_info["dev_id"])
def handle_runtime(info, address, connection, channel, exchange, gw_binding, db, redis):
"""
S23
runtime status packet: {login [0:unlogin | 1:login],
defend_status [0:undefend | 1:defend],
gps:gsm:pbat [0-100:0-9:0-100]}
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)
if len(body) == 3:
body.append('-1')
body.append('0')
logging.info("[GW] old version is compatible, append fob_pbat, is_send")
if len(body) == 4:
body.append('0')
logging.info("[GW] old version is compatible, append is_send")
args = DotDict(success=GATEWAY.RESPONSE_STATUS.SUCCESS,
command=head.command,
mannual_status='')
sessionID = QueryHelper.get_terminal_sessionID(dev_id, redis)
if sessionID != head.sessionID:
args.success = GATEWAY.RESPONSE_STATUS.INVALID_SESSIONID
else:
if resend_flag:
logging.warn("[GW] Recv resend packet, head: %s, body: %s and drop it!",
info.head, info.body)
terminal_info = QueryHelper.get_terminal_info(head.dev_id, db, redis)
args.mannual_status = terminal_info['mannual_status']
else:
redis.setvalue(resend_key, True, GATEWAY.RESEND_EXPIRY)
hp = AsyncParser(body, head)
runtime_info = hp.ret
update_terminal_status(redis, head.dev_id, address)
terminal_info = update_terminal_info(db, redis, runtime_info)
args.mannual_status = terminal_info['mannual_status']
db.execute("INSERT INTO T_RUNTIME_STATUS"
" VALUES(NULL, %s, %s, %s, %s, %s, %s, %s, %s)",
head.dev_id, runtime_info['login'], runtime_info['defend_status'],
runtime_info['gps'], runtime_info['gsm'], runtime_info['pbat'],
runtime_info['fob_pbat'], head.timestamp)
is_send = int(runtime_info['is_send'])
if is_send:
terminal_info = QueryHelper.get_terminal_info(head.dev_id, db, redis)
alias = QueryHelper.get_alias_by_tid(head.dev_id, redis, db)
communication_staus = u'正常'
communication_mode = u'撤防'
gsm_strength = u'强'
gps_strength = u'强'
if int(terminal_info['login']) == GATEWAY.TERMINAL_LOGIN.ONLINE:
communication_staus = u'正常'
else:
communication_staus = u'异常'
if int(terminal_info['mannual_status']) == UWEB.DEFEND_STATUS.YES:
communication_mode = u'强力设防'
elif int(terminal_info['mannual_status']) == UWEB.DEFEND_STATUS.SMART:
communication_mode = u'智能设防'
else:
communication_mode= u'撤防'
pbat = int(terminal_info.get('pbat', 0))
gsm = int(terminal_info.get('gsm', 0))
if gsm < 3:
gsm_strength = u'弱'
elif gsm < 6:
gsm_strength = u'较弱'
gps = int(terminal_info.get('gps', 0))
if gps < 10:
gps_strength = u'弱'
elif gps < 20:
gps_strength = u'较弱'
elif gps < 30:
gps_strength = u'较强'
runtime_sms = SMSCode.SMS_RUNTIME_STATUS % (alias, communication_staus, communication_mode, int(pbat), gsm_strength, gps_strength)
SMSHelper.send(terminal_info.owner_mobile, runtime_sms)
logging.info("[GW] Send runtime_status sms to user: %s, tid: %s",
terminal_info.owner_mobile, head.dev_id)
update_terminal_status(redis, head.dev_id, address)
if args['success'] == GATEWAY.RESPONSE_STATUS.SUCCESS:
acc_status_info_key = get_acc_status_info_key(dev_id)
acc_status_info = redis.getvalue(acc_status_info_key)
if acc_status_info and (not acc_status_info['t2_status']): # T2(query) is need
args['success'] = 3 # acc_status is changed
logging.info("[GW] ACC_status is changed, dev_id: %s, acc_status_info: %s",
dev_id, acc_status_info)
rc = RuntimeRespComposer(args)
request = DotDict(packet=rc.buf,
address=address,
dev_id=dev_id)
append_gw_request(request, connection, channel, exchange, gw_binding)
except:
logging.exception("[GW] Handle runtime status report exception.")
GWException().notify()