def post(self):
"""Turn on buletooth."""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
tid = data.get('tid', None)
tids = data.get('tids', None)
self.check_tid(tid)
logging.info("[BLUETOOTH] kqly request: %s, uid: %s, tids: %s",
data, self.current_user.uid, 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:
tids = str_to_list(tids)
tids = tids if tids else [self.current_user.tid, ]
tids = [str(t) for t in tids]
kqly(self.db, self.redis, tids)
self.write_ret(status)
except Exception as e:
logging.exception("[BLUETOOTH] Kqly 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 wrapper(self, *args, **kwargs):
province_ids = map(int, str_to_list(self.get_argument('province_id', '')))
city_ids = map(int, str_to_list(self.get_argument('city_id', '')))
group_ids = map(int, str_to_list(self.get_argument('group', '')))
is_permitted = _internal_check(self.current_user.id,
province_ids,
city_ids,
group_ids,
self.db)
if is_permitted:
return method(self, *args, **kwargs)
else:
self.render(error_page,
error=True,
message=ErrorCode.PERMISSION_DENIED)
def delete(self):
"""Delete a line.
"""
try:
delete_ids = map(int, str_to_list(self.get_argument('ids', None)))
logging.info("[UWEB] delete line: %s, cid: %s",
delete_ids, self.current_user.cid)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
return
try:
status = ErrorCode.SUCCESS
self.db.execute("DELETE FROM T_LINE_PASSENGER WHERE line_id IN %s",
tuple(delete_ids + DUMMY_IDS))
self.db.execute("DELETE FROM T_LINE WHERE id IN %s",
tuple(delete_ids + DUMMY_IDS))
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] cid: %s delete line failed. Exception: %s",
self.current_user.cid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def post(self):
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
tid = data.get('tid', None)
tids = data.get('tids', None)
# check tid whether exist in request and update current_user
self.check_tid(tid)
logging.info("[UWEB] Defend 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:
res = []
tids = str_to_list(tids)
tids = tids if tids else [self.current_user.tid, ]
tids = [str(tid) for tid in tids]
for tid in tids:
r = DotDict(tid=tid,
status=ErrorCode.SUCCESS)
try:
terminal = QueryHelper.get_available_terminal(tid, self.db)
if not terminal:
r.status = ErrorCode.LOGIN_AGAIN
res.append(r)
logging.error("[UWEB] The terminal with tid: %s does not exist, redirect to login.html",
tid)
continue
update_mannual_status(self.db, self.redis, tid, data.mannual_status)
logging.info("[UWEB] uid:%s, tid:%s set mannual status to %s successfully",
self.current_user.uid, tid, data.mannual_status)
except Exception as e:
r.status = ErrorCode.FAILED
logging.exception("[UWEB] uid:%s, tid:%s set mannual status to %s failed. Exception: %s",
self.current_user.uid, tid,
data.mannual_status, e.args)
finally:
res.append(r)
# NOTE: wspush
if status == ErrorCode.SUCCESS:
for tid in tids:
WSPushHelper.pushS7(tid, self.db, self.redis)
self.write_ret(status, dict_=DotDict(res=res))
except Exception as e:
logging.exception("[UWEB] uid:%s, tid:%s set mannual status to %s failed. Exception: %s",
self.current_user.uid, self.current_user.tid, data.mannual_status, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def delete(self):
"""Delete region.
"""
try:
delete_ids = map(int, str_to_list(self.get_argument('ids', None)))
logging.info("[UWEB] delete region: %s, cid: %s",
delete_ids, self.current_user.cid)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
try:
status = ErrorCode.SUCCESS
delete_region(delete_ids, self.db, self.redis)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] cid: %s delete region failed. Exception: %s",
self.current_user.cid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def delete(self):
"""Delete activity.
"""
try:
delete_ids = map(int, str_to_list(self.get_argument("ids", None)))
logging.info("[ADMIN] delete apk: %s", delete_ids)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[ADMIN] data format illegal. Exception: %s", e.args)
self.write_ret(status)
return
try:
status = ErrorCode.SUCCESS
self.db.execute("DELETE FROM T_APK WHERE id IN %s", tuple(delete_ids + DUMMY_IDS))
self.write_ret(status)
except Exception as e:
status = ErrorCode.SERVER_BUSY
logging.exception("[ADMIN] delete apk failed. Exception: %s", e.args)
self.write_ret(status)
def delete(self):
"""Delete single.
"""
status = ErrorCode.SUCCESS
try:
delete_ids = map(int, str_to_list(self.get_argument("single_ids", None)))
logging.info("[UWEB] Delete single: %s, cid: %s", delete_ids, self.current_user.cid)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[UWEB] Invalid data format. Exception: %s", e.args)
self.write_ret(status)
return
try:
delete_single(delete_ids, self.db, self.redis)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] Delete single failed. cid: %s, Exception: %s", self.current_user.cid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def delete(self):
status = ErrorCode.SUCCESS
try:
delete_ids = map(int, str_to_list(self.get_argument('ids', None)))
except Exception as e:
logging.info("[LOG] Feedback illegal data format. Exception: %s",
e.args)
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
try:
self.acbdb.execute("DELETE FROM T_FEEDBACK"
" WHERE id IN %s",
tuple(delete_ids + DUMMY_IDS))
self.write_ret(status)
except Exception as e:
logging.exception("[LOG] Feedback query failed. Exception: %s",
e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def delete(self):
"""Delete a group.
"""
try:
status = ErrorCode.SUCCESS
delete_ids = map(int, str_to_list(self.get_argument("ids", None)))
for delete_id in delete_ids:
terminals = self.db.query(
"SELECT * FROM T_TERMINAL_INFO"
" WHERE group_id = %s"
" AND (service_status = %s "
" OR service_status = %s)",
delete_id,
UWEB.SERVICE_STATUS.ON,
UWEB.SERVICE_STATUS.TO_BE_ACTIVATED,
)
if not terminals:
logging.info(
"[UWEB] group delete request: %s, uid: %s, tid: %s",
delete_ids,
self.current_user.uid,
self.current_user.tid,
)
self.db.execute("DELETE FROM T_GROUP WHERE id = %s", delete_id)
else:
status = ErrorCode.GROUP_HAS_TERMINAL
# NOTE: wspush to client
tid = self.current_user.tid
if status == ErrorCode.SUCCESS:
WSPushHelper.pushS3(tid, self.db, self.redis)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] Delete group failed. cid: %s, Exception: %s", self.current_user.cid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def delete(self):
"""Delete announcement.
"""
status = ErrorCode.SUCCESS
try:
delete_ids = map(int, str_to_list(self.get_argument('ids', None)))
logging.info("[UWEB] Delete announcement: %s",
delete_ids)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception(
"[UWEB] data format illegal. Exception: %s", e.args)
self.write_ret(status)
return
try:
self.db.execute("DELETE FROM T_ANNOUNCEMENT_LOG WHERE id IN %s",
tuple(delete_ids + DUMMY_IDS))
self.write_ret(status)
except Exception as e:
status = ErrorCode.SERVER_BUSY
logging.exception("[UWEB] Delete announcement failed. Exception: %s",
e.args)
self.write_ret(status)
def post(self):
"""Provide some statistics about terminals.
"""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
page_size = UWEB.LIMIT.PAGE_SIZE
page_number = int(data.pagenum)
start_time = data.start_time
end_time = data.end_time
query_type = data.query_type
tids = str_to_list(data.tids)
logging.info("[UWEB] mileage request: %s, cid: %s, oid: %s",
data, self.current_user.cid, self.current_user.oid)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[UWEB] Invalid data format. Exception: %s",
e.args)
self.write_ret(status)
self.finish()
return
# NOTE: prepare
try:
# the interval between start_time and end_time is one week
# no checks for enterprise
if self.current_user.cid != UWEB.DUMMY_CID:
pass
elif (int(end_time) - int(start_time)) > UWEB.QUERY_INTERVAL:
self.write_ret(ErrorCode.QUERY_INTERVAL_EXCESS)
self.finish()
return
statistic_mode = 'single'
if not tids: # all terminals
statistic_mode = 'all'
if self.current_user.oid == UWEB.DUMMY_OID: # enterprise
terminals = QueryHelper.get_all_terminals_by_cid(
self.current_user.cid, self.db)
else: # operator
terminals = QueryHelper.get_all_terminals_by_oid(
self.current_user.oid, self.db)
tids = [terminal.tid for terminal in terminals]
except Exception as e:
logging.exception("[UWEB] cid:%s, oid:%s get mileage report failed. Exception: %s",
self.current_user.cid, self.current_user.oid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
self.finish()
return
def _on_finish(db):
self.db = db
page_count = int(data.pagecnt)
if statistic_mode == 'all': # all
if page_count == -1:
count = len(tids)
d, m = divmod(count, page_size)
page_count = (d + 1) if m else d
reports = []
dis_count = Decimal()
for item, tid in enumerate(tids):
seq = item + 1
# NOTE: It's amazing: In database, distance's type is long. sum(distance)'s type is Decimal
mileage_log = self.db.get("SELECT SUM(distance) AS distance"
" FROM T_MILEAGE_LOG"
" WHERE tid = %s"
" AND (timestamp BETWEEN %s AND %s)",
tid, start_time,
end_time + 60 * 60 * 24)
if mileage_log and mileage_log['distance']:
dis_sum = '%0.1f' % (mileage_log['distance'] / 1000,)
else:
dis_sum = 0
alias = QueryHelper.get_alias_by_tid(
tid, self.redis, self.db)
dct = dict(seq=seq,
alias=alias,
distance=float(dis_sum))
reports.append(dct)
dis_count += Decimal(dis_sum)
counts = [float(dis_count), ]
# orgnize and store the data to be downloaded
m = hashlib.md5()
m.update(self.request.body)
hash_ = m.hexdigest()
mem_key = self.KEY_TEMPLATE % (self.current_user.uid, hash_)
self.redis.setvalue(
mem_key, (statistic_mode, reports, counts), time=UWEB.STATISTIC_INTERVAL)
reports = reports[
(page_number * page_size):((page_number + 1) * page_size)]
self.write_ret(status,
dict_=DotDict(res=reports,
pagecnt=page_count,
hash_=hash_))
else: # single
tid = tids[0]
# end_time must be bigger than start_time
delta = end_time - start_time
d, m = divmod(delta, 60 * 60 * 24)
start_date = get_date_from_utc(start_time)
end_date = get_date_from_utc(end_time)
start_day = datetime.datetime.fromtimestamp(start_time)
end_day = datetime.datetime.fromtimestamp(end_time)
# get how many days the end_time and start_time cover
days = abs(end_day - start_day).days + 1
res = []
graphics = []
counts = []
dis_sum = Decimal()
current_time = int(time.time())
for item in range(days):
timestamp = start_time + 1 * 60 * 60 * 24 * (item)
date = get_date_from_utc(timestamp)
year, month, day = date.year, date.month, date.day
start_time_, end_time_ = start_end_of_day(
year=year, month=month, day=day)
re = {}
re['alias'] = '-'.join([str(year), str(month), str(day)])
mileage_log = self.db.get("SELECT distance FROM T_MILEAGE_LOG"
" WHERE tid = %s"
" AND timestamp = %s",
tid, end_time_)
distance = mileage_log['distance'] if mileage_log else 0
# meter --> km
distance = '%0.1f' % (Decimal(distance) / 1000,)
if float(distance) == 0:
distance = 0
graphics.append(float(distance))
dis_sum += Decimal(distance)
re['distance'] = distance
re['seq'] = item + 1
res.append(re)
counts = [float(dis_sum), ]
if page_count == -1:
items_count = len(res)
d, m = divmod(items_count, page_size)
page_count = (d + 1) if m else d
# store resutl in redis
m = hashlib.md5()
m.update(self.request.body)
hash_ = m.hexdigest()
mem_key = self.KEY_TEMPLATE % (self.current_user.uid, hash_)
self.redis.setvalue(
mem_key, (statistic_mode, res, counts,), time=UWEB.STATISTIC_INTERVAL)
res = res[
page_number * page_size:(page_number + 1) * page_size]
self.write_ret(status,
dict_=dict(res=res,
counts=counts,
graphics=graphics,
pagecnt=page_count,
hash_=hash_))
self.finish()
self.queue.put((10, _on_finish))
def post(self):
"""Turn on tracing."""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
tid = data.get('tid', None)
tids = data.get('tids', None)
flag = int(data.get('flag', 1))
# check tid whether exist in request and update current_user
self.check_tid(tid)
logging.info("[UWEB] track LQ request: %s, "
" uid: %s, tid: %s, tids: %s, flag: %s",
data, self.current_user.uid, tid, tids, flag)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
self.write_ret(status)
return
try:
tids = str_to_list(tids)
tids = tids if tids else [self.current_user.tid, ]
tids = [str(tid) for tid in tids]
if int(flag) == 1:
for tid in tids:
# NOTE: just send lqgz temporary
terminal = QueryHelper.get_terminal_by_tid(tid, self.db)
lqgz_key = get_lqgz_key(tid)
lqgz_value = self.redis.getvalue(lqgz_key)
lqgz_interval_key = get_lqgz_interval_key(tid)
if not lqgz_value:
interval = 30 # in minute
biz_type = QueryHelper.get_biz_type_by_tmobile(
terminal.mobile, self.db)
if biz_type != UWEB.BIZ_TYPE.YDWS:
self.write_ret(status)
return
sms = SMSCode.SMS_LQGZ % interval
SMSHelper.send_to_terminal(terminal.mobile, sms)
self.redis.setvalue(
lqgz_key, True, SMS.LQGZ_SMS_INTERVAL)
self.redis.setvalue(
lqgz_interval_key, True, SMS.LQGZ_INTERVAL * 2)
# END
track_key = get_track_key(tid)
track = self.redis.get(track_key)
logging.info("[UWEB] Get track: %s from redis", track)
if track and int(track) == 1:
# turn on track already
logging.info(
"[UWEB] Terminal: %s turn on track already.", tid)
else:
self.db.execute("UPDATE T_TERMINAL_INFO SET track = %s"
" WHERE tid = %s",
flag, tid)
self.redis.setvalue(track_key, 1, UWEB.TRACK_INTERVAL)
sessionID_key = get_terminal_sessionID_key(tid)
self.redis.delete(sessionID_key)
self.write_ret(status)
except Exception as e:
logging.exception("[UWEB] uid: %s, tid: %s send lqgz failed. Exception: %s. ",
self.current_user.uid, self.current_user.tid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
def post(self):
""" Provide some statistics about terminals.
"""
status = ErrorCode.SUCCESS
#NOTE: check data format
try:
data = DotDict(json_decode(self.request.body))
page_size = UWEB.LIMIT.PAGE_SIZE
page_number = int(data.pagenum)
start_time= data.start_time
end_time = data.end_time
query_type = data.query_type
if query_type == UWEB.QUERY_TYPE.JUNIOR: # 0
start_period_ = 0
end_period_ = 0
else:
start_period= data.start_period
end_period = data.end_period
start_period_ = int(start_period[:2])*60*60 + int(start_period[2:])*60
end_period_ = int(end_period[:2])*60*60 + int(end_period[2:])*60
tids = str_to_list(data.tids)
logging.info("[UWEB] mileage request: %s, cid: %s, oid: %s",
data, self.current_user.cid, self.current_user.oid)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[UWEB] Invalid data format. Exception: %s",
e.args)
self.write_ret(status)
self.finish()
return
#NOTE: prepare
try:
# the interval between start_time and end_time is one week
if self.current_user.cid != UWEB.DUMMY_CID: # no checks for enterprise
pass
elif (int(end_time) - int(start_time)) > UWEB.QUERY_INTERVAL:
self.write_ret(ErrorCode.QUERY_INTERVAL_EXCESS)
self.finish()
return
statistic_mode = 'single'
if not tids: # all terminals
statistic_mode = 'all'
terminals = QueryHelper.get_terminals_by_cid(self.current_user.cid, self.db)
tids = [terminal.tid for terminal in terminals]
except Exception as e:
logging.exception("[UWEB] cid:%s, oid:%s get mileage report failed. Exception: %s",
self.current_user.cid, self.current_user.oid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
self.finish()
return
def _on_finish(db):
self.db = db
page_count = int(data.pagecnt)
if statistic_mode == 'all': # all
if page_count == -1:
count = len(tids)
d, m = divmod(count, page_size)
page_count = (d + 1) if m else d
reports = []
for item, tid in enumerate(tids):
seq=item+1
dis_sum = Decimal()
start_date = get_date_from_utc(start_time)
end_date = get_date_from_utc(end_time)
start_day = datetime.datetime.fromtimestamp(start_time)
end_day = datetime.datetime.fromtimestamp(end_time)
# get how many days the end_time and start_time cover
days = abs(end_day-start_day).days+1
for item in range(days):
distance = Decimal()
timestamp = start_time+1*60*60*24*(item)
date = get_date_from_utc(timestamp)
year, month, day = date.year, date.month, date.day
start_time_, end_time_ = start_end_of_day(year=year, month=month, day=day)
points = self.db.query("SELECT longitude, latitude FROM T_LOCATION"
" WHERE tid = %s"
" AND (timestamp BETWEEN %s AND %s)"
" AND type = 0"
" ORDER BY timestamp asc",
tid, start_time_+start_period_, start_time_+end_period_)
for i in range(len(points)-1):
if points[i].longitude and points[i].latitude and \
points[i+1].longitude and points[i+1].latitude:
dis = get_distance(points[i].longitude, points[i].latitude,
points[i+1].longitude, points[i+1].latitude)
distance += Decimal(str(dis))
# meter --> km
distance = '%0.1f' % (distance/1000,)
dis_sum += Decimal(distance)
alias = QueryHelper.get_alias_by_tid(tid, self.redis, self.db)
dct = dict(seq=seq,
alias=alias,
distance=float(dis_sum))
reports.append(dct)
# orgnize and store the data to be downloaded
m = hashlib.md5()
m.update(self.request.body)
hash_ = m.hexdigest()
mem_key = self.KEY_TEMPLATE % (self.current_user.uid, hash_)
self.redis.setvalue(mem_key, (statistic_mode, reports, 0), time=UWEB.STATISTIC_INTERVAL)
reports= reports[(page_number * page_size):((page_number+1) * page_size)]
self.write_ret(status,
dict_=DotDict(res=reports,
pagecnt=page_count,
hash_=hash_))
else: # single
tid = tids[0]
delta = end_time - start_time # end_time must bigger than start_time
d, m = divmod(delta, 60*60*24)
start_date = get_date_from_utc(start_time)
end_date = get_date_from_utc(end_time)
start_day = datetime.datetime.fromtimestamp(start_time)
end_day = datetime.datetime.fromtimestamp(end_time)
# get how many days the end_time and start_time cover
days = abs(end_day-start_day).days+1
#if days == 0:
# if start_date.day == end_date.day:
# days = 1
# else:
# days = 2
#else:
# days = days+1 if m else days
# if end_day.hour*60*60 + end_day.minute*60 + end_day.second < start_day.hour*60*60 + start_day.minute*60 + start_day.second:
# days = days+1
res = []
graphics = []
counts = []
dis_sum = Decimal()
current_time = int(time.time())
sql_cmd = ("SELECT longitude, latitude FROM T_LOCATION"
" WHERE tid = %s"
" AND (timestamp BETWEEN %s AND %s)"
" AND type = 0"
" ORDER BY timestamp asc")
#last_cmd = ("SELECT timestamp FROM T_LOCATION"
# " WHERE tid = %s"
# " AND (timestamp BETWEEN %s AND %s)"
# " AND type = 0"
# " ORDER BY timestamp desc limit 1")
#next_cmd = ("SELECT timestamp FROM T_LOCATION"
# " WHERE tid = %s"
# " AND (timestamp BETWEEN %s AND %s)"
# " AND type = 0"
# " ORDER BY timestamp asc limit 1")
if days == 1: # start_time, end_time in the same day
timestamp = start_time
date = get_date_from_utc(timestamp)
re = {}
re['alias'] = '-'.join([str(date.year),str(date.month),str(date.day)])
distance = Decimal()
points = self.db.query(sql_cmd, tid, start_time+start_period_, start_time+end_period_)
for i in range(len(points)-1):
if points[i].longitude and points[i].latitude and \
points[i+1].longitude and points[i+1].latitude:
dis = get_distance(points[i].longitude, points[i].latitude,
points[i+1].longitude, points[i+1].latitude)
distance += Decimal(str(dis))
# meter --> km
distance = '%0.1f' % (distance/1000,)
graphics.append(float(distance))
dis_sum += Decimal(distance)
re['distance'] = distance
re['seq'] = 1
res.append(re)
else: # start_time, end_time in different days
for item in range(days):
timestamp = start_time+1*60*60*24*(item)
date = get_date_from_utc(timestamp)
year, month, day = date.year, date.month, date.day
start_time_, end_time_ = start_end_of_day(year=year, month=month, day=day)
## handle the first day and last day
#if item == 0:
# start_time_ = start_time
#if item == days:
# end_time_ = end_time
#last_point = self.db.get(last_cmd, tid, start_time_-60*60*24, start_time_,)
#next_point = self.db.get(next_cmd, tid, end_time_, end_time_+60*60*24)
#start_time_ = last_point['timestamp'] if last_point else start_time_
#end_time_ = next_point['timestamp'] if next_point else end_time_
re = {}
re['alias'] = '-'.join([str(year),str(month),str(day)])
distance = Decimal()
points = self.db.query(sql_cmd, tid, start_time_+start_period_, start_time_+end_period_)
for i in range(len(points)-1):
if points[i].longitude and points[i].latitude and \
points[i+1].longitude and points[i+1].latitude:
dis = get_distance(points[i].longitude, points[i].latitude,
points[i+1].longitude, points[i+1].latitude)
distance += Decimal(str(dis))
# meter --> km
distance = '%0.1f' % (distance/1000,)
graphics.append(float(distance))
dis_sum += Decimal(distance)
re['distance'] = distance
re['seq'] = item+1
res.append(re)
counts = [float(dis_sum),]
if page_count == -1:
items_count = len(res)
d, m = divmod(items_count, page_size)
page_count = (d + 1) if m else d
# store resutl in redis
m = hashlib.md5()
m.update(self.request.body)
hash_ = m.hexdigest()
mem_key = self.KEY_TEMPLATE % (self.current_user.uid, hash_)
self.redis.setvalue(mem_key, (statistic_mode, res, counts,), time=UWEB.STATISTIC_INTERVAL)
res= res[page_number*page_size:(page_number+1)*page_size]
self.write_ret(status,
dict_=dict(res=res,
counts=counts,
graphics=graphics,
pagecnt=page_count,
hash_=hash_))
self.finish()
self.queue.put((10, _on_finish))
def post(self):
"""Retrive various attendance.
"""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
mobile = data.get('mobile', None)
mobiles = str_to_list(mobile)
if not mobiles:
terminals = self.db.query("SELECT tmobile FROM V_TERMINAL"
" where cid = %s",
self.current_user.cid)
mobiles = [str(terminal['tmobile']) for terminal in terminals]
logging.info("[UWEB] attendance request: %s, cid: %s",
data, self.current_user.cid)
except Exception as e:
status = ErrorCode.ILLEGAL_DATA_FORMAT
logging.exception("[UWEB] Invalid data format. Exception: %s",
e.args)
self.write_ret(status)
return
try:
page_size = int(data.get('pagesize', UWEB.LIMIT.PAGE_SIZE))
page_number = int(data.pagenum)
page_count = int(data.pagecnt)
start_time = data.start_time
end_time = data.end_time
# we need return the event count to GUI at first time query
if page_count == -1:
sql = ("SELECT COUNT(*) as count FROM V_ATTENDANCE"
" WHERE mobile IN %s "
" AND (timestamp BETWEEN %s AND %s)")
sql = sql % (tuple(mobiles + DUMMY_IDS_STR), 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 mobile as tid, mobile, clatitude, clongitude,"
" timestamp, name, type, speed, degree,"
" locate_error"
" FROM V_ATTENDANCE"
" WHERE mobile IN %s"
" AND (timestamp BETWEEN %s AND %s)"
" ORDER BY timestamp DESC"
" LIMIT %s, %s")
sql = sql % (tuple(mobiles + DUMMY_IDS_STR), start_time, end_time, page_number * page_size, page_size)
res = self.db.query(sql)
# change the type form decimal to float.
for r in res:
r['alias'] = QueryHelper.get_alias_by_tid(r['tid'], self.redis, self.db)
r['name'] = r['name'] if r['name'] is not None else u''
r['degree'] = float(r['degree'])
r['speed'] = float(r['speed'])
r['comment'] = ''
self.write_ret(status,
dict_=DotDict(res=res,
pagecnt=page_count))
except Exception as e:
status = ErrorCode.SERVER_BUSY
logging.exception("[UWEB] cid:%s get attendance info failed. Exception: %s",
self.current_user.cid, e.args)
self.write_ret(status)
def post(self):
"""Create a administrator.
"""
# create
fields = DotDict(corporation="",
name="",
login="",
password="",
mobile="",
phone="",
email="",
valid="",
source_id="")
list_inject = ['name', 'password', 'mobile', 'phone']
for key in list_inject:
v = self.get_argument(key, '')
# if not check_sql_injection(v):
# self.get()
# return
for key in fields.iterkeys():
fields[key] = self.get_argument(key, '')
fields.source_id = fields.source_id if fields.source_id else 5
administrator_id = self.db.execute("INSERT INTO T_ADMINISTRATOR (login, password, "
" name, mobile, phone, email, "
" corporation, source_id, valid, type)"
" VALUES (%s, password(%s), %s, %s, "
" %s, %s, %s, %s, %s, %s)",
fields.login, fields.password,
fields.name, fields.mobile,
fields.phone, fields.email,
fields.corporation,
fields.source_id, fields.valid, 2)
# insert privilege
privileges = map(int, self.get_arguments('privileges'))
if privileges:
self.db.executemany("INSERT INTO T_PRIVILEGE"
" VALUES (%s, %s)",
[(administrator_id, id)
for id in privileges])
cities = map(int, str_to_list(self.get_argument('cities', '')))
key = self.get_area_memcache_key(administrator_id)
if len(cities) == 1 and cities[0] == 0:
self.db.execute("INSERT INTO T_AREA_PRIVILEGE"
" VALUES(NULL, %s, %s, %s)",
administrator_id, AREA.CATEGORY.PROVINCE,
AREA.PROVINCE.LIAONING)
cities = self.db.query("SELECT city_id, city_name FROM T_HLR_CITY"
" WHERE province_id = %s",
AREA.PROVINCE.LIAONING)
self.redis.setvalue(key, cities)
else:
# put privilege_areas into memcached
areas = self.get_area(cities)
self.redis.setvalue(key, areas)
cities = self.db.query("SELECT region_code FROM T_HLR_CITY"
" WHERE city_id IN %s",
tuple(cities + DUMMY_IDS))
cids = [c.region_code for c in cities]
for cid in cids:
self.db.execute("INSERT INTO T_AREA_PRIVILEGE"
" VALUES (NULL, %s, %s, %s)",
administrator_id, AREA.CATEGORY.CITY, cid)
self.redirect("/administrator/list/%s" % administrator_id)
def post(self, administrator_id):
"""Edit the administrator.
"""
is_self = (administrator_id == self.current_user.id)
# update basic info
fields = DotDict(corporation="corporation = %s",
name="name = %s",
mobile="mobile = %s",
phone="phone = %s",
email="email = %s",
valid="valid = %s",
source_id="source_id = %s"
)
list_inject = ['corporation', 'name', 'mobile', 'phone']
for key in list_inject:
v = self.get_argument(key, '')
# if not check_sql_injection(v):
# self.get(administrator_id)
# return
if is_self:
del fields['valid']
del fields['source_id']
self.bookkeep(dict(id=self.current_user.id,
session_id=self.current_user.session_id),
quote(safe_utf8(self.get_argument('name', u""))))
data = [self.get_argument(key, '')
for key in fields.iterkeys()] + [administrator_id]
set_clause = ','.join([v for v in fields.itervalues()])
self.db.execute("UPDATE T_ADMINISTRATOR"
" SET " + set_clause +
" WHERE id = %s",
*data)
if not is_self:
# update privilege
privileges = map(int, self.get_arguments('privileges'))
if privileges:
rs = self.db.query("SELECT privilege_group_id FROM T_PRIVILEGE"
" WHERE administrator_id = %s",
administrator_id)
ids = [r.privilege_group_id for r in rs]
new_ids = list(set(privileges) - set(ids))
old_ids = list(set(ids) - set(privileges))
# clean up old ids
self.db.execute("DELETE FROM T_PRIVILEGE"
" WHERE administrator_id = %s"
" AND privilege_group_id in %s",
administrator_id, tuple(old_ids + DUMMY_IDS))
# insert new ids
self.db.executemany("INSERT INTO T_PRIVILEGE"
" VALUES (%s, %s)",
[(administrator_id, priv)
for priv in new_ids])
key = self.get_area_memcache_key(administrator_id)
cities = [int(i)
for i in str_to_list(self.get_argument('cities', ''))]
if len(cities) == 1 and int(cities[0]) == 0:
self.db.execute("DELETE FROM T_AREA_PRIVILEGE"
" WHERE administrator_id = %s",
administrator_id)
self.db.execute("INSERT INTO T_AREA_PRIVILEGE"
" VALUES(NULL, %s, %s, %s)",
administrator_id, AREA.CATEGORY.PROVINCE,
AREA.PROVINCE.LIAONING)
cities = self.db.query("SELECT city_id, city_name FROM T_HLR_CITY"
" WHERE province_id = %s",
AREA.PROVINCE.LIAONING)
self.redis.setvalue(key, cities)
else:
if cities:
areas = self.get_area(cities)
self.redis.setvalue(key, areas)
cities = self.db.query("SELECT region_code FROM T_HLR_CITY"
" WHERE city_id IN %s",
tuple(cities + DUMMY_IDS))
cids = [c.region_code for c in cities]
rs = self.db.query("SELECT area_id FROM T_AREA_PRIVILEGE"
" WHERE category = %s"
" AND administrator_id = %s",
AREA.CATEGORY.CITY, administrator_id)
ids = [r.area_id for r in rs]
new_ids = list(set(cids) - set(ids))
old_ids = list(set(ids) - set(cids))
# clean up old ids
self.db.execute("DELETE FROM T_AREA_PRIVILEGE"
" WHERE administrator_id = %s"
" AND category = %s"
" AND area_id in %s",
administrator_id, AREA.CATEGORY.CITY,
tuple(old_ids + DUMMY_IDS))
self.db.execute("DELETE FROM T_AREA_PRIVILEGE"
" WHERE administrator_id = %s"
" AND category = %s",
administrator_id, AREA.CATEGORY.PROVINCE)
# insert new ids
self.db.executemany("INSERT INTO T_AREA_PRIVILEGE"
" VALUES (NULL, %s, %s, %s)",
[(administrator_id, AREA.CATEGORY.CITY, id)
for id in new_ids])
else:
self.db.execute("DELETE FROM T_AREA_PRIVILEGE"
" WHERE administrator_id = %s",
administrator_id)
self.redis.delete(key)
self.redirect("/administrator/list/%s" % administrator_id)
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 prepare_data(self, hash_):
mem_key = self.get_memcache_key(hash_)
data = self.redis.getvalue(mem_key)
if data:
return data
provinces = self.get_argument('province_id', None)
cities = self.get_argument('city_id', None)
start_time = int(self.get_argument('start_time', None))
end_time = int(self.get_argument('end_time', None))
group = self.get_argument('group', None)
user_name = self.get_argument('user_name', None)
mobile = self.get_argument('mobile', None)
#if user_name and (not check_sql_injection(user_name)):
# return [], [start_time, end_time]
#if mobile and (not check_sql_injection(mobile)):
# return [], [start_time, end_time]
# the result of today is inavaliable
d = datetime.datetime.fromtimestamp(time.time())
t = datetime.datetime.combine(datetime.date(d.year,d.month, d.day), datetime.time(0, 0, 0))
today_ = int(time.mktime(t.timetuple())) * 1000
if start_time >= today_:
return [], [start_time, end_time]
results = []
if not (cities or provinces):
return results, [start_time, end_time]
elif not cities:
provinces = str_to_list(provinces)
cities = city_list(provinces, self.db)
else:
cities = str_to_list(cities)
cities = [int(c) for c in cities]
cs = self.db.query("SELECT DISTINCT region_code FROM T_HLR_CITY"
" WHERE city_id IN %s",
tuple(cities + DUMMY_IDS))
citylist = [c.region_code for c in cs]
query_term = {'city_id':{'$in':citylist},
'fetchtime':{'$gte':start_time, '$lte':end_time},
'group_id': None,
'user_name': None,
'mobile': None}
for term in ['user_name', 'mobile']:
v = self.get_argument(term, None)
if v:
query_term[term] = {'$regex': '\S*'+v+'\S*'}
else:
query_term.pop(term)
if group:
query_term['group_id'] = str(self.get_argument('group'))
else:
query_term.pop('group_id')
display_term = {'province':1, 'city':1, 'group_name':1,
'user_name':1, 'mobile':1, '_id':0}
res = []
try:
mobiles = self.collection.find(query_term, {'mobile':1}).distinct('mobile')
if mobiles:
for m in mobiles:
count = self.collection.find({'mobile':m,
'fetchtime':{'$gte':start_time, '$lte':end_time}}).count()
r = self.collection.find_one({'mobile':m,
'fetchtime':{'$gte':start_time, '$lte':end_time}}, display_term)
r['count'] = count
res.append(r)
if not res:
ins = MSms()
res = ins.retrieve(citylist, start_time, end_time)
except:
ins = MSmsMixin()
res = ins.retrieve_mixin(citylist, start_time, end_time)
res = ins.distinct(res)
if user_name:
p_name = re.compile(user_name)
if mobile:
p_mobile = re.compile(mobile)
results = []
for r in res:
flag = True
if group and r['group_id'] != group:
flag &= False
if user_name and not p_name.findall(r['user_name']):
flag &= False
if mobile and not p_mobile.findall(r['mobile']):
flag &= False
if flag:
results.append(r)
self.redis.setvalue(mem_key,(results, [start_time, end_time]),
time=self.MEMCACHE_EXPIRY)
return results, [start_time, end_time]
def prepare_data(self, hash_):
"""Associated with the post method.
workflow:
if get value according the hash:
return value
else:
retrieve the db and return the result.
"""
mem_key = self.get_memcache_key(hash_)
data = self.redis.getvalue(mem_key)
if data:
return data
# TODO: retrieve all the cities
# HOW TO BEST PASS province and city?
provinces = self.get_argument('province_id', None)
cities = self.get_argument('city_id', None)
start_time = int(self.get_argument('timestamp', None))
end_time = end_of_month(start_time)
d = date.fromtimestamp(start_time/1000)
year = d.year
month = d.month
# only last six days of this month can retrieve results
s_time = start_of_month(int(time.time())*1000)
e_time = end_of_month(int(time.time())*1000)
if start_time == s_time:
# this month
cal = date.today().timetuple()
year = cal.tm_year
month = cal.tm_mon
day = cal.tm_mday
maxdays = monthrange(year, month)[1]
if maxdays - day > ADMIN.MONTH_RETRIEVE_DAYS:
return [], start_time
elif start_time > e_time:
return [], start_time
if cities is None:
provinces = str_to_list(provinces)
cities = city_list(provinces, self.db)
else:
cities = str_to_list(cities)
cities = [int(c) for c in cities]
cs = self.db.query("SELECT DISTINCT region_code FROM T_HLR_CITY"
" WHERE city_id IN %s",
tuple(cities + DUMMY_IDS))
citylist = [int(c.region_code) for c in cs]
query_term = {'city_id': {'$in': citylist}, 'year': year, 'month': month}
try:
results = list(self.collection.find(query_term, {'_id':0}))
if not results:
ins = MLocation()
results = ins.retrieve(citylist, start_time, end_time)
except:
ins = MLocationMixin()
results = ins.retrieve_mixin(citylist, start_time, end_time)
self.redis.setvalue(mem_key, (results, start_time),
time=self.MEMCACHE_EXPIRY)
return results, start_time
def post(self):
"""Provide some statistics about terminals.
"""
status = ErrorCode.SUCCESS
try:
data = DotDict(json_decode(self.request.body))
logging.info("[UWEB] event statistic 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:
res = []
page_size = UWEB.LIMIT.PAGE_SIZE
page_number = int(data.pagenum)
page_count = int(data.pagecnt)
start_time = data.start_time
end_time = data.end_time
tids = str_to_list(data.tids)
# the interval between start_time and end_time is one week
if self.current_user.cid != UWEB.DUMMY_CID: # no checks for enterprise
pass
elif (int(end_time) - int(start_time)) > UWEB.QUERY_INTERVAL:
self.write_ret(ErrorCode.QUERY_INTERVAL_EXCESS)
return
CATEGORY_DCT = DotDict(illegalmove=EVENTER.CATEGORY.ILLEGALMOVE,
illegashake=EVENTER.CATEGORY.ILLEGALSHAKE,
#sos=EVENTER.CATEGORY.EMERGENCY,
heartbeat_lost=EVENTER.CATEGORY.HEARTBEAT_LOST,
powerlow=EVENTER.CATEGORY.POWERLOW)
if page_count == -1:
count = len(tids)
d, m = divmod(count, page_size)
page_count = (d + 1) if m else d
for tid in tids:
res_item = {}
res_item['alias'] = QueryHelper.get_alias_by_tid(tid, self.redis, self.db)
for key, category in CATEGORY_DCT.iteritems():
item = self.db.get("SELECT COUNT(*) as count FROM V_EVENT"
" WHERE tid = %s"
" AND (timestamp BETWEEN %s AND %s)"
" AND category = %s",
tid, start_time, end_time, category)
res_item[key] = item.count
res.append(res_item)
# store resutl in redis
m = hashlib.md5()
m.update(self.request.body)
hash_ = m.hexdigest()
mem_key = self.KEY_TEMPLATE % (self.current_user.uid, hash_)
self.redis.setvalue(mem_key, res, time=UWEB.STATISTIC_INTERVAL)
res = res[(page_number * page_size):((page_number+1) * page_size)]
self.write_ret(status,
dict_=DotDict(res=res,
pagecnt=page_count,
hash_=hash_))
except Exception as e:
logging.exception("[UWEB] event statistic, uid:%s, tid:%s failed. Exception: %s",
self.current_user.uid, self.current_user.tid, e.args)
status = ErrorCode.SERVER_BUSY
self.write_ret(status)
