def checkSelfOtherAttribute(self):
if not self.class_guid_id:
yield logClient.tornadoWarningLog('会议室:({}),设备({})没有指定类别'.format(
self.meeting_room_name, self.name))
if not self.brand_guid_id:
yield logClient.tornadoWarningLog('会议室:({}),设备({})没有指定品牌'.format(
self.meeting_room_name, self.name))
def getSelfSwitchFunction(self):
data = {
'database':
self.company_db,
'fields': [
'guid',
'device_guid_id', #所属设备
'control_channel_guid_id', #所属控制通道
'function_name', #功能名称 1 == 开机 0 == 关机
'control_type', #控制方式
'realize_status', #实现状态
],
'eq': {
'is_delete': False,
'device_guid_id': self.guid,
},
}
msg = yield mysqlClient.tornadoSelectAll('d_device_switch_function',
data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_device_switch_function'))
return
else:
switch_function_list = msg['msg']
for switch_function_info in switch_function_list:
function_name = switch_function_info.get('function_name')
control_type = switch_function_info.get('control_type')
realize_status = switch_function_info.get('realize_status')
channel_guid = switch_function_info.get('control_channel_guid_id')
if function_name == 1:
#开机
if self.on_info.get('channel_guid') != None:
yield logClient.tornadoWarningLog(
'会议室:({}),设备:({})的开机功能设置多条.自动省略一条'.format(
self.meeting_room_name, self.name))
else:
self.on_info['channel_guid'] = channel_guid
self.on_info['control_type'] = control_type
self.on_info['realize_status'] = realize_status
self.on_info['self_guid'] = self.guid
elif function_name == 0:
#关机
if self.off_info.get('channel_guid') != None:
yield logClient.tornadoWarningLog(
'会议室:({}),设备:({})的关机功能设置多条.自动省略一条'.format(
self.meeting_room_name, self.name))
else:
self.off_info['channel_guid'] = channel_guid
self.off_info['control_type'] = control_type
self.off_info['realize_status'] = realize_status
self.off_info['self_guid'] = self.guid
else:
yield logClient.tornadoWarningLog(
'会议室:({}),设备:({})的开关功能设置错误'.format(self.meeting_room_name,
self.name))
def tokenChangeHandle(self):
remove_list = []
for client in self.callback_address_set:
try:
clientInfo = json.loads(client)
except:
remove_list.append(client)
continue
callback = clientInfo.get('callback')
method = clientInfo.get('method')
if method not in ['post', 'get', 'POST', 'GET'
] or callback == None:
remove_list.append(client)
continue
data = {'token': self.token}
if method == 'get' or method == 'GET':
result = yield asyncTornadoRequest(callback,
method='GET',
params=data)
else:
result = yield asyncTornadoRequest(callback,
method='POST',
body=data)
if result.get('ret') == 0:
yield logClient.tornadoInfoLog('token反推成功,{}'.format(callback))
continue
else:
yield logClient.tornadoWarningLog(
'token反推失败,{}'.format(callback))
remove_list.append(client)
for client in remove_list:
self.callback_address_set.discard(client)
def getSelfOnlineFunction(self):
data = {
'database': self.company_db,
'fields': [
'guid',
'device_guid_id',
'control_channel_guid_id',
],
'eq': {
'is_delete': False,
'device_guid_id': self.guid,
},
}
msg = yield mysqlClient.tornadoSelectOnly('d_device_online_channel',
data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_device_online_channel'))
return
if msg['lenght'] == 0:
yield logClient.tornadoWarningLog(
'会议室:({}),设备({})没有定义在线状态通道'.format(self.meeting_room_name,
self.name))
return
self.online_channel_guid = msg['msg'][0]['control_channel_guid_id']
def control_device(self, control_type, msg):
'''
msg = {
'ret':0,
'type':'control',
'meeting_room_guid':'会议室guid',
'channel_guid':'通道guid',
'user_id':'用户id',
'event_type':'事件类型',
'status':'当前状态',
'control_type':'控制类型'
‘input_port’:'连接的输入源guid
'connection_token':'连接token‘
}
'''
# msg = {
# 'ret': 0,
# 'type': 'control',
# 'meeting_room_guid': '会议室guid',
# 'channel_guid': '通道guid',
# 'event_type': 'click',
# 'status': '当前状态',
# 'control_type': '控制类型',
# 'input_port':'连接的输入源guid',
# 'connection_token':'连接token',
# }
connection_token = msg.get('connection_token')
meeting_room_guid = msg.get('meeting_room_guid')
channel_guid = msg.get('channel_guid')
meeting_room_object = self.GuidToMeetingRoom.get(meeting_room_guid)
if meeting_room_object == None:
yield logClient.tornadoWarningLog('控制未知会议室设备')
return
back_msg = yield meeting_room_object.userControl(msg)
ret = back_msg.get('ret')
if ret == 0:
content = {
'ret': 0,
'type': control_type,
'guid': channel_guid,
'control_event': back_msg.get('event_type'),
'status': back_msg.get('status'),
'connection_token': connection_token
}
else:
content = {
'ret': 1,
'type': control_type,
'guid': channel_guid,
'connection_token': connection_token
}
topic = '/aaiot/0/send/controlbus/event/websocket/0/control'
yield self.myPublish(topic, json_dumps(content), QOS_LOCAL)
def login(self):
url = TOKEN_SERVICE_ADDRESS
data = {'callback': TOKEN_CHANGE_ADDRESS, 'method': 'POST'}
while True:
result = yield asyncTornadoRequest(url, method='GET', params=data)
if result.get('ret') == 0:
self.token = result.get('token')
if self.token != None:
yield logClient.tornadoInfoLog('登录成功,token:{}'.format(
self.token))
break
yield logClient.tornadoWarningLog('登录失败')
yield gen.sleep(5)
yield self.updateCallback()
def login(self):
body = {'username': self.username, 'password': self.password}
url = self.loginUrl
while True:
result = yield asyncTornadoRequest(url, method='POST', body=body)
if result.get('errcode') == 200:
result_body = result.get('body')
if result_body == None:
yield gen.sleep(10)
continue
self.token = result_body.get('token')
if self.token == None:
yield gen.sleep(10)
continue
yield logClient.tornadoInfoLog('登录成功')
break
else:
yield logClient.tornadoWarningLog('登录失败')
yield self.tokenChangeHandle()
def controlSelfChannel(self, channel_object, msg):
'''
:param channel_object: 通道对象
:param msg: {
topic:
topic_list:
data:
}
:return:
'''
control_event = msg.get('control_event')
channel_type = channel_object.type
if channel_type == 'button':
if control_event == 'click' or control_event == 'push':
old_status = channel_object.getSelfStatus()
if old_status == 'on':
yield channel_object.updateSelfStatus('off')
elif old_status == 'off':
yield channel_object.updateSelfStatus('on')
elif channel_type == 'channel':
if control_event == 'on' or control_event == 'off':
yield channel_object.updateSelfStatus(control_event)
elif channel_type == 'level':
try:
level_value = float(control_event)
if level_value > channel_object.max_value:
yield channel_object.updateSelfStatus(
channel_object.max_value)
elif level_value < channel_object.min_value:
yield channel_object.updateSelfStatus(
channel_object.min_value)
else:
yield channel_object.updateSelfStatus(level_value)
except:
pass
elif channel_type == 'string':
if type(control_event) != str:
string_value = str(control_event)
yield channel_object.updateSelfStatus(string_value)
else:
yield channel_object.updateSelfStatus(control_event)
else:
yield logClient.tornadoWarningLog('未知通道类型')
def forwardInformation(self, msg):
'''
功能： 将收到的信息,找到connection_token 相同的连接客户端,同步给他
1> channel_feedback类型(物联服务器主动推送消息) 需要判断是否有查询任务在等待,有查询任务则不推送
2> control类型(控制返回的假状态),需要处理聚集同步的事务
3> query类型(本服务查询,物联服务器返回的真实状态),直接同步
'''
try:
msg = json.loads(msg)
except:
return
msg_connection_token = msg.get('connection_token')
msg_used = False
for clientObject in self.clientObjectSet: # 遍历所有前端websocket连接用户
# connection_token 过滤
if clientObject.connection_token != msg_connection_token or msg_connection_token == None:
continue
msg_used = True
#分类型处理
type_ = msg['type']
# channel_feedback类消息 -- 推送给connection_token相同的前端,如果有查询任务在等待,则不推送
if type_ == 'channel_feedback':
channel_guid = msg.get('guid') # 获取同步信息guid信息
if channel_guid == None:
continue
# 如果通道guid不在查询字典中,说明可以推送给前端
if channel_guid not in clientObject.query_task_dict.keys():
# yield logClient.tornadoDebugLog('没有等待查询任务...推送信息:{}'.format(channel_guid))
yield clientObject.sendToWebsocketClient(msg)
else:
yield logClient.tornadoDebugLog(
'查询任务等待中...不推送:{}'.format(channel_guid))
elif type_ == 'login':
#获取登录结果
ret = msg.get('ret', 1)
if ret == 0:
#已登录状态,退出上一次登录
if clientObject.logined == 1:
for last_connection_token in clientObject.last_connection_token:
logont_msg = {
'type': 'logout',
'connection_token': last_connection_token
}
yield self.sendToService(json_dumps(logont_msg))
yield logClient.tornadoWarningLog(
'删除上次登录token:{}'.format(last_connection_token))
else:
clientObject.last_connection_token = []
#未登录状态 标注：已经登录
else:
clientObject.logined = 1
yield clientObject.sendToWebsocketClient(msg)
# 其他类型,直接推送
else:
if type_ == 'device_switch':
print(msg)
yield clientObject.sendToWebsocketClient(msg)
#判断是否是聚集通道,如果是聚集通道有同步的需要做同步
#只有控制聚集通道时,才同步
if type_ == 'control':
channel_guid = msg.get('guid') # 获取同步信息guid信息
if channel_guid == None:
continue
# 获取聚集通达状态
channel_status = msg.get('status') # 获取聚集通道的状态
#1: 尝试判断是否为聚集通道
sync_info = self.sync_channel_dict.get(channel_guid)
if sync_info != None: # 聚集通道
# 尝试获取状态相同的同步通道类别
sync_channel_list = sync_info.get(channel_status)
if sync_channel_list == None:
continue
# 遍历所有通道同步的通道,发送假反馈给前端
for sync_channel_info in sync_channel_list:
guid = sync_channel_info.get('sync_channel_guid')
meeting_room_guid = sync_channel_info.get(
'meeting_room_guid')
status = sync_channel_info.get('sync_channel_status')
try:
status = int(status)
except:
pass
info = {
'ret': 0,
'type': 'control',
'guid': guid,
'meeting_room_guid': meeting_room_guid,
'status': status,
'connection_token': msg_connection_token
}
yield clientObject.sendToWebsocketClient(info)
# 添加查询任务
delay_time = self.sync_delay_dict.get(guid, 3)
new_later_task = clientObject.ioloop.add_timeout(
self.ioloop.time() + delay_time,
clientObject.query_status, guid, meeting_room_guid)
last_later_task = clientObject.query_task_dict.get(
guid)
if last_later_task != None:
clientObject.ioloop.remove_timeout(last_later_task)
clientObject.query_task_dict[guid] = new_later_task
#2: 尝试获取互斥
for mutex_group in self.mutex_group_list:
channel_guid_list = mutex_group.get(
'channel_guid_list', [])
if channel_guid in channel_guid_list:
mutex_channel_info_dict = mutex_group.get(
'mutex_channel_info', [])
master_info = mutex_channel_info_dict.get(channel_guid)
if master_info == None:
continue
master_now_status = None
for key, value in master_info.items():
if value == channel_status:
master_now_status = key
break
if master_now_status != None:
if master_now_status == 'negative_value':
#其他通道取负值
other_channel_status = 'positive_value'
elif master_now_status == 'positive_value':
#其他通道取正值
other_channel_status = 'negative_value'
else:
continue
for guid, mutex_channel_info in mutex_channel_info_dict.items(
):
if guid != channel_guid:
status = mutex_channel_info.get(
other_channel_status)
meeting_room_guid = mutex_channel_info.get(
'meeting_room_guid')
try:
status = int(status)
except:
pass
info = {
'ret': 0,
'type': 'control',
'guid': guid,
'meeting_room_guid': meeting_room_guid,
'status': status,
'connection_token':
msg_connection_token
}
yield clientObject.sendToWebsocketClient(
info)
# 添加查询任务
delay_time = self.sync_delay_dict.get(
guid, 3)
new_later_task = clientObject.ioloop.add_timeout(
self.ioloop.time() + delay_time,
clientObject.query_status, guid,
meeting_room_guid)
last_later_task = clientObject.query_task_dict.get(
guid)
if last_later_task != None:
clientObject.ioloop.remove_timeout(
last_later_task)
clientObject.query_task_dict[
guid] = new_later_task
else:
continue
else:
if msg_used == False:
logont_msg = {
'type': 'logout',
'connection_token': msg_connection_token
}
yield self.sendToService(json_dumps(logont_msg))
yield logClient.tornadoWarningLog(
'删除上次登录token:{}'.format(msg_connection_token))
