def handleDeviceStatus(self, message=MessageDeviceStatus()): """ 注意: 包括 家庭模式 """ import base64 profile = message.params.get('profile', '') if profile: profile = base64.decodestring(profile) self.device.profile = profile self.device.save() return self.device.assign(message.values()) self.device.alive_time = timestamp_current() self.device.save() # 写入 redis name = constants.DeviceStatusHash.format(self.device_id) data = hash_object(self.device) self.redis.hmset(name, data) # 写入日志 log = model.LogDeviceStatus() log.device_id = self.device_id log.sys_time = timestamp_current() log.assign(message.params) # log.host_ver = message.host_ver # log.mcu_ver = message.mcu_ver # log.status_time = message.status_time # log.boot_time = message.boot_time log.save()
def create_cargo_address(): """查询本人创建的共享设备信息 支持 共享设备编号查询 或 设备编号查询 如果共享记录未创建则创建,并返回 """ user = g.user name = request.values.get('name') phone = request.values.get('phone') address_ = request.values.get('address', '') is_default = request.values.get('is_default', 0, type=int) if not name or not phone or not address_: return ErrorReturn(ErrorDefs.ParameterInvalid, u'必须提供联系人、手机号、收件地址').response if is_default: # 将其他记录设置为非默认 model.CargoAddress.collection().update_many( { 'user_id': user.id, 'is_default': 1 }, {'$set': { 'is_default': 0 }}) address = model.CargoAddress() address.user_id = user.id address.name = name address.phone = phone address.address = address_ address.is_default = is_default address.order = timestamp_current() address.update_time = timestamp_current() address.save() return CR(result=address.id).response
def inspectThread(self): self.running = True while self.running: gevent.sleep(1) if timestamp_current() - self.live_time > 60: self.logger.warn('no payload on line long time.(>60s)') self.close() break if self.join_time and timestamp_current() - self.status_time > 10: self.logger.warn('line_status recv timeout.') self.close() break
def get_ticket(): """上传微信 code , 与微信服务器交互,获得open_id,并返回token到前端""" main = instance.serviceManager.get('main') code = request.values.get('code') encryptedData = request.values.get('encryptedData') iv = request.values.get('encryptedData') if not code: return ErrorReturn(ErrorDefs.UserNotExist).response appid = main.getConfig().get('wx_settings').get('appid') secret = main.getConfig().get('wx_settings').get('secret') params = dict(appid=appid, secret=secret, js_code=code, grant_type='authorization_code') url = main.getConfig().get('wx_settings').get('code2session_url') resp = requests.get(url, params) data = resp.json() open_id = '' session_key = '' union_id = '' # if data.get('errcode') == 0: open_id = data.get('openid') session_key = data.get('session_key') # union_id = data.get('unionid') if not open_id: return ErrorReturn(ErrorDefs.AccessDenied, u'微信服务器返回错误:{}'.format( data.get('errcode'))).response user = model.User.get_or_new(platform='wx', account=open_id) user.platform = 'wx' user.last_login = timestamp_current() user.save() auth = AuthToken() auth.login_time = timestamp_current() auth.user_id = user.account auth.user_name = user.name auth.platform = 'wx' auth.open_id = open_id user.token = auth.encode() user.save() result = dict(open_id=open_id, union_id=union_id, token=user.token) return CR(result=result).response
def cmd_position_now(): """立即定位, 这里要进行请求阀控 2018.10.21 禁止发送 lbs 定位请求,在实时监控过程中,gps信号okey的 情况下,请求lbs,导致轨迹漂移 """ user = g.user device_id = request.values.get('device_id') main = instance.serviceManager.get('main') device = model.Device.get(device_id=device_id) cc = main.getCommandController(device.device_type) #设备上一次发送立即定位命令的时间 # redis记录最近一次发送时间,直到key失效之前不能重复发送 # 保证大量的客户端不会对设备发送大量的立即定位命令 name = constants.DevicePositionRequestTimeKey.format(device_id) redis = instance.datasourceManager.get('redis').conn value = redis.get(name) if not value: cmd = cc.positionNowGps() cmd_send(device_id, cmd, online=True) # cmd = cc.positionNowLbs() # cmd_send(device_id, cmd, online=True) expire = main.getConfig().get('max_position_request_interval', 10) redis.set(name, timestamp_current(), expire) # cmd = cc.positionNowLbs() # main.sendCommand(device_id, cmd) # cmd = cc.positionNowGps() # main.sendCommand(device_id, cmd) return CR().response
def rebuild_device_followers(): model.ShareDeviceFollower.collection().delete_many({}) shares = model.SharedDeviceLink.find() # print shares for share in shares: devices = model.DeviceUserRelation.find(is_share_device=True,share_device_link = share.id) for device in devices: user = model.User.get(_id= ObjectId(device.user_id) ) print '=*'*20 print share.name # print share.user_id # print user # wxuser = model.WxUser(open_id = user.account) follower = model.ShareDeviceFollower.get(share_id=share.id,user_id=user.id) if not follower: follower = model.ShareDeviceFollower() follower.user_id = user.id follower.open_id = user.account follower.share_id = share.id follower.device_id = share.device_id follower.create_time = timestamp_current() wxuser = model.WxUser.get(open_id=user.account) if wxuser: follower.avatar_url = wxuser.avatarUrl follower.nick_name = wxuser.nickName print follower.nick_name # print follower.dict() follower.save()
def distribute_message(self,message): data = message.dict() data['name'] = message.__class__.__name__ data['type_id'] = message.Type.value data['type_comment'] = message.Type.comment data['timestamp'] = timestamp_current() data['datetime'] = current_datetime_string() data['device_id'] = self.device_id data['device_type'] = self.device_type if data.has_key('extra'): del data['extra'] if data.has_key('Type'): del data['Type'] print data #将设备消息发布出去 self.service.dataFanout('switch0',json.dumps(data)) # 发布到隶属于设备编号的通道上去 self.device_pub_channel.publish_or_produce(json.dumps(data)) # # 写入日志数据库 dbname = 'blue_earth_device_log' coll = self.mongo[dbname][self.device_id] coll.insert_one(data)
def init_outerbox(): """室外机登录""" ip = request.remote_addr.split(':')[-1] box = model.OuterBox.get(ip=ip) # 根据ip检查设备是否登记 if not box: return ErrorReturn(ErrorDefs.ObjectNotExist, u'室外主机未登记') box.login_time = timestamp_current() box.save() data = {} garden = model.HomeGarden.get(id='8888') data['propcenter_ip'] = garden.property_call_server data['stream_server_url'] = garden.stream_server_url innerbox_list = [] rs = model.InnerBox.find(garden_id=garden.id, building_id=box.building_id) for _ in rs: innerbox_list.append(dict(room_id=_.room_id, ip=_.ip)) sentry_list = [] rs = model.SentryApp.find(garden_id=garden.id) for _ in rs: sentry_list.append(dict(name=_.name, ip=_.ip)) data['innerbox_list'] = innerbox_list data['sentry_list'] = sentry_list result = data return CR(result=result)
def handleDeviceLogInfo(self, message=MessageDeviceLogInfo()): log = model.LogDeviceLogInfo() log.device_id = self.device_id log.sys_time = timestamp_current() log.device_time = message.time log.content = message.content log.save()
def sendCommand(self,command): content = command content = self.command_controller.execute(content) if not content: return True self.logger.debug('SendCommand: {} {} {}'.format(content,self.device_id,self.device_type)) command = MessageOnlineCommand() command.content = content command.sequence = self.seq_gen.next_id() packet = command.packet() packet.sequence = self.next_packet_sequence() try: self.conn.sendData(packet.to_bytes()) except: self.logger.error('socket sendData error. {} {} {}'.format(content,self.device_id,self.device_type)) self.close() return False # save send record send = model.CommandSend() send.device_id = self.device_id send.send_time = timestamp_current() send.sequence = packet.sequence send.command = command.content send.save() return True
def messageProcessTask(self): """处理设备上报消息的工作队列""" while self.running: # 长久没有心跳包 if timestamp_current() - self.last_heartbeat > 60 * 5: self.logger.warn('Heartbeat Lost. Close socket. {} {} '.format( self.device_id, self.device_type)) self.close() break try: message, date = self.queue.get(block=True, timeout=1) try: self.logger.debug( 'message pop from queue: {} {} {} {}'.format( date, message.__class__.__name__, self.device_id, self.device_type)) self.handleMessage(message) except: self.logger.warn(traceback.print_exc()) self.close() break except: pass self.logger.warn('messageTask() exiting.. {} {} '.format( self.device_id, self.device_type))
def setTrading(self, code, allow=True): """指定证券代码进入可交易状态""" cfg = self.trading_codes.get(code, {'allow': False, 'start': 0}) cfg['allow'] = allow if not allow: cfg['start'] = 0 else: cfg['start'] = timestamp_current()
def onConnected(self, conn, address): """连接上来 , 等待app发送join请求,超时 10s 断开连接 """ self.logger.debug('app connected . {}'.format(str(address))) self.conn = conn self.peer_address = address # 连接上来的对方地址 self.last_heartbeat = timestamp_current() # gevent.spawn_later(self.checkLogin,10) gevent.spawn(self.checkLogin)
def device_login(): """设备主机登陆,服务器校验合法性,并返回接入服务器地址""" main = instance.serviceManager.get('main') id_ = request.values.get('id') type_ = request.values.get('type') ver = request.values.get('ver') time = request.values.get('time') sign = request.values.get('sign','').upper() if not id_ or not type_ or not ver or not time or not sign: # if not id_ or not type_ : return ErrorReturn(ErrorDefs.ParameterInvalid).response secret_key = main.getConfig().get('device_secret_key') value,_ = make_signature(secret_key,dict(id=id_,type=type_,ver=ver,time=time)) if value != sign: instance.getLogger().error(u"数据签名计算错误") return ErrorReturn(ErrorDefs.ParameterInvalid).response device = model.SmartDevice.get(id = id_) if not device: return ErrorReturn(ErrorDefs.ObjectNotExist,u'设备不存在').response # 加入 认证处理时间 data = dict(id=id_,type=type_,ver=ver,time=time,auth_time=timestamp_current()) token = device_token_create(data,device.secret_key) main = instance.serviceManager.get('main') boxserver = main.getConfig().get('boxserver') host,port = boxserver.split(':') result = dict(token=token, server_ip=host, server_port=int(port), server_time=timestamp_current() ) # server = model.DeviceServer.get(id=device.server_id) # if not server: # return ErrorReturn(ErrorDefs.DeviceServerNotFound).response # # result = dict( token = token, server_ip = server.ip, server_port = server.port , # server_time = timestamp_current() # ) return CR(result= result).response
def add_device_into_group(): """添加设备到组 """ user = g.user group_id = request.values.get('group_id') device_id = request.values.get('device_id') rel = model.DeviceGroupRelation.get(user_id = user.id,group_id=group_id,device_id=device_id) if rel: return CR().response rel = model.DeviceGroupRelation() rel.group_id = group_id rel.device_id = device_id rel.user_id = user.id rel.update_time = timestamp_current() rel.order = timestamp_current() rel.save() return CR(result=rel.id).response
def init_product_list(): content = YamlConfigParser('./product-list.yaml').props.get('product_list') for profile in content: product = model.Product.get_or_new(sku=profile['sku']) # product = model.Product() object_assign(product, profile) product.update_time = timestamp_current() product.save()
def create_share_device_code(): """生成分享码 缓存中记录分享码生成时间 """ from mantis.BlueEarth import constants redis = instance.datasourceManager.get('redis').conn code = '1212' name = constants.DeviceShareCodeCreateTimeKey.format(code) redis.set(name, timestamp_current(), 3600) return CR(result=code).response
def create_favorite(): """ 收藏产品 """ user = g.user sku = request.values.get('sku') comment = request.values.get('comment', '') product = model.Product.get(sku=sku) if not product: return ErrorReturn(ErrorDefs.ObjectNotExist, u'产品不存在').response favorite = model.Favorite() favorite.user_id = user.id favorite.sku = sku favorite.number = 1 favorite.create_time = timestamp_current() favorite.order = timestamp_current() favorite.comment = comment favorite.save() return CR(result=favorite.id).response
def onActive(self): """设备在线登录, 订阅本设备下行的消息""" self.logger.debug('device onActive. {} {}'.format( self.device_type, self.device_id)) self.active = True gevent.spawn(self.threadHeartbeat) # 定时心跳发送 access_url = self.service.getConfig().get( 'access_api_url') #暴露给外部调用的web接口,接收命令控制 self.redis.set(constants.DeviceAccessHttpAPI.format(self.device_id), access_url) # 记录设备由哪个sever接入的 # service_id = self.service.getConfig().get('id') # self.redis.hset(constants.DeviceServerRel,self.device_id,service_id) device = model.SmartDevice.get(id=self.device_id) if device: self.device = device else: self.logger.error('device not register', self.device_id) self.close() return CHECK_ACTIVE = False if CHECK_ACTIVE: if not device.active_time: # 未激活 self.logger.error('device not actived.', self.device_id) self.close() return device.alive_time = timestamp_current() device.save() self.service.deviceOnline(self) self.subscribeTraverseDownMessage() # 创建到华为iot的通道 # self.iot_controller = iot.IotController(self) # self.iot_controller.onActive() # 设备上线,即刻发送设备状态查询 self.traverseDown(MessageDeviceStatusQuery()) # 要求设备返回所有状态 20190630 msg_sensor_query = MessageSensorStatusQuery() msg_sensor_query.sensor_type = 0 msg_sensor_query.sensor_id = 0 self.traverseDown(msg_sensor_query) # 发送设备profile上报请求 msg_upload_profile = MessageDeviceCommand() msg_upload_profile.command = 'upload_profile' self.traverseDown(msg_upload_profile)
def traverseDown(self, message): """转发设备下行消息""" self.conn.sendData(message.marshall()) if isinstance(message, MessageDeviceValueSet): log = model.LogDeviceValueSet() log.device_id = self.device_id log.sys_time = timestamp_current() log.param_name = message.param_name log.param_value = message.param_value log.save() if isinstance(message, MessageSensorValueSet): log = model.LogSensorValueSet() log.device_id = self.device_id log.sensor_id = message.sensor_id log.sensor_type = message.sensor_type log.sys_time = timestamp_current() log.param_name = message.param_name log.param_value = message.param_value log.save()
def create_group(): """创建设备组 """ user = g.user name = request.values.get('name') comment = request.values.get('comment','') if not name: return ErrorReturn(ErrorDefs.ParameterInvalid).response if model.Group.get(name=name): return ErrorReturn(ErrorDefs.ObjectHasExist,u'相同组名已存在').response group = model.Group() group.name = name group.comment = comment group.order = timestamp_current() group.user_id = user.id group.create_time = timestamp_current() group.update_time = timestamp_current() group.save() return CR(result=group.id).response
def make_position(self): pos = model.Position() name = DevicePositionLastest.format(device_id=self.device_id) data = self.redis.hgetall(name) # if data: # object_assign(pos,data) pos.device_id = self.device_id pos.device_type = self.device_type pos.report_time = timestamp_current() # 取出当前的信号值、电压值 if data: pos.gsm = data.get('gsm', 0) pos.voltage = data.get('voltage', 0) return pos
def update_group_info(): """更新设备组信息 支持记录 置顶 settop = 1 """ user = g.user group_id = request.values.get('group_id') name = request.values.get("name") comment = request.values.get('comment') settop = request.values.get('set_top',0,type=int) group = model.Group.get(user_id=user.id,_id=ObjectId(group_id)) if not group: return ErrorReturn(ErrorDefs.ObjectNotExist).response if name: group.name = name if comment: group.comment = comment if settop: group.order = -timestamp_current() if name or comment or settop: group.update_time = timestamp_current() group.save() return CR(result=group.id).response
def checkTask(self, dest): from model import InnberBoxCheck, InnberBoxCheckSnapShot data = check_one_host(dest) if not data: return data['ip'], data['port'] = dest data['check_time_s'] = current_datetime_string() data['check_time'] = timestamp_current() check = InnberBoxCheck() check.assign(data) check.save() obj = InnberBoxCheckSnapShot.get_or_new(ip=dest[0]) obj.assign(data) obj.save()
def update_cargo_address(): """ """ user = g.user id = request.values.get('id') is_default = request.values.get('is_default', 0, type=int) order = request.values.get('order', 0, type=int) props = request.values.to_dict() address = model.CargoAddress.get(_id=ObjectId(id)) if not address: return ErrorReturn(ErrorDefs.ObjectNotExist, u'请求对象不存在').response object_assign(address, props) address.is_default = is_default address.user_id = user.id address.update_time = timestamp_current() address.save() return CR(result=address.id).response
def get_device_share_info(): """查询本人创建的共享设备信息 支持 共享设备编号查询 或 设备编号查询 如果共享记录未创建则创建,并返回 """ user = g.user share_id = request.values.get('share_id') # device_id = request.values.get('device_id') link = None # if share_id: # link = model.SharedDeviceLink.get(user_id=user.id,_id=ObjectId(share_id)) # device = model.DeviceUserRelation.get(user_id=user.id, device_id=device_id) # if not device: # return ErrorReturn(ErrorDefs.ObjectNotExist,u'设备对象不存在').response # link = model.SharedDeviceLink.get(user_id=user.id,device_id=device_id) link = model.SharedDeviceLink.get(_id=ObjectId(share_id)) result = link.dict() result['share_id'] = link.id result['create_time_str'] = timestamp_to_str(result['create_time']) expire_time = parse(link.expire_time) + relativedelta(days=+1) expire_time = datetime_to_timestamp(expire_time) # 共享设备是否过期 if expire_time and expire_time < timestamp_current(): result['is_expired'] = True # 访问上限 if link.user_limit: num = model.DeviceUserRelation.collection().find({ 'share_device_link': link.id }).count() if num >= link.user_limit: result['is_limited'] = True if link.password: result['is_password_null'] = False else: result['is_password_null'] = True return CR(result=result).response
def handleSensorStatus(self, message=MessageSensorStatus()): # 写入 redis 记录设备当前最新的状态值 name = constants.SensorStatusHash.format( device_id=self.device_id, sensor_type=message.sensor_type, sensor_id=message.sensor_id) data = message.params self.redis.hmset(name, data) # 发布到华为iot # self.iot_controller.onMessageSensorStatus( message ) sensor = model.Sensor.get(device_id=message.device_id, id=message.sensor_id, type=message.sensor_type) if not sensor: sensor = model.Sensor() sensor.id = message.sensor_id sensor.type = message.sensor_type sensor.device_id = message.device_id params = {} if sensor.params: # 合并新老的状态参数值 try: params = json.loads(sensor.params) params.update(params) except: pass params.update(message.params) jsondata = json.dumps(params) sensor.params = jsondata sensor.save() # 写入日志 log = model.LogSensorStatus() log.device_id = self.device_id log.sys_time = timestamp_current() log.sensor_id = message.sensor_id log.sensor_type = message.sensor_type log.datetime = datetime.datetime.now() log.assign(message.params) # log.params = json.dumps( message.params ) log.save()
def messageTask(self): import traceback while self.running: # 长久没有心跳包 if timestamp_current() - self.last_heartbeat > MaxLiveTimeDeviceLandingServerKey: self.logger.warn('device heartbeat timer reached limit. close socket. {} {} '.format(self.device_id, self.device_type)) self.close() break try: message,date = self.queue.get(block=True, timeout=1) try: self.logger.debug('message pop from queue: {} {} {} {}'.format(date,message.__class__.__name__,self.device_id,self.device_type)) self.handle(message) except: self.logger.warn(traceback.print_exc()) except:pass self.logger.warn('messageTask() exiting.. {} {} '.format(self.device_id, self.device_type))
def checkLogin(self, message): from mantis.fanbei.smarthome.token import device_token_check device = model.SmartDevice.get(id=message.device_id) if not device: return False secret = device.secret_key data = device_token_check(message.token, secret) if not data: return False auth_time = data.get('auth_time', 0) self.device_id = data.get('id') self.device_type = data.get('type') TOKEN_VALID_TIME = self.service.getConfig().get( 'token_valid_time', 300) # 校验token是否已过期 if timestamp_current() - auth_time > TOKEN_VALID_TIME: instance.getLogger().error(u'过期无效token: ', message.token) return False return True
def handle_lbs_alarm(self,message): """处理lbs报警""" alarm = model.AlarmData() alarm.alarm_source_type = AlarmSourceType.LBS_ALARM alarm.alarm_name = AlarmType.get_name(message.location_ext.alarm) pos = self.make_position() pos.timestamp = timestamp_current() # str_to_timestamp(message.location.ymdhms) object_assign(pos,message.location_ext.dict()) pos.position_source = PositionSource.LBS self.convertLbsLocation(pos) self.savePosition(pos) data = hash_object(pos,excludes=('_id',)) object_assign(alarm,data) alarm.alarm_name = AlarmType.get_name(message.location_ext.alarm) alarm.save() # 推送更新的报警包 self.device_app_pub_channel.publish_or_produce(json.dumps(data))