def put(self): """Update the parameters of terminal. """ 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] Terminal 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: 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 user = QueryHelper.get_user_by_uid(self.current_user.uid, self.db) if not user: status = ErrorCode.LOGIN_AGAIN logging.error("[UWEB] The user with uid: %s does not exist," " redirect to login.html", self.current_user.uid) self.write_ret(status) return # sql injection if data.has_key('corp_cnum') and not check_cnum(data.corp_cnum): status = ErrorCode.ILLEGAL_CNUM self.write_ret(status) return # NOTE: deprecated if data.has_key('white_list'): white_list = ":".join(data.white_list) if not check_sql_injection(white_list): status = ErrorCode.ILLEGAL_WHITELIST self.write_ret(status) return self.update_terminal_db(data) # NOTE: wspush to client if status == ErrorCode.SUCCESS: WSPushHelper.pushS7(tid, self.db, self.redis) self.write_ret(status) except Exception as e: logging.exception("[UWEB] uid:%s, tid:%s update terminal info failed. Exception: %s", self.current_user.uid, self.current_user.tid, e.args) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def get(self): """Get activities. """ status = ErrorCode.SUCCESS try: res = [] timestamp = self.get_argument('timestamp', None) if timestamp is None: res = QueryHelper.get_activity_list(self.db) elif int(timestamp) == -1: res = QueryHelper.get_activity_avaliable(self.db) else: res = QueryHelper.get_activity_by_begintime(timestamp, self.db) for r in res: if r['filename']: r['filepath'] = self.application.settings[ 'activity_path'] + r['filename'] else: r['filepath'] = '' r['url'] = r['html_name'] del r['filename'] del r['html_name'] self.write_ret(status, dict_=DotDict(res=res)) except Exception as e: logging.exception("[UWEB] Get activities failed. Exception: %s", e.args) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def get(self): status = ErrorCode.SUCCESS try: category = int(self.get_argument('category', UWEB.APK_TYPE.YDWS)) if category == UWEB.APK_TYPE.YDWS: # 1 #version_info = get_version_info("android") version_info = QueryHelper.get_version_info_by_category( category, self.db) elif category == UWEB.APK_TYPE.YDWQ_MONITOR: # 2 version_info = QueryHelper.get_version_info_by_category( category, self.db) elif category == UWEB.APK_TYPE.YDWQ_MONITORED: # 3 version_info = QueryHelper.get_version_info_by_category( category, self.db) elif category == UWEB.APK_TYPE.YDWS_ANJIETONG: # 4 version_info = QueryHelper.get_version_info_by_category( category, self.db) else: logging.info("[UWEB] Invalid category: %s", category) self.write_ret(status, dict_=DotDict(version_info=version_info)) except Exception as e: logging.exception( "[UWEB] Android check update failed. Exception: %s", e.args) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def get(self): category = int(self.get_argument('category', 2)) if category == 2: # ydws #version_info = get_version_info('android') download_info = get_download_count(category, self.db) version_info = QueryHelper.get_version_info_by_category( UWEB.APK_TYPE.YDWS, self.db) update_download_count(category, self.db) self.render('android_weixin.html', versioncode=version_info.versioncode, versionname=version_info.versionname, versioninfo=version_info.versioninfo, updatetime=version_info.updatetime, filesize=version_info.filesize, count=download_info.count) elif category == 3: # ydwq_monitor version_info = QueryHelper.get_version_info_by_category( UWEB.APK_TYPE.YDWQ_MONITOR, self.db) url = "/static/apk/" + version_info['filename'] self.redirect(url) elif category == 4: # ydwq_monitored version_info = QueryHelper.get_version_info_by_category( UWEB.APK_TYPE.YDWQ_MONITORED, self.db) url = "/static/apk/" + version_info['filename'] self.redirect(url) elif category == 5: # ydws_anjietong version_info = QueryHelper.get_version_info_by_category( UWEB.APK_TYPE.YDWS_ANJIETONG, self.db) url = "/static/apk/" + version_info['filename'] self.redirect(url)
def get(self): """Display profile of current user. """ status = ErrorCode.SUCCESS try: tid = self.get_argument('tid',None) # check tid whether exist in request and update current_user self.check_tid(tid) profile = DotDict() # 1: user user = QueryHelper.get_user_by_uid(self.current_user.uid, self.db) if not user: status = ErrorCode.LOGIN_AGAIN logging.error("[UWEB] User does not exist, redirect to login.html. uid: %s.", self.current_user.uid) self.write_ret(status) return # 2: car car = QueryHelper.get_car_by_tid(self.current_user.tid, self.db) profile.update(user) profile.update(car) self.write_ret(status, dict_=dict(profile=profile)) except Exception as e: logging.exception("[UWEB] Get user 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 get(self): """Get terminal info. """ status = ErrorCode.SUCCESS try: tid = self.get_argument('tid', None) # check tid whether exist in request and update current_user self.check_tid(tid) car_sets = DotDict() 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 user = QueryHelper.get_user_by_mobile(terminal.owner_mobile, self.db) if not user: logging.error("[UWEB] The user with uid: %s does not exist," " redirect to login.html", self.current_user.uid) self.clear_cookie(self.app_name) self.write_ret(ErrorCode.LOGIN_AGAIN) return # NOTE: deprecated. if terminal['mannual_status'] == 1: terminal['parking_defend'] = 0 else: terminal['parking_defend'] = 1 # NOTE: deprecated. whitelist = QueryHelper.get_white_list_by_tid( self.current_user.tid, self.db) car_info = QueryHelper.get_car_by_tid( self.current_user.tid, self.db) car = dict(corp_cnum=car_info.get('cnum', '')) # add tow dict: terminal, car. add two value: whitelist_1, # whitelist_2 white_list = [terminal.owner_mobile] for item in whitelist: white_list.append(item['mobile']) car_sets.update(terminal) car_sets.update(car) car_sets.update(DotDict(white_list=white_list)) self.write_ret(status, dict_=dict(car_sets=car_sets)) except Exception as e: status = ErrorCode.SERVER_BUSY logging.exception("[UWEB] uid: %s tid: %s get terminal failed. Exception: %s", self.current_user.uid, self.current_user.tid, e.args) self.write_ret(status)
def post(self): """Get latest location of a terminal. """ status = ErrorCode.SUCCESS res = {} try: data = DotDict(json_decode(self.request.body)) mobile = str(data.mobile) token = data.token logging.info("[REALTIME] Request, data:%s", data) except Exception as e: status = ErrorCode.DATA_FORMAT_ILLEGAL logging.exception("[REALTIME] Invalid data format, body: %s, mobile: %s.", self.request.body, mobile) self.write_ret(status) return try: status = self.basic_check(token, mobile) if status != ErrorCode.SUCCESS: self.write_ret(status) return terminal = QueryHelper.get_terminal_by_tmobile(mobile, self.db) tid = terminal.tid location = QueryHelper.get_location_info(tid, self.db, self.redis) # check and make name valid if location and location['name'] is None: location['name'] = '' # check and make clatclon valid locations = [location,] locations = get_locations_with_clatlon(locations, self.db) location = locations[0] if (location and location.clatitude and location.clongitude): res = dict(lon=location.get('longitude', 0), lat=location.get('latitude', 0), clon=location.get('clongitude', 0), clat=location.get('clatitude', 0), timestamp=location.get('timestamp',0), name=location.get('name',''), type=location.get('type',0)) self.write_ret(status, dict_=dict(res=res)) except Exception as e: logging.exception("[REALTIME] sid: %s. Exception: %s", mobile, e.args) status = ErrorCode.FAILED self.write_ret(status)
def handle_charge_info(self, info): info = DotDict(info) self.db.execute("INSERT INTO T_CHARGE" " VALUES (NULL, %s, %s, %s)", info.dev_id, info.content, info.timestamp) user = QueryHelper.get_user_by_tid(info.dev_id, self.db) if not user: logging.error("[EVENTER] Cannot find USER of terminal: %s", info.dev_id) return sms_option = QueryHelper.get_sms_option_by_uid(user.owner_mobile, EVENTER.SMS_CATEGORY.CHARGE.lower(), self.db) if sms_option == UWEB.SMS_OPTION.SEND: logging.error("[EVENTER] do not send charge sms temporarily")
def get(self): """Just just to a new page. """ # NOTE: The se_id should can be found in platform. se_id = self.get_argument("se_id", "") single_event = QueryHelper.get_single_event_by_se_id(se_id, self.db) terminal = QueryHelper.get_terminal_info(single_event["tid"], self.db, self.redis) self.render( "single_point.html", single_id=single_event["sid"], alias=terminal["alias"], tid=single_event.get("tid", ""), start_time=single_event.get("start_time"), end_time=single_event.get("end_time"), )
def pushS4(tid, db, redis): """ S4 Information about online, offline. e.g. res = [] res.append(dict(tid='tid1', login_status=1)) res.append(dict(tid='tid2', login_status=2)) """ res = [] t = QueryHelper.get_terminal_info(tid, db, redis) if t: res.append(dict(tid=tid, biz_type=t.get('biz_type', 0), login_status=t['login'] if t['login'] == 0 else 1)) packet = dict(packet_type="S4", res=res) res = WSPushHelper.push_packet(tid, packet, db, redis)
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 pushS4(self, op): """ res = [] res.append(dict(tid='tid1', login_status=1)) res.append(dict(tid='tid2', login_status=2)) """ res = [] corp = self.db.get("SELECT * FROM V_TERMINAL where tid = %s", self.tid) if corp: terminals = self.db.query("SELECT tid FROM V_TERMINAL WHERE cid= %s", corp['cid']) for terminal in terminals: t = QueryHelper.get_terminal_info(terminal['tid'], self.db, self.redis) res.append(dict(tid=terminal['tid'], biz_type=0, login_status=t['login'])) else: res = [] packet = dict(packet_type="S4", res=res) res = self.push(packet) return res
def get_sms_status(self, tmobile): """ sms_status: 0, // failded 1, // sent 2, // reached to terminal 3, // terminal has connected to gataway """ sms_status = 0 terminal = QueryHelper.get_terminal_by_tmobile(tmobile, self.db) if terminal.login == GATEWAY.TERMINAL_LOGIN.ONLINE: sms_status = 3 elif terminal.msgid: sms_status = 1 else: sms = self.db.get("SELECT send_status, recv_status" " FROM T_SMS" " WHERE msgid = %s" " AND category = %s" " LIMIT 1", terminal.msgid, SMS.CATEGORY.MT) if not sms: pass elif sms.recv_status == 0: sms_status = 2 elif sms.send_status == 0: sms_status = 1 return sms_status
def get(self): """Display smsoption of current user. workflow: if alarmoption is exist: return alarmoption else: initialize the alarmoption return alarmoption """ status = ErrorCode.SUCCESS try: umobile = self.get_argument('umobile') logging.info( "[UWEB] Alarmoption request: %s", self.request.arguments) 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: alarm_options = QueryHelper.get_alarm_options(umobile, self.db) self.write_ret(status, dict_=dict(res=alarm_options)) except Exception as e: logging.exception("[UWEB] Get alarmoption failed. umobile: %s, Exception: %s", umobile, e.args) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def update_terminal_dynamic_info(db, redis, location): """Update terminal's dynamic info in db and redis. Then inclues gps, gsm, pbat. """ # db tid = location.dev_id fields = [] # NOTE: only gps, gsm, pbat should be updated keys = ['gps', 'gsm', 'pbat'] for key in keys: if location.get(key, None) is not None: fields.append(key + " = " + str(location[key])) set_clause = ','.join(fields) if set_clause: db.execute("UPDATE T_TERMINAL_INFO" " SET " + set_clause + " WHERE tid = %s", tid) # redis terminal_info = QueryHelper.get_terminal_info(tid, db, redis) if terminal_info: terminal_info_key = get_terminal_info_key(tid) for key in terminal_info: value = location.get(key, None) if value is not None: terminal_info[key] = value redis.setvalue(terminal_info_key, terminal_info)
def post(self): """Get last infomation of a terminal. """ status = ErrorCode.SUCCESS try: data = DotDict(json_decode(self.request.body)) mobile = str(data.mobile) manual_status = data.manual_status token = data.token logging.info("[MANUAL] Request, data:%s", data) except Exception as e: status = ErrorCode.DATA_FORMAT_INVALID logging.exception("[REBOO] Invalid data format, body: %s, mobile: %s.", self.request.body, mobile) self.write_ret(status) return try: status = self.basic_check(token, mobile) if status != ErrorCode.SUCCESS: self.write_ret(status) return terminal = QueryHelper.get_terminal_by_tmobile(mobile, self.db) tid = terminal.tid update_mannual_status(self.db, self.redis, tid, manual_status) self.write_ret(status) except Exception as e: logging.exception("[MANUAL] mobile: %s. Exception: %s", mobile, e.args) status = ErrorCode.FAILED self.write_ret(status)
def get(self): """Get the latest usable location. #NOTE: deprecated """ 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(self.current_user.tid, self.db) if not terminal: status = ErrorCode.LOGIN_AGAIN logging.error("[UWEB] The terminal with tid: %s is noexist, redirect to login.html", self.current_user.tid) self.write_ret(status) return ret = self.get_realtime(self.current_user.uid, self.current_user.sim) self.set_header(*self.JSON_HEADER) self.write(json_encode(ret)) except Exception as e: logging.exception("Failed to get location: %s, Sim: %s", e.args, self.current_user.sim) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def update_terminal_info_ydwq(db, redis, t_info): """Update terminal's info in db and redis. """ terminal_info_key = get_terminal_info_key(t_info['tid']) terminal_info = QueryHelper.get_terminal_info(t_info['tid'], db, redis) # 1: db fields = [] # gps, gsm, pbat, changed by position report keys = ['gps', 'gsm', 'pbat', 'login'] for key in keys: value = t_info.get(key, None) if value is not None and value != terminal_info[key]: fields.append(key + " = " + str(t_info[key])) set_clause = ','.join(fields) if set_clause: db.execute("UPDATE T_TERMINAL_INFO" " SET " + set_clause + " WHERE tid = %s", t_info['tid']) # 2: redis for key in terminal_info: value = t_info.get(key, None) if value is not None: terminal_info[key] = value redis.setvalue(terminal_info_key, terminal_info) return terminal_info
def get(self): """Display profile of current operator. """ status = ErrorCode.SUCCESS try: profile = DotDict() # 1: user oper = QueryHelper.get_operator_by_oid(self.current_user.oid, self.db) if not oper: status = ErrorCode.LOGIN_AGAIN logging.error("[UWEB] Operator does not exist, redirect to login.html. oid: %s.", self.current_user.oid) self.write_ret(status) return profile.update(oper) for key in profile.keys(): profile[key] = profile[key] if profile[key] else '' self.write_ret(status, dict_=dict(profile=profile)) except Exception as e: logging.exception("[UWEB] Get corp profile failed. oid:%s, tid:%s, Exception: %s", self.current_user.oid, self.current_user.tid, e.args) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def post(self): """Reboot a terminal. """ status = ErrorCode.SUCCESS try: data = DotDict(json_decode(self.request.body)) mobile = str(data.mobile) token = data.token logging.info("[REBOOT] Request, data:%s", data) except Exception as e: logging.exception("[REBOOT] Invalid data format, body: %s, mobile: %s.", self.request.body, mobile) status = ErrorCode.DATA_FORMAT_INVALID self.write_ret(status) return try: status = self.basic_check(token, mobile) if status != ErrorCode.SUCCESS: self.write_ret(status) return terminal = QueryHelper.get_terminal_by_tmobile(mobile, self.db) tid = terminal.tid restart_terminal(self.db, self.redis, tid, mobile) logging.info("[REBOOT] Restart a terminal. tid: %s, mobile: %s", tid, mobile) self.write_ret(status) except Exception as e: logging.exception("[REBOOT] Reboot failed. mobile: %s. Exception: %s", mobile, e.args) status = ErrorCode.FAILED self.write_ret(status)
def get_realtime(self, uid, sim): """Get the location of the current realtime request. workflow: if there is alive memcached, we can get location from it, else get location from db return result to user browser """ ret = DotDict(status=ErrorCode.SUCCESS, message='', location=None) location = QueryHelper.get_location_info(self.current_user.tid, self.db, self.redis) locations = [location,] locations = get_locations_with_clatlon(locations, self.db) location = locations[0] if (location and location.clatitude and location.clongitude): if not location.name: location.name = '' if location.has_key('id'): del location['id'] location['degree'] = float(location.degree) location['tid'] = self.current_user.tid ret.location = location return ret
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 get(self): """Display smsoption of current user. """ status = ErrorCode.SUCCESS try: terminals = self.db.query("SELECT tt.mobile, tt.owner_mobile" " FROM T_TERMINAL_INFO as tt, " " T_GROUP as tg, T_CORP as tc" " WHERE tt.service_status = 1 AND tc.cid = %s " " AND tc.cid = tg.corp_id AND tt.group_id = tg.id", self.current_user.cid) mobiles = [] for terminal in terminals: if terminal.owner_mobile not in mobiles: mobiles.append(terminal.owner_mobile) sms_options = {} for mobile in mobiles: sms_option = QueryHelper.get_sms_option(mobile, self.db) sms_options[mobile] = sms_option self.write_ret(status, dict_=dict(sms_options=sms_options)) except Exception as e: logging.exception("[UWEB] uid:%s tid:%s get SMS Options failed. Exception: %s", e.args) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def pushS6(tid, db, redis): """ S6 Information about basic info. res = [] res.append(dict(tid=tid, gps=8, gsm=8, pbat=8, )) """ res = [] terminal = QueryHelper.get_terminal_info(tid, db, redis) packet = dict(tid=tid, biz_type=terminal.get('biz_type', 0), gps=terminal['gps'], gsm=terminal['gsm'], pbat=terminal['pbat']) res.append(packet) packet = dict(packet_type="S6", res=res) res = WSPushHelper.push_packet(tid, packet, db, redis)
def pushS7(tid, db, redis): """ S7 Information about basic info. res = [] res.append(dict(tid=tid, alias='jiajiajia', icon_type=2, owner_mobile='13011292217', mannual_status=1, )) """ res = [] terminal = QueryHelper.get_terminal_info(tid, db, redis) packet = dict(tid=tid, biz_type=terminal.get('biz_type', 0), alias=terminal['alias'], icon_type=terminal['icon_type'], owner_mobile=terminal['owner_mobile'], mannual_status=terminal['mannual_status']) res.append(packet) packet = dict(packet_type="S7", res=res) res = WSPushHelper.push_packet(tid, packet, db, redis)
def notify_to_parents(self, alias, location, mobile, region_id=None): """Push information to clinet through push. PUSH 1.0 """ flag = self.check_timestamp(int(location['timestamp'])) if not flag: return category = location.category dev_id = location.dev_id if not location['pbat']: terminal = QueryHelper.get_terminal_info(dev_id, self.db, self.redis) location['pbat'] = terminal['pbat'] if terminal['pbat'] is not None else 0 if mobile: # 1: push to android android_push_list_key = get_android_push_list_key(mobile) android_push_list = self.redis.getvalue(android_push_list_key) if android_push_list: for push_id in android_push_list: push_key = NotifyHelper.get_push_key(push_id, self.redis) NotifyHelper.push_to_android(category, dev_id, alias, location, push_id, push_key, region_id) # 2: push to ios ios_push_list_key = get_ios_push_list_key(mobile) ios_push_list = self.redis.getvalue(ios_push_list_key) if ios_push_list: for ios_id in ios_push_list: ios_badge = NotifyHelper.get_iosbadge(ios_id, self.redis) NotifyHelper.push_to_ios(category, dev_id, alias, location, ios_id, ios_badge, region_id)
def post(self): """Query the white_list according to the given parameters. """ status = ErrorCode.SUCCESS try: data = json_decode(self.request.body) mobile = data.get('mobile') if check_zs_phone(mobile, self.db): biz_type = QueryHelper.get_biz_by_mobile(mobile, self.db) if biz_type: biz_type = biz_type.get('biz_type') else: r = re.compile(r"^(1477847\d{4})$") if r.match(mobile): biz_type = 1 else: biz_type = 0 whitelist = DotDict(mobile=mobile, biz_type=biz_type) self.write_ret(status, dict_=DotDict(whitelist=whitelist)) else: status = ErrorCode.MOBILE_NOT_ORDERED message = ErrorCode.ERROR_MESSAGE[status] % mobile self.write_ret(status=status, message=message) except Exception as e: logging.exception("Search whitelist failed.Terminal mobile: %s," " owner mobile: %s", mobile) self.render('errors/error.html', message=ErrorCode.FAILED)
def get(self): status = ErrorCode.SUCCESS try: tid = self.get_argument('tid',None) # check tid whether exist in request and update current_user self.check_tid(tid) terminal = self.db.get("SELECT id FROM T_TERMINAL_INFO" " WHERE tid = %s" " AND service_status = %s", self.current_user.tid, UWEB.SERVICE_STATUS.ON) if terminal: lq_sms_key = get_lq_sms_key(self.current_user.tid) sms = SMSCode.SMS_LQ % SMS.LQ.WEB biz_type = QueryHelper.get_biz_type_by_tmobile(self.current_user.sim, self.db) if biz_type != UWEB.BIZ_TYPE.YDWS: pass else: SMSHelper.send_to_terminal(self.current_user.sim, sms) self.redis.setvalue(lq_sms_key, True, SMS.LQ_INTERVAL) lq_interval_key = get_lq_interval_key(self.current_user.tid) self.redis.setvalue(lq_interval_key, int(time.time()), (SMS.LQ.WEB*60 - 160)) logging.info("[UWEB] wake up, send %s to Sim: %s", sms, self.current_user.sim) else: status = ErrorCode.LOGIN_AGAIN self.write_ret(status) except Exception as e: logging.exception("[UWEB] uid: %s wake up tid: %s failed. Exception: %s", self.current_user.uid, self.current_user.tid, e.args) status = ErrorCode.SERVER_BUSY self.write_ret(status)
def 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 post(self): cid = self.get_argument("cid", "") message = None url = None corp = QueryHelper.get_corp_by_cid(cid, self.db) if not corp: message = ErrorCode.USER_NOT_FOUND self.render("delegation/delegation_enterprise.html", message=message, url=url) else: uid = "dummy" tid = "dummy" tmobile = "dummy" cid = cid oid = UWEB.DUMMY_OID url = "/".join( [ ConfHelper.UWEB_CONF.url_out, UWebHelper.URLS.DELEGATION[1:], str(uid), str(tid), str(tmobile), str(cid), str(oid), ] ) sign = UWebHelper.get_sign("".join([str(uid), str(tid), str(tmobile), str(cid), str(oid)])) url += "?s=" + sign self.log_delegation(self.current_user.id, cid, uid, tid) self.render("delegation/delegation_enterprise.html", message=message, url=url)