def _on_finish(response):
response = json_decode(response)
if response['success'] == ErrorCode.SUCCESS:
new_fobs = response['params']['FOBS']
if new_fobs:
fobs = self.db.query("SELECT fobid FROM T_FOB"
" WHERE tid = %s",
tid)
old_fobids = [fob.fobid for fob in fobs]
new_fobids = new_fobs.split(':')
add_fobids = list(set(new_fobids) - set(old_fobids))
del_fobids = list(set(old_fobids) - set(new_fobids))
for fobid in add_fobids:
self.db.execute("INSERT INTO T_FOB(tid, fobid)"
" VALUES(%s, %s)",
tid, fobid)
for fobid in del_fobids:
self.db.execute("DELETE FROM T_FOB"
" WHERE tid = %s"
" AND fobid = %s",
tid, fobid)
if len(old_fobids) != len(new_fobids):
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET keys_num = %s"
" WHERE tid = %s",
len(new_fobids),
tid)
# redis
terminal_info_key = get_terminal_info_key(tid)
terminal_info = self.redis.getvalue(terminal_info_key)
if terminal_info:
terminal_info['fob_list'] = new_fobids
terminal_info['keys_num'] = len(new_fobids)
self.redis.setvalue(terminal_info_key, terminal_info)
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 = QueryHelper.get_available_terminal(tid, self.db)
if not terminal:
status = ErrorCode.LOGIN_AGAIN
logging.error("[UWEB] The terminal with tid: %s does not exist, redirect to login.html",
self.current_user.tid)
self.write_ret(status)
return
else:
terminal_info_key = get_terminal_info_key(self.current_user.tid)
terminal_info = self.redis.getvalue(terminal_info_key)
mannual_status = terminal_info['mannual_status']
self.write_ret(status,
dict_=DotDict(defend_status=mannual_status,
mannual_status=mannual_status,
fob_status=terminal.fob_status))
except Exception as e:
logging.exception("[UWEB] uid:%s tid:%s get defend status failed. Exception: %s",
self.current_user.uid, self.current_user.tid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
return
def modify_terminal():
db = DBConnection().db
redis = MyRedis()
mobile='14778746907'
#mobile='14778741845'
#mobile='14778749172'
#mobile='14778746786'
#mobile='14778740942'
#mobile='14778745985'
#mobile='14778744628'
#mobile='14778744861'
#mobile='14778742261'
#mobile='14778744473'
#mobile='14778747112'
#mobile='14778745219'
#mobile='14778742290'
#mobile='14778749137'
#mobile='14778742587'
#mobile='14778745073'
#mobile='14778747467'
#mobile='14778741340'
#mobile='14778748943'
#mobile='14778743681'
sql = "select id, tid, mobile, owner_mobile, begintime, login_time from T_TERMINAL_INFO where mobile= %s"
terminals = db.query(sql, mobile)
#print 'len ', len(terminals)
count = 0
cnt = 0
no_loc = 0
for i, t in enumerate(terminals):
tid = t.tid
mobile = t.mobile
owner_mobile = t.owner_mobile
terminal_info_key = get_terminal_info_key(tid)
terminal_info = redis.getvalue(terminal_info_key)
if terminal_info:
print 'umobile in redis:%s, umobile in db:%s' % (terminal_info['owner_mobile'], owner_mobile)
if terminal_info['owner_mobile'] != owner_mobile:
print 'mobile: %s, umobile in redis:%s, umobile in db:%s' % (mobile, terminal_info['owner_mobile'], owner_mobile)
cnt = cnt + 1
terminal_info['owner_mobile'] = owner_mobile
redis.setvalue(terminal_info_key, terminal_info)
else:
pass
print 'count:', count
print 'cnt:', cnt
def put(self):
"""Modify profile of current user.
"""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
tid = data.get('tid',None)
# check tid whether exist in request and update current_user
self.check_tid(tid)
logging.info("[UWEB] User profile request: %s, uid: %s, tid: %s",
data, self.current_user.uid, self.current_user.tid)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
return
try:
if data.has_key('name') and not check_name(data.name):
status = ErrorCode.ILLEGAL_NAME
self.write_ret(status)
return
name = data.get('name', None)
if name is not None:
sql_cmd = "UPDATE T_USER SET name = %s WHERE uid = %s"
self.db.execute(sql_cmd,
name, self.current_user.uid)
cnum = data.get('cnum', None)
if cnum is not None:
self.db.execute("UPDATE T_CAR"
" SET cnum = %s"
" WHERE tid = %s",
safe_unicode(cnum), self.current_user.tid)
terminal_info_key = get_terminal_info_key(self.current_user.tid)
terminal_info = self.redis.getvalue(terminal_info_key)
if terminal_info:
terminal_info['alias'] = cnum if cnum else self.current_user.sim
self.redis.setvalue(terminal_info_key, terminal_info)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] Update profile failed. uid:%s, tid:%s, Exception: %s",
self.current_user.uid, self.current_user.tid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def post(self, tmobile, service_status):
status = ErrorCode.SUCCESS
try:
terminal = self.db.get("SELECT id, tid FROM T_TERMINAL_INFO"
" WHERE mobile = %s",
tmobile)
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET service_status = %s"
" WHERE id = %s",
service_status, terminal.id)
# clear redis
sessionID_key = get_terminal_sessionID_key(terminal.tid)
address_key = get_terminal_address_key(terminal.tid)
info_key = get_terminal_info_key(terminal.tid)
lq_sms_key = get_lq_sms_key(terminal.tid)
lq_interval_key = get_lq_interval_key(terminal.tid)
keys = [sessionID_key, address_key, info_key, lq_sms_key, lq_interval_key]
self.redis.delete(*keys)
except Exception as e:
status = ErrorCode.FAILED
logging.exception("[ADMIN] Update service_status to %s failed."
" tmobile: %s, Exception: %s",
service_status, tmobile, e.args)
self.write_ret(status)
def post(self, tmobile):
"""Modify a business."""
fields = DotDict(cnum="",
ctype="",
ccolor="",
cbrand="",
uname="",
umobile="",
tmobile="",
service_status="",
begintime="",
endtime="",
address="",
email="")
for key in fields.iterkeys():
fields[key] = self.get_argument(key, "")
if fields[key]:
if not check_sql_injection(fields[key]):
logging.error("Edit business condition contain SQL inject. %s : %s",
key, fields[key])
self.render('errors/error.html',
message=ErrorCode.ERROR_MESSAGE[ErrorCode.EDIT_CONDITION_ILLEGAL])
return
try:
self.db.execute("UPDATE T_USER"
" SET name = %s,"
" address = %s,"
" email = %s "
" WHERE mobile = %s",
fields.uname, fields.address,
fields.email, fields.umobile)
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET begintime = %s,"
" endtime = %s,"
" service_status = %s "
" WHERE mobile = %s",
fields.begintime, fields.endtime,
fields.service_status, fields.tmobile)
terminal = self.db.get("SELECT tid "
" FROM T_TERMINAL_INFO"
" WHERE mobile = %s",
fields.tmobile)
self.db.execute("UPDATE T_CAR"
" SET cnum = %s,"
" type = %s,"
" color = %s,"
" brand = %s "
" WHERE tid = %s",
fields.cnum, fields.ctype,
fields.ccolor, fields.cbrand, terminal.tid)
terminal_info_key = get_terminal_info_key(terminal.tid)
terminal_info = self.redis.getvalue(terminal_info_key)
if terminal_info:
terminal_info['alias'] = fields.cnum if fields.cnum else fields.tmobile
self.redis.setvalue(terminal_info_key, terminal_info)
fields.sms_status = self.get_sms_status(fields.tmobile)
self.render('business/list.html',
business=fields,
status=ErrorCode.SUCCESS,
message='')
except Exception as e:
logging.exception("Edit business failed.mobile: %s, Exception: %s",
tmobile, e.args)
self.render('errors/error.html',
message=ErrorCode.ERROR_MESSAGE[ErrorCode.EDIT_USER_FAILURE])
def post(self):
try:
line_id = int(self.get_argument('line_id'))
logging.info("[CLIENT] map request line_id : %s",
line_id)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
return
try:
cars_info = []
status = ErrorCode.SUCCESS
terminals = self.db.query("SELECT tid "
" FROM T_CAR_LINE, T_LINE_PASSENGER"
" WHERE T_CAR_LINE.line_id = T_LINE_PASSENGER.line_id"
" AND T_CAR_LINE.line_id = %s",
line_id)
tids = [terminal.tid for terminal in terminals]
# 1 inquery data
for tid in tids:
# 1: get terminal info
terminal_info_key = get_terminal_info_key(tid)
terminal = self.redis.getvalue(terminal_info_key)
if not terminal:
terminal = self.db.get("SELECT mannual_status, defend_status,"
" fob_status, mobile, login, gps, gsm,"
" pbat, keys_num"
" FROM T_TERMINAL_INFO"
" WHERE tid = %s",
tid)
terminal = DotDict(terminal)
terminal['alias'] = QueryHelper.get_alias_by_tid(tid, self.redis, self.db)
fobs = self.db.query("SELECT fobid FROM T_FOB"
" WHERE tid = %s", tid)
terminal['fob_list'] = [fob.fobid for fob in fobs]
self.redis.setvalue(terminal_info_key, DotDict(terminal))
if terminal['login'] == GATEWAY.TERMINAL_LOGIN.SLEEP:
terminal['login'] = GATEWAY.TERMINAL_LOGIN.ONLINE
# 2: get location
location_key = get_location_key(str(tid))
location = self.redis.getvalue(location_key)
if not location:
location = self.db.get("SELECT id, speed, timestamp, category, name,"
" degree, type, latitude, longitude, clatitude, clongitude, timestamp"
" FROM T_LOCATION"
" WHERE tid = %s"
" AND NOT (clatitude = 0 AND clongitude = 0)"
" ORDER BY timestamp DESC"
" LIMIT 1",
tid)
if location:
mem_location = DotDict({'id':location.id,
'latitude':location.latitude,
'longitude':location.longitude,
'type':location.type,
'clatitude':location.clatitude,
'clongitude':location.clongitude,
'timestamp':location.timestamp,
'name':location.name,
'degree':float(location.degree),
'speed':float(location.speed)})
self.redis.setvalue(location_key, mem_location, EVENTER.LOCATION_EXPIRY)
if location and location['name'] is None:
location['name'] = ''
car_info=dict(defend_status=terminal['defend_status'] if terminal['defend_status'] is not None else 1,
mannual_status=terminal['mannual_status'] if terminal['mannual_status'] is not None else 1,
fob_status=terminal['fob_status'] if terminal['fob_status'] is not None else 0,
timestamp=location['timestamp'] if location else 0,
speed=location.speed if location else 0,
# NOTE: degree's type is Decimal, float() it before json_encode
degree=float(location.degree) if location else 0.00,
name=location.name if location else '',
type=location.type if location else 1,
latitude=location['latitude'] if location else 0,
longitude=location['longitude'] if location else 0,
clatitude=location['clatitude'] if location else 0,
clongitude=location['clongitude'] if location else 0,
login=terminal['login'] if terminal['login'] is not None else 0,
gps=terminal['gps'] if terminal['gps'] is not None else 0,
gsm=terminal['gsm'] if terminal['gsm'] is not None else 0,
pbat=terminal['pbat'] if terminal['pbat'] is not None else 0,
mobile=terminal['mobile'],
alias=terminal['alias'],
#keys_num=terminal['keys_num'] if terminal['keys_num'] is not None else 0,
keys_num=0,
fob_list=terminal['fob_list'] if terminal['fob_list'] else [])
cars_info.append(car_info)
self.write_ret(status,
dict_=DotDict(cars_info=cars_info))
except Exception as e:
logging.exception("[CLIENT] map show tids lastinfo failed, line_id : %s. Exception: %s",
line_id, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def post(self):
"""Retrive various event.
"""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
tid = data.get('tid', None)
tids = data.get('tids', None)
tids = str_to_list(tids)
if not tids:
tids = [tid, ] if tid else []
tids = [str(t) for t in tids]
if not tid:
tid = tids[0] if len(tids) > 0 else ''
# check tid whether exist in request and update current_user
self.check_tid(tid)
logging.info("[UWEB] Event request: %s, uid: %s, tid: %s, tids: %s",
data, self.current_user.uid, self.current_user.tid, tids)
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:
terminal = QueryHelper.get_available_terminal(self.current_user.tid, self.db)
if not terminal:
status = ErrorCode.LOGIN_AGAIN
logging.error(
"[UWEB] The terminal with tid: %s does not exist, redirect to login.html", self.current_user.tid)
self.write_ret(status)
return
page_size = int(data.get('pagesize', UWEB.LIMIT.PAGE_SIZE))
category = data.get('category', None)
categories = data.get('categories', None)
page_number = int(data.pagenum)
page_count = int(data.pagecnt)
start_time = data.start_time
end_time = data.end_time
# NOTE: all catgories
all_categories = [2, # powerlow
3, # illegalshake
4, # illegalmove
5, # sos
6, # hearbeat lost
7, # region enter
8, # retion out
9, # power off
10, # stop
11, # speed_limit
]
if category is not None:
if int(category) == -1:
categories = all_categories
else:
categories = [int(category), ]
elif categories:
if int(categories[0]) == -1:
categories = all_categories
else:
categories = [int(c) for c in categories]
# NOTE: for individual: the interval between start_time and end_time is one week;
# for enterprise: no need to check time interval
if self.current_user.cid != UWEB.DUMMY_CID:
hide_lst = [5] # enterprise: no sos
else: # individual: no stop
hide_lst = [5, 10, 11]
if (int(end_time) - int(start_time)) > UWEB.QUERY_INTERVAL:
self.write_ret(ErrorCode.QUERY_INTERVAL_EXCESS)
return
# we need return the event count to GUI at first time query
if page_count == -1:
sql = ("SELECT COUNT(*) as count FROM V_EVENT"
" WHERE tid IN %s " +
" AND category IN %s" +
" AND (timestamp BETWEEN %s AND %s)")\
% (tuple(tids + DUMMY_IDS_STR), tuple(list(set(categories) - set(hide_lst)) + DUMMY_IDS), start_time, end_time)
res = self.db.get(sql)
event_count = res.count
d, m = divmod(event_count, page_size)
page_count = (d + 1) if m else d
sql = ("SELECT tid, latitude, longitude, clatitude, clongitude,"
" timestamp, name, type, speed, degree,"
" category, pbat, terminal_type, fobid, rid, locate_error"
" FROM V_EVENT"
" WHERE tid IN %s"
" AND (timestamp BETWEEN %s AND %s)"
" AND category IN %s"
" ORDER BY timestamp DESC"
" LIMIT %s, %s") %\
(tuple(tids + DUMMY_IDS_STR), start_time, end_time,
tuple(list(set(categories) - set(hide_lst)) + DUMMY_IDS), page_number * page_size, page_size)
events = self.db.query(sql)
alias_dict = {}
for tid in tids:
terminal_info_key = get_terminal_info_key(tid)
terminal_info = self.redis.getvalue(terminal_info_key)
alias_dict[tid] = terminal_info['alias'] if terminal_info[
'alias'] else terminal_info['mobile']
# Adjust the fields in events.
for event in events:
event['alias'] = alias_dict[event['tid']]
event['pbat'] = event['pbat'] if event[
'pbat'] is not None else 0
event['fobid'] = event['fobid'] if event[
'fobid'] is not None else u''
event['name'] = event['name'] if event[
'name'] is not None else u''
event['degree'] = float(event['degree'])
event['speed'] = float(event['speed'])
event['comment'] = ''
if event['category'] == EVENTER.CATEGORY.POWERLOW:
if event['terminal_type'] == '1':
if int(event['pbat']) == 100:
event['comment'] = ErrorCode.ERROR_MESSAGE[
ErrorCode.TRACKER_POWER_FULL]
elif int(event['pbat']) <= 5:
event['comment'] = ErrorCode.ERROR_MESSAGE[
ErrorCode.TRACKER_POWER_OFF]
else:
event['comment'] = (
ErrorCode.ERROR_MESSAGE[ErrorCode.TRACKER_POWER_LOW]) % event['pbat']
else:
event['comment'] = ErrorCode.ERROR_MESSAGE[
ErrorCode.FOB_POWER_LOW] % event['fobid']
if event['category'] in [EVENTER.CATEGORY.REGION_ENTER, EVENTER.CATEGORY.REGION_OUT]:
region = self.db.get("SELECT name AS region_name"
" FROM T_REGION"
" WHERE id = %s",
event.rid)
region_name = safe_unicode(
region.region_name) if region else u''
event['comment'] = u'围栏名：' + region_name
self.write_ret(status,
dict_=DotDict(events=events,
pagecnt=page_count))
except Exception as e:
logging.exception("[UWEB] uid:%s, tid:%s get alarm info failed. Exception: %s",
self.current_user.uid, self.current_user.tid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def post(self):
logging.info("[UWEB] Android login test")
status = ErrorCode.SUCCESS
cid = UWEB.DUMMY_CID
oid = UWEB.DUMMY_OID
uid = ConfHelper.UWEB_CONF.test_uid
tid = ConfHelper.UWEB_CONF.test_tid
sim = ConfHelper.UWEB_CONF.test_sim
version_type = int(self.get_argument("version_type", 0))
biz_type = UWEB.BIZ_TYPE.YDWS
self.bookkeep(dict(cid=cid,
oid=oid,
uid=uid,
tid=tid,
sim=sim))
user_info = QueryHelper.get_user_by_uid(uid, self.db)
# NOTE: add cars_info, it's same as lastinfo
cars_info = {}
terminals = QueryHelper.get_terminals_by_uid(uid, biz_type, self.db)
for terminal in terminals:
# 1: get terminal
tid = terminal.tid
group_info = get_group_info_by_tid(self.db, tid)
terminal_info_key = get_terminal_info_key(tid)
terminal_cache = self.redis.getvalue(terminal_info_key)
if terminal_cache:
terminal['gps'] = terminal_cache['gps']
terminal['gsm'] = terminal_cache['gsm']
terminal['pbat'] = terminal_cache['pbat']
mobile = terminal['mobile']
terminal['keys_num'] = 0
if terminal['login'] == GATEWAY.TERMINAL_LOGIN.SLEEP:
terminal['login'] = GATEWAY.TERMINAL_LOGIN.ONLINE
# NOTE: if alias is null, provide cnum or sim instead
terminal['alias'] = QueryHelper.get_alias_by_tid(
tid, self.redis, self.db)
fobs = self.db.query("SELECT fobid FROM T_FOB"
" WHERE tid = %s", tid)
terminal['fob_list'] = [fob.fobid for fob in fobs]
terminal['sim'] = terminal['mobile']
# 2: get location
location = QueryHelper.get_location_info(tid, self.db, self.redis)
if location and not (location.clatitude or location.clongitude):
location_key = get_location_key(str(tid))
locations = [location, ]
locations = get_locations_with_clatlon(locations, self.db)
location = locations[0]
self.redis.setvalue(
location_key, location, EVENTER.LOCATION_EXPIRY)
if location and location['name'] is None:
location['name'] = ''
avatar_name, avatar_path, avatar_full_path, avatar_time = self.get_avatar_info(
mobile)
service_status = QueryHelper.get_service_status_by_tmobile(
self.db, mobile)
car_dct = {}
if location and location['type'] == 1: # cellid
location['locate_error'] = 500 # mile
car_info = dict(defend_status=terminal['defend_status'] if terminal['defend_status'] is not None else 1,
service_status=service_status,
mannual_status=terminal['mannual_status'] if terminal['mannual_status'] is not None else 1,
fob_status=terminal['fob_status'] if terminal['fob_status'] is not None else 0,
timestamp=location['timestamp'] if location else 0,
speed=location.speed if location else 0,
# NOTE: degree's type is Decimal, float() it before json_encode
degree=float(location.degree) if location else 0.00,
locate_error=location.get('locate_error', 20) if location else 20,
bt_name=terminal['bt_name'] if terminal.get('bt_name', None) is not None else '',
bt_mac=terminal['bt_mac'] if terminal.get('bt_mac', None) is not None else '',
dev_type=terminal['dev_type'] if terminal.get('dev_type', None) is not None else 'A',
name=location.name if location else '',
type=location.type if location else 1,
latitude=location['latitude'] if location else 0,
longitude=location['longitude'] if location else 0,
clatitude=location['clatitude'] if location else 0,
clongitude=location['clongitude'] if location else 0,
login=terminal['login'] if terminal['login'] is not None else 0,
gps=terminal['gps'] if terminal['gps'] is not None else 0,
gsm=terminal['gsm'] if terminal['gsm'] is not None else 0,
pbat=terminal['pbat'] if terminal['pbat'] is not None else 0,
mobile=terminal['mobile'],
owner_mobile=terminal['owner_mobile'],
alias=terminal['alias'],
#keys_num=terminal['keys_num'] if terminal['keys_num'] is not None else 0,
keys_num=0,
group_id=group_info['group_id'],
group_name=group_info['group_name'],
icon_type=terminal['icon_type'],
avatar_path=avatar_path,
avatar_time=avatar_time,
fob_list=terminal['fob_list'] if terminal['fob_list'] else [])
car_dct[tid] = car_info
cars_info.update(car_dct)
#push_info = NotifyHelper.get_push_info()
push_id = uid
push_key = NotifyHelper.get_push_key(push_id, self.redis)
lastinfo_time_key = get_lastinfo_time_key(uid)
lastinfo_time = self.redis.getvalue(lastinfo_time_key)
push = dict(id='',
key='')
t = int(time.time()) * 1000
push_key = get_push_key(uid, t)
json_data = WSPushHelper.register_wspush(uid, self.redis)
data = json_data['data']
if data:
id = data.get('push_id', '')
key = data.get('psd', '')
push['id'] = id
push['key'] = key
if version_type >= 1:
terminals = []
for k, v in cars_info.iteritems():
v.update({'tid': k})
terminals.append(v)
self.write_ret(status,
dict_=DotDict(wspush=push,
push_id=push_id,
push_key=push_key,
name=user_info.name if user_info else uid,
user_type=UWEB.USER_TYPE.PERSON,
lastinfo_time=lastinfo_time,
terminals=terminals))
else:
self.write_ret(status,
dict_=DotDict(wspush=push,
push_id=push_id,
# app_key=push_info.app_key,
push_key=push_key,
name=user_info.name if user_info else uid,
user_type=UWEB.USER_TYPE.PERSON,
cars_info=cars_info,
lastinfo_time=lastinfo_time,
cars=terminals,))
def post(self):
username = self.get_argument("username")
password = self.get_argument("password")
user_type = self.get_argument("user_type", UWEB.USER_TYPE.PERSON)
biz_type = self.get_argument("biz_type", UWEB.BIZ_TYPE.YDWS)
devid = self.get_argument("devid", "")
versionname = self.get_argument("versionname", "")
version_type = int(self.get_argument("version_type", 0))
logging.info("[UWEB] Android login request, username: %s, password: %s, user_type: %s, devid: %s",
username, password, user_type, devid)
# must check username and password avoid sql injection.
if not (username.isalnum() and password.isalnum()):
status = ErrorCode.ILLEGAL_LABEL
self.write_ret(status)
return
# check the user, return uid, tid, sim and status
cid, oid, uid, terminals, user_type, status = self.login_passwd_auth(username, password, user_type)
logging.info(
"[UWEB] Login auth, cid:%s, oid:%s, uid:%s, user_type:%s", cid, oid, uid, user_type)
if status == ErrorCode.SUCCESS:
# role: 0: person; 1: operator; 2: enterprise
# method 0: web; 1: android; 2: ios
# NOTE: keep the login log
login_info = dict(uid=uid,
role=0,
method=1,
versionname=versionname)
record_login_user(login_info, self.db)
self.bookkeep(dict(cid=cid,
oid=oid,
uid=uid,
tid=terminals[0].tid,
sim=terminals[0].sim))
user_info = QueryHelper.get_user_by_uid(uid, self.db)
# NOTE: add cars_info, it's same as lastinfo
cars_info = {}
if user_type == UWEB.USER_TYPE.PERSON:
terminals = QueryHelper.get_terminals_by_uid(uid, biz_type, self.db)
elif user_type == UWEB.USER_TYPE.OPERATOR:
terminals = QueryHelper.get_terminals_by_oid(oid, biz_type, self.db)
elif user_type == UWEB.USER_TYPE.CORP:
terminals = QueryHelper.get_terminals_by_cid(cid, biz_type, self.db)
else:
logging.error("[UWEB] Invalid user_type: %s", user_type)
for terminal in terminals:
# 1: get terminal
tid = terminal.tid
group_info = get_group_info_by_tid(self.db, tid)
terminal_info_key = get_terminal_info_key(tid)
terminal_cache = self.redis.getvalue(terminal_info_key)
if terminal_cache:
terminal['gps'] = terminal_cache['gps']
terminal['gsm'] = terminal_cache['gsm']
terminal['pbat'] = terminal_cache['pbat']
mobile = terminal['mobile']
terminal['keys_num'] = 0
if terminal['login'] == GATEWAY.TERMINAL_LOGIN.SLEEP:
terminal['login'] = GATEWAY.TERMINAL_LOGIN.ONLINE
# NOTE: if alias is null, provide cnum or sim instead
terminal['alias'] = QueryHelper.get_alias_by_tid(
tid, self.redis, self.db)
fobs = self.db.query("SELECT fobid FROM T_FOB"
" WHERE tid = %s", tid)
terminal['fob_list'] = [fob.fobid for fob in fobs]
terminal['sim'] = terminal['mobile']
# 2: get location
location = QueryHelper.get_location_info(tid, self.db, self.redis)
if location and not (location.clatitude or location.clongitude):
location_key = get_location_key(str(tid))
locations = [location, ]
locations = get_locations_with_clatlon(locations, self.db)
location = locations[0]
self.redis.setvalue(location_key, location, EVENTER.LOCATION_EXPIRY)
if location and location['name'] is None:
location['name'] = ''
avatar_name, avatar_path, avatar_full_path, avatar_time = self.get_avatar_info(mobile)
service_status = QueryHelper.get_service_status_by_tmobile(
self.db, mobile)
car_dct = {}
if location and location['type'] == 1: # cellid
location['locate_error'] = 500 # mile
car_info = dict(defend_status=terminal['defend_status'] if terminal['defend_status'] is not None else 1,
service_status=service_status,
mannual_status=terminal['mannual_status'] if terminal['mannual_status'] is not None else 1,
fob_status=terminal['fob_status'] if terminal['fob_status'] is not None else 0,
timestamp=location['timestamp'] if location else 0,
speed=location.speed if location else 0,
# NOTE: degree's type is Decimal, float() it before json_encode
degree=float(location.degree) if location else 0.00,
locate_error=location.get('locate_error', 20) if location else 20,
bt_name=terminal['bt_name'] if terminal.get('bt_name', None) is not None else '',
bt_mac=terminal['bt_mac'] if terminal.get('bt_mac', None) is not None else '',
dev_type=terminal['dev_type'] if terminal.get('dev_type', None) is not None else 'A',
name=location.name if location else '',
type=location.type if location else 1,
latitude=location['latitude'] if location else 0,
longitude=location['longitude'] if location else 0,
clatitude=location['clatitude'] if location else 0,
clongitude=location['clongitude'] if location else 0,
login=terminal['login'] if terminal['login'] is not None else 0,
gps=terminal['gps'] if terminal['gps'] is not None else 0,
gsm=terminal['gsm'] if terminal['gsm'] is not None else 0,
pbat=terminal['pbat'] if terminal['pbat'] is not None else 0,
mobile=terminal['mobile'],
owner_mobile=terminal['owner_mobile'],
alias=terminal['alias'],
#keys_num=terminal['keys_num'] if terminal['keys_num'] is not None else 0,
keys_num=0,
group_id=group_info['group_id'],
group_name=group_info['group_name'],
icon_type=terminal['icon_type'],
avatar_path=avatar_path,
avatar_time=avatar_time,
fob_list=terminal['fob_list'] if terminal['fob_list'] else [])
car_dct[tid] = car_info
cars_info.update(car_dct)
#push_info = NotifyHelper.get_push_info()
push_id = devid if devid else uid
push_key = NotifyHelper.get_push_key(push_id, self.redis)
lastinfo_time_key = get_lastinfo_time_key(uid)
lastinfo_time = self.redis.getvalue(lastinfo_time_key)
# uid --> android_push_list
# check push_id whether exists in a old android_push_list
old_android_push_list_key = self.redis.get(push_id)
if old_android_push_list_key:
old_android_push_list = self.redis.getvalue(
old_android_push_list_key)
if not isinstance(old_android_push_list, list):
self.redis.delete(old_android_push_list_key)
old_android_push_list = []
if old_android_push_list and (push_id in old_android_push_list):
logging.info("[UWEB] push_id:%s has existed in a old_android_push_list: %s, so remove push_id from the list.",
push_id, old_android_push_list)
old_android_push_list.remove(push_id)
self.redis.set(old_android_push_list_key, old_android_push_list)
android_push_list_key = get_android_push_list_key(uid)
android_push_list = self.redis.getvalue(android_push_list_key)
android_push_list = android_push_list if android_push_list else []
if push_id not in android_push_list:
android_push_list.append(push_id)
self.redis.set(android_push_list_key, android_push_list)
self.redis.set(push_id, android_push_list_key)
logging.info("[UWEB] uid: %s, android_push_lst: %s", username, android_push_list)
if user_info:
self.login_sms_remind(uid, user_info.mobile, terminals, login="******")
else:
pass # corp maybe no user_info
push = dict(id='',
key='')
json_data = WSPushHelper.register_wspush(uid, self.redis)
data = json_data['data']
if data:
id = data.get('push_id', '')
key = data.get('psd', '')
push['id'] = id
push['key'] = key
if version_type >= 1:
terminals = []
for k, v in cars_info.iteritems():
v.update({'tid': k})
terminals.append(v)
self.write_ret(status,
dict_=DotDict(wspush=push,
push_id=push_id,
push_key=push_key,
name=user_info.name if user_info else username,
user_type=user_type,
terminals=terminals,
lastinfo_time=lastinfo_time,))
else:
self.write_ret(status,
dict_=DotDict(wspush=push,
push_id=push_id,
# app_key=push_info.app_key,
push_key=push_key,
name=user_info.name if user_info else username,
user_type=user_type,
cars_info=cars_info,
lastinfo_time=lastinfo_time,
cars=terminals))
else:
logging.info("[UWEB] username: %s login failed, message: %s",
username, ErrorCode.ERROR_MESSAGE[status])
self.write_ret(status)
def update_terminal_db(self, data):
"""Update database.
"""
# NOTE: these fields should to be modified in db
terminal_keys = ['cellid_status', 'white_pop', 'trace', 'freq',
'vibchk', 'vibl', 'push_status', 'login_permit',
'alert_freq', 'stop_interval', 'biz_type', 'speed_limit']
terminal_fields = []
if data.has_key('tid'):
del data['tid']
for key, value in data.iteritems():
# NOTE: These fields should be modified in database.
if key in terminal_keys:
if data.get(key, None) is not None:
terminal_fields.append(key + ' = ' + str(value))
# NOT: These fields should be handled specially.
if key == 'white_list':
white_list = data[key]
if len(data['white_list']) < 1:
pass
else:
self.db.execute("DELETE FROM T_WHITELIST WHERE tid = %s",
self.current_user.tid)
for white in white_list[1:]:
self.db.execute("INSERT INTO T_WHITELIST"
" VALUES(NULL, %s, %s)"
" ON DUPLICATE KEY"
" UPDATE tid = VALUES(tid),"
" mobile = VALUES(mobile)",
self.current_user.tid, white)
elif key == 'alias':
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET alias = %s"
" WHERE tid = %s",
value, self.current_user.tid)
terminal_info_key = get_terminal_info_key(
self.current_user.tid)
terminal_info = self.redis.getvalue(terminal_info_key)
if terminal_info:
terminal_info[key] = value
self.redis.setvalue(terminal_info_key, terminal_info)
elif key == 'icon_type':
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET icon_type = %s"
" WHERE tid = %s",
value, self.current_user.tid)
terminal_info_key = get_terminal_info_key(
self.current_user.tid)
terminal_info = self.redis.getvalue(terminal_info_key)
if terminal_info:
terminal_info[key] = value
self.redis.setvalue(terminal_info_key, terminal_info)
elif key == 'corp_cnum':
self.db.execute("UPDATE T_CAR"
" SET cnum = %s"
" WHERE tid = %s",
safe_utf8(value), self.current_user.tid)
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET alias = %s"
" WHERE tid = %s",
safe_utf8(value), self.current_user.tid)
terminal_info_key = get_terminal_info_key(
self.current_user.tid)
terminal_info = self.redis.getvalue(terminal_info_key)
if terminal_info:
terminal_info[
'alias'] = value if value else self.current_user.sim
self.redis.setvalue(terminal_info_key, terminal_info)
elif key == 'owner_mobile' and value is not None:
umobile = value
user = dict(umobile=umobile,
password=u'111111')
add_user(user, self.db, self.redis)
t = QueryHelper.get_terminal_by_tid(self.current_user.tid, self.db)
old_uids = [t.owner_mobile]
# send sms
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET owner_mobile = %s"
" WHERE tid = %s",
umobile, self.current_user.tid)
register_sms = SMSCode.SMS_REGISTER % (
umobile, self.current_user.sim)
SMSHelper.send_to_terminal(self.current_user.sim, register_sms)
# update redis
terminal_info_key = get_terminal_info_key(
self.current_user.tid)
terminal_info = self.redis.getvalue(terminal_info_key)
if terminal_info:
terminal_info[key] = umobile
self.redis.setvalue(terminal_info_key, terminal_info)
# wspush to client
WSPushHelper.pushS3(self.current_user.tid, self.db, self.redis)
WSPushHelper.pushS3_dummy(old_uids, self.db, self.redis)
elif key == "alert_freq":
alert_freq_key = get_alert_freq_key(self.current_user.tid)
if self.redis.exists(alert_freq_key):
logging.info(
"[UWEB] Termianl %s delete alert freq in redis.", self.current_user.tid)
self.redis.delete(alert_freq_key)
# if vibl has been changed,then update use_scene as well
elif key == "vibl":
use_scene = get_use_scene_by_vibl(value)
self.db.execute("UPDATE T_TERMINAL_INFO SET use_scene=%s WHERE tid=%s",
use_scene, self.current_user.tid)
logging.info("[UWEB] Terminal %s update use_scene %s and vibl %s",
self.current_user.tid, use_scene, value)
logging.info(
"[UWEB] Termianl %s delete session in redis.", self.current_user.tid)
# NOTE: deprecated.
elif key == "parking_defend" and value is not None:
if value == 1:
mannual_status = UWEB.DEFEND_STATUS.SMART
else:
mannual_status = UWEB.DEFEND_STATUS.YES
update_mannual_status(
self.db, self.redis, self.current_user.tid, mannual_status)
elif key == 'login_permit':
# wspush to client
WSPushHelper.pushS3(self.current_user.tid, self.db, self.redis)
else:
pass
# NOTE:update database.
terminal_clause = ','.join(terminal_fields)
if terminal_clause:
self.db.execute("UPDATE T_TERMINAL_INFO"
" SET " + terminal_clause +
" WHERE tid = %s ",
self.current_user.tid)
# NOTE: clear sessionID if freq, stop_interval, vibl can be found.
if data.has_key('freq') or data.has_key('stop_interval') or data.has_key('vibl'):
clear_sessionID(self.redis, self.current_user.tid)
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 post(self):
"""Get event info.
"""
status = WXErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
logging.info("[WEIXIN] event request body: %s", self.request.body)
tid = data.tid
openid = data.get('openid')
start_time = data.start_time
end_time = data.end_time
except Exception as e:
status = WXErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[WEIXIN] Invalid data format. Exception: %s",
e.args)
self.render('error.html',
status=status,
message=WXErrorCode.ERROR_MESSAGE[status])
return
try:
checksql = "SELECT uid FROM T_USER WHERE openid = '%s'" % openid
user = self.db.query(checksql)
if not user:
status = WXErrorCode.USER_BIND
message = WXErrorCode.ERROR_MESSAGE[status]
self.render('error.html',
status=status,
message=message)
return
sql = ("SELECT tid, latitude, longitude, clatitude, clongitude,"
" timestamp, name, type, speed, degree,"
" category, pbat, terminal_type, fobid, rid, locate_error"
" FROM V_EVENT"
" WHERE tid ='%s'"
" AND (timestamp BETWEEN %s AND %s)"
" ORDER BY timestamp DESC") %\
(tid, start_time, end_time)
#sql = ("SELECT tid, latitude, longitude, clatitude, clongitude,"
# " timestamp, name, type, speed, degree,"
# " category, pbat, terminal_type, fobid, rid, locate_error"
# " FROM V_EVENT"
# " where timestamp BETWEEN %s AND %s"
# " ORDER BY timestamp DESC limit 21 ") %\
# (start_time, end_time)
events = self.db.query(sql)
alias_dict = {}
terminal_info_key = get_terminal_info_key(tid)
terminal_info = self.redis.getvalue(terminal_info_key)
alias_dict[tid] = terminal_info['alias'] if terminal_info['alias'] else terminal_info['mobile']
# change the type form decimal to float.
for event in events:
event['alias'] = '' # alias_dict[event['tid']]
event['pbat'] = event['pbat'] if event['pbat'] is not None else 0
event['fobid'] = event['fobid'] if event['fobid'] is not None else u''
event['name'] = event['name'] if event['name'] is not None else u''
event['degree'] = float(event['degree'])
event['speed'] = float(event['speed'])
event['comment'] = ''
if event['category'] == EVENTER.CATEGORY.POWERLOW:
if event['terminal_type'] == '1':
if int(event['pbat']) == 100:
event['comment'] = ErrorCode.ERROR_MESSAGE[ErrorCode.TRACKER_POWER_FULL]
elif int(event['pbat']) <= 5:
event['comment'] = ErrorCode.ERROR_MESSAGE[ErrorCode.TRACKER_POWER_OFF]
else:
event['comment'] = (ErrorCode.ERROR_MESSAGE[ErrorCode.TRACKER_POWER_LOW]) % event['pbat']
else:
event['comment'] = ErrorCode.ERROR_MESSAGE[ErrorCode.FOB_POWER_LOW] % event['fobid']
if event['category'] in [EVENTER.CATEGORY.REGION_ENTER, EVENTER.CATEGORY.REGION_OUT]:
region = self.db.get("SELECT name AS region_name"
" FROM T_REGION"
" WHERE id = %s",
event.rid)
region_name = safe_unicode(region.region_name) if region else u''
event['comment'] = u'围栏名：'+ region_name
r = events * 2 + events[0:6]
self.write_ret(status,
dict_=DotDict(res=r))
print "jjjjjj res:",r
except Exception as e:
logging.exception("[WEIXIN] search event failed POST(), Execption:%s",
e.args)
status=WXErrorCode.FAILED
message=WXErrorCode.ERROR_MESSAGE[status]
self.render('error.html',
status=status,
message=message)
