def updataSelfStatus(self,status):
if self.type == 'button' or self.type == 'channel':
if status == 'on' or status == 'off':
self.channel_value = status
elif self.type == 'level':
try:
self.level_value = float(status)
except:
pass
elif self.type == 'string':
self.string_value = status
elif self.type == 'macro':
if status == 'on' or status == 'off':
self.channel_value = status
else:
yield logClient.tornadoInfoLog('聚集通道狀態反饋錯誤:{}'.format(status))
elif self.type == 'matrix':
if isinstance(status,dict):
self.matrix_value = status.get('channel_guid')
yield logClient.tornadoDebugLog('矩阵通道:{}更新状态为:{}'.format(self.name, self.matrix_value))
else:
try:
status = json.loads(status)
self.matrix_value = status.get('channel_guid')
yield logClient.tornadoDebugLog('矩阵通道:{}更新状态为:{}'.format(self.name,self.matrix_value))
except:
yield logClient.tornadoErrorLog(status)
elif self.type == 'none':
if self.feedback == 'button' or self.feedback == 'channel':
if status == 'on' or status == 'off':
self.channel_value = status
elif self.feedback == 'level':
try:
self.level_value = float(status)
except:
pass
elif self.feedback == 'string':
self.string_value = status
elif self.feedback == 'matrix':
if isinstance(status, dict):
self.matrix_value = status.get('channel_guid')
yield logClient.tornadoDebugLog('矩阵通道:{}更新状态为:{}'.format(self.name, self.matrix_value))
else:
try:
status = json.loads(status)
self.matrix_value = status.get('channel_guid')
yield logClient.tornadoDebugLog('矩阵通道:{}更新状态为:{}'.format(self.name, self.matrix_value))
except:
yield logClient.tornadoErrorLog(status)
else:
yield logClient.tornadoErrorLog('未知通道:{}'.format(self.guid))
return
else:
yield logClient.tornadoErrorLog('未知通道:{}'.format(self.guid))
return
for callback in self.updateCallback:
yield callback(self.guid,self.getSelfStatus())
def getMutexChannel(self):
mutex_group_guid_list = []
for DATABASE in DATABASES:
db = DATABASE['name']
data = {
'database': db,
'fields': ['guid'],
'eq': {
'is_delete': False,
}
}
msg = yield mysqlClient.tornadoSelectAll('d_mutex_group', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog('数据库:{},查询失败:{}'.format(
db, 'd_mutex_group'))
return
mutex_group_guid_list += [x['guid'] for x in msg['msg']]
for mutex_group_guid in mutex_group_guid_list:
data = {
'database':
db,
'fields': [
'd_mutex_channel.control_channel_guid_id',
'd_mutex_channel.positive_value',
'd_mutex_channel.negative_value',
'd_control_channel.meeting_room_guid_id',
],
'eq': {
'd_mutex_channel.is_delete': False,
'd_control_channel.guid': {
'key': 'd_mutex_channel.control_channel_guid_id'
},
'mutex_group_guid_id': mutex_group_guid
}
}
msg = yield mysqlClient.tornadoSelectAll(
'd_mutex_channel,d_control_channel', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_macro_back'))
return
mutex_channel_info = msg['msg']
info = {
'mutex_channel_info': {
x['control_channel_guid_id']: {
'positive_value': x['positive_value'],
'negative_value': x['negative_value'],
'meeting_room_guid': x['meeting_room_guid_id']
}
for x in mutex_channel_info
},
'channel_guid_list':
[x['control_channel_guid_id'] for x in mutex_channel_info]
}
self.mutex_group_list.append(info)
def getSelfWeather(self):
result = yield self.getWeather(self.city_id,self.name)
# print(result)
status = result.get('status')
if status == 1:
yield logClient.tornadoErrorLog(result.get('errmsg'))
return
city_id = result.get('cityid') #当前城市ID
if city_id != self.city_id:
yield logClient.tornadoErrorLog('{}:获取的天气信息城市不一至:{},{}'.format(self.name,self.city_id,city_id))
return
date = result.get('date') #日期
# week = result.get('week') #星期
update_time = result.get('update_time') #气象台更新时间
# city = result.get('city') #天气情况
# cityEn = result.get('cityEn') #
# country = result.get('country') #
# countryEn = result.get('countryEn')
self.wea = result.get('wea') #天气情况
self.wea_img = result.get('wea_img') #天气对应图标(xue, lei, shachen, wu, bingbao, yun, yu, yin, qing)
self.tem = result.get('tem') #当前温度
self.tem1 = result.get('tem1') #最小温度
self.tem2 = result.get('tem2') #最大温度
self.win = result.get('win') #风向
self.win_speed = result.get('win_speed') #风速等级
self.win_meter = result.get('win_meter') #风速 如: 12km/h
self.humidity = result.get('humidity') #湿度
self.visibility = result.get('visibility') #能见度
self.pressure = result.get('pressure') #气压hPa
self.air = result.get('air') #空气质量
self.air_pm25 = result.get('air_pm25') #PM2.5
self.air_level = result.get('air_level') #空气质量等级
# air_tips = result.get('air_tips') #空气质量描述
# alarm = result.get('alarm')
now_time = datetime.datetime.now()
updateTime = datetime.datetime.strptime(date +' '+update_time,'%Y-%m-%d %H:%M')
last_update_time = updateTime + datetime.timedelta(seconds=self.updateInvertal)
invertal = (last_update_time - now_time).seconds+30
yield self.publishSelfInfo()
self.ioloop.add_timeout(self.ioloop.time()+invertal, self.getSelfWeather)
yield logClient.tornadoInfoLog('城市:{},天气情况:{}'.format(self.name,self.wea))
yield logClient.tornadoInfoLog('城市:{},天气对应图标:{}'.format(self.name,self.wea_img))
yield logClient.tornadoInfoLog('城市:{},当前温度:{}'.format(self.name,self.tem))
yield logClient.tornadoInfoLog('城市:{},最大温度:{}'.format(self.name, self.tem1))
yield logClient.tornadoInfoLog('城市:{},最小温度:{}'.format(self.name, self.tem2))
yield logClient.tornadoInfoLog('城市:{},风向:{}'.format(self.name,self.win))
yield logClient.tornadoInfoLog('城市:{},风速等级:{}'.format(self.name,self.win_speed))
yield logClient.tornadoInfoLog('城市:{},风速:{}'.format(self.name,self.win_meter))
yield logClient.tornadoInfoLog('城市:{},湿度:{}'.format(self.name,self.humidity))
yield logClient.tornadoInfoLog('城市:{},能见度:{}'.format(self.name,self.visibility))
yield logClient.tornadoInfoLog('城市:{},气压hPa:{}'.format(self.name,self.pressure))
yield logClient.tornadoInfoLog('城市:{},空气质量:{}'.format(self.name,self.air))
yield logClient.tornadoInfoLog('城市:{},PM2.5:{}'.format(self.name,self.air_pm25))
yield logClient.tornadoInfoLog('城市:{},空气质量等级:{}'.format(self.name,self.air_level))
def initMeetingRoom(self):
for DATABASE in DATABASES:
db = DATABASE['name']
# 获取公司名称
if db == 'aura':
db_name = 'default'
else:
db_name = db
data = {
'database': 'aura',
'fields': ['name'],
'eq': {
'database_name': db_name
}
}
msg = yield mysqlClient.tornadoSelectOnly('d_company', data)
if msg['ret'] == '0' and msg['lenght'] == 1:
company_name = msg['msg'][0]['name']
else:
yield logClient.tornadoErrorLog('数据库:{},查询错误:({})'.format(
db, 'd_company'))
continue
data = {
'database':
db,
'fields': [
'guid',
'room_name',
'sin_minute',
'status_group_guid_id as schedule_status',
],
'eq': {
'is_delete': False,
# 'guid':'ec5eadb8-9744-11e9-922b-5254002d0365',
},
}
msg = yield mysqlClient.tornadoSelectAll('d_meeting_room', data)
if msg['ret'] == '0':
room_list = msg['msg']
else:
yield logClient.tornadoErrorLog('获取数据库:排程信息失败')
continue
for room_info in room_list:
room_info['company_db'] = db
room_info['company_name'] = company_name
room_info['publish_function'] = self.myPublish
meeting_room_object = MeetingRoom(**room_info)
self.meetingRoomDict[
meeting_room_object.guid] = meeting_room_object
else:
yield logClient.tornadoDebugLog('会议室更新完成,开始分钟事件')
self.ioloop.add_timeout(self.ioloop.time(), self.minuteTask)
def updateSelfRunStatus(self):
'''
status
0 运行中 -- 在线 +
1 未连接 -- 不在线
2 关闭中
3 待修中
'''
if self.online_status == 0:
status = 1
elif self.switch_status == 0: #关
status = 2
elif self.switch_status == 1: #开
status = 0
else:
return
data = {
'database': self.company_db,
'msg': {
'run_status': status
},
'eq': {
'guid': self.guid,
'is_delete': False,
}
}
msg = yield mysqlClient.tornadoUpdateMany('d_device', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog('数据库更新失败:{}'.format('d_device'))
def storageDeviceOpen(self):
# 查询最近一次记录
data = {
'database': self.company_db,
'fields':
['update_time', 'device_guid_id', 'status_name', 'work_time'],
'eq': {
'is_delete': False,
'device_guid_id': self.guid,
},
'sortInfo': [
{
'update_time': 'DESC',
},
]
}
msg = yield mysqlClient.tornadoSelectOne('d_device_switch_record',
data)
if msg['ret'] == '0':
if not msg['msg']: # 没有记录开机,添加记录开机
yield self.mysqlStorage('d_device_switch_record', {
'status_name': 1,
'work_time': 0
})
elif msg['msg'].get('status_name') == 0: # 上一次记录是关机,则记录一次开机
yield self.mysqlStorage('d_device_switch_record', {
'status_name': 1,
'work_time': 0
})
else:
yield logClient.tornadoErrorLog(
'数据库查询错误:{}'.format('d_device_switch_record'))
return
def updateGoods(self):
for DATABASE in DATABASES:
db = DATABASE['name']
data = {
'database':
db,
'fields': [
'barcode', 'qrcode', 'label1', 'label2', 'label3',
'label4', 'label5', 'label6', 'label7', 'label8', 'label9',
'label10', 'label11', 'label12', 'label13', 'label14',
'label15', 'label16', 'label17', 'label18', 'photo1',
'photo2', 'photo3', 'photo4', 'photo5'
],
'eq': {
'is_delete': False
},
}
msg = yield mysqlClient.tornadoSelectAll('d_shop_goods', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog('获取数据库:商品信息失败')
break
goods_list = msg['msg']
for goods in goods_list:
self.goods_dict[goods['barcode']] = Goods(
**goods,
ioloop=self.ioloop,
aioloop=self.aioloop,
eslCloudClient=self.eslCloudClient)
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 updateAllCity(self):
for DATABASE in DATABASES:
db = DATABASE['name']
data = {
'database': db,
'fields': ['guid','name','city_id'],
'eq': {
'is_delete': False,
},
'neq':{
'upper_story_id': None,
'city_id':'',
}
}
msg = yield mysqlClient.tornadoSelectAll('d_city', data)
if msg['ret'] == '0':
city_list = msg['msg']
else:
yield logClient.tornadoErrorLog('数据库:{},查询错误:({})'.format(db, 'd_city'))
continue
for city_info in city_list:
city_id = city_info.get('city_id')
guid = city_info.get('guid')
if not city_id or city_id in self.cityDict.keys():
continue
city_ = CityWeather(**city_info,publish_func=self.myPublish,username='******',appsecret='JRt7az1y',appid='37394325',base_url='https://www.tianqiapi.com')
self.cityDict[guid] = city_
else:
pass
def initSelfLabelDevice(self):
self.updating = True
self.labelDeviceDict = {}
data = {
'fields': ['mac',
'meeting_room_guid_id',
'size_type',
'use_type',
'barcode_id',
'template'
],
'eq': {
'is_delete': False,
'meeting_room_guid_id': self.guid
},
'sortInfo': [
{'update_time': ''},
]
}
data['database'] = 'aura'
msg = yield mysqlClient.tornadoSelectAll('d_label_device', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog('获取数据库:标签信息失败',company=self.company_name)
return
labelDeviceList = msg['msg']
for labelDeviceInfo in labelDeviceList:
labelDeviceMac = labelDeviceInfo['mac']
labelDeviceInfo['template'] = labelDeviceInfo.get('template','').split(',')
while '' in labelDeviceInfo['template']:
labelDeviceInfo['template'].remove('')
# 获取设备
self.labelDeviceDict[labelDeviceMac] = labelDeviceInfo
self.updating = False
def getChannelSyncDelay(self):
'''
默认值为0,如果不为0表示,对该通道的同步延时做了要求,需要按照要求同步
:return:
'''
for DATABASE in DATABASES:
db = DATABASE['name']
data = {
'database': db,
'fields': [
'guid',
'sync_delay',
],
'eq': {
'is_delete': False,
},
'neq': {
'sync_delay': 0
},
}
msg = yield mysqlClient.tornadoSelectAll('d_control_channel', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog('数据库{},查询失败:{}'.format(
db, 'd_control_channel'))
continue
self.sync_delay_dict = {
**self.sync_delay_dict,
**{x['guid']: x['sync_delay']
for x in msg['msg']}
}
def getAllocateChannelGuid(self):
self.allocate_channel_dict = {}
for DATABASE in DATABASES:
db = DATABASE['name']
# 获取通道分配信息
data = {
'database': db,
'fields': ['meeting_room_guid_id', 'control_channel_guid_id'],
'eq': {
'is_delete': False,
},
}
msg = yield mysqlClient.tornadoSelectAll('d_allocate_channel',
data)
if msg['ret'] == '0':
allocate_channel_list = msg['msg']
else:
yield logClient.tornadoErrorLog('数据库{}：查询错误:({})'.format(
db, 'd_allocate_channel'))
continue
for allocate_channel_info in allocate_channel_list:
meeting_room_guid = allocate_channel_info.get(
'meeting_room_guid_id')
allocate_channel_guid = allocate_channel_info.get(
'control_channel_guid_id')
if meeting_room_guid not in self.allocate_channel_dict.keys():
self.allocate_channel_dict[meeting_room_guid] = {}
self.allocate_channel_dict[meeting_room_guid][
allocate_channel_guid] = None
else:
self.allocate_channel_dict[meeting_room_guid][
allocate_channel_guid] = None
else:
pass
def sendToWebsocketClient(self, msg):
# print(msg)
try:
self.write_message(msg)
except Exception as e:
yield logClient.tornadoErrorLog(e)
return
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 updateLabelInfo(self,name,company_db,delayFlag=None,callback=None):
now_time = time.time()
brush_info = yield self.getSelfInfo()
if callback == None:
if brush_info == self.lastBrushInfo:
yield logClient.tornadoInfoLog('会议室:{},两次推送内容相同,取消推送'.format(name))
return
if now_time - self.lastBrushTime < 60:
yield logClient.tornadoInfoLog('会议室:{},两次推送间隔太短,启动延时推送'.format(name))
if self.waitBrushTask != None:
#有任务
yield logClient.tornadoDebugLog('会议室:{},存在相同任务,删除任务'.format(name))
self.ioloop.remove_timeout(self.waitBrushTask)
else:
yield logClient.tornadoDebugLog('会议室:{},无相同任务,添加任务'.format(name))
if callback == None:
self.waitBrushTask = self.ioloop.add_timeout(self.ioloop.time() + 60-int((now_time - self.lastBrushTime)), self.updateLabelInfo, name,company_db, delayFlag)
else:
self.waitBrushTask = self.ioloop.add_timeout(self.ioloop.time() + 60-int((now_time - self.lastBrushTime)), self.updateLabelInfo, name,company_db, delayFlag, callback)
return None
self.lastBrushTime = now_time
self.waitBrushTask = None
yield self.checkSelfLabelTemplate(name)
fault_count = 0
while True:
result = yield self.brushSelfInfo(brush_info)
if result == True:
yield logClient.tornadoInfoLog('会议室:{},{}推送商品成功'.format(name,'延时' if delayFlag else ''))
yield self.keepNowBrushInfo(brush_info)
yield self.storageSelf(company_db)
yield self.printNowBrushInfo(brush_info)
break
elif result == 501:
yield logClient.tornadoErrorLog('会议室:{},推送商品token失效'.format(name))
yield self.eslCloudClient.tokenError()
else:
yield logClient.tornadoErrorLog('会议室:{},{}推送商品失败'.format(name,'延时' if delayFlag else ''))
yield gen.sleep(10)
fault_count += 1
if fault_count >= 10:
break
def sendToService(self, msg):
if self.connectionObject:
try:
self.connectionObject.write_message(msg)
except Exception as e:
self.sendDataBuffer.append(msg)
self.connectionObject = None
yield logClient.tornadoErrorLog(str(e))
else:
self.sendDataBuffer.append(msg)
if self.waitSendDataTask == None:
self.ioloop.add_timeout(self.ioloop.time(),self.sendDataBufferData)
def handle_message(self):
try:
while self.mosquittoReceiveBuffer:
try:
msg = self.mosquittoReceiveBuffer.pop(0)
except:
return
topic = msg.get('topic')
topic_list = msg.get('topic_list')
control_event = msg.get('data')
data = {
'type': 'control',
'topic': topic,
'topic_list': topic_list,
'control_event': control_event
}
meeting_room_guid = topic_list[1]
type_ = topic_list[5]
if type_ == 'command':
channel = topic_list[7]
if channel == 'macro':
#计算macro信息
try:
macro_info = json.loads(control_event)
except:
macro_info = []
yield self.updateMeetingRoomMacro(
meeting_room_guid, macro_info)
data = {
'type': 'sync_device',
'meeting_room_guid': meeting_room_guid
}
yield logClient.tornadoDebugLog(json_dumps(data))
for websocketObject in self.websocketObject.clientObjectSet:
if meeting_room_guid in websocketObject.meeting_room_list:
websocketObject.sendToClientService(
json_dumps(data))
else:
yield logClient.tornadoDebugLog(json_dumps(data))
if topic_list[5] == 'macro':
yield self.macroControlHandle(meeting_room_guid, topic,
topic_list,
control_event)
else:
yield self.transmitControlComand(
meeting_room_guid, data)
except Exception as e:
yield logClient.tornadoErrorLog(str(e))
self.handle_message_task = None
def checkSelfLabelTemplate(self,name):
for mac,mac_template_info in self.bindingDict.items():
new_template_id = mac_template_info.get('new_template_id')
now_template_id = mac_template_info.get('now_template_id')
fault_count = 0
if new_template_id != now_template_id:
while True:
result = yield self.updateLabelTemplate(mac, new_template_id)
if result == True:
self.bindingDict[mac]['now_template_id'] = new_template_id
yield logClient.tornadoInfoLog('会议室：{},标签:{},更新模板:{},成功'.format(name, mac, new_template_id))
break
elif result == 501:
yield self.eslCloudClient.tokenError()
yield logClient.tornadoErrorLog('会议室：{},更新模板:token失效'.format(name))
else:
yield logClient.tornadoErrorLog('会议室：{},标签:{},更新模板:{},失败'.format(name, mac, new_template_id))
yield gen.sleep(10)
fault_count += 1
if fault_count >= 10:
break
else:
yield gen.sleep(30)
def storgeSelfScheduleWrokTime(self, time: int = None):
data = {
'database': self.companyDb,
'fields': ['total_work_hour'],
'eq': {
'guid': self.guid,
}
}
msg = yield mysqlClient.tornadoSelectOne('d_meeting_room', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_meeting_room'))
meeting_room_info = msg['msg']
if meeting_room_info == None:
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_meeting_room'))
last_total_work_hour = meeting_room_info.get('total_work_hour')
try:
time = int(time)
except:
return
new_total_work_hour = last_total_work_hour + time
data = {
'database': self.companyDb,
'msg': {
'update_time': datetime.datetime.now(),
'total_work_hour': new_total_work_hour,
'is_delete': False,
},
'eq': {
'guid': self.guid,
}
}
msg = yield mysqlClient.tornadoUpdateMany('d_meeting_room', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库更新失败:{}'.format('d_meeting_room'))
def overSchedule(self, schedule_guid):
data = {
'database': self.companyDb,
'msg': {
'update_time': datetime.datetime.now(),
'stop_time': datetime.datetime.now(),
},
'eq': {
'guid': schedule_guid,
}
}
msg = mysqlClient.updateMany('schedule', data)
if msg['ret'] == '0':
pass
else:
yield logClient.tornadoErrorLog('删除记录失败:{}'.format('schedule'))
def storgeSelfScheduleStatus(self, new_status):
# 更新数据库排程状态
data = {
'database': self.companyDb,
'msg': {
'update_time': datetime.datetime.now(),
'status_group_guid_id': new_status,
'is_delete': False,
},
'eq': {
'guid': self.guid,
}
}
msg = yield mysqlClient.tornadoUpdateMany('d_meeting_room', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库更新失败:{}'.format('d_meeting_room'))
def sendDataBufferData(self):
if self.connectionObject:
while True:
try:
msg = self.sendDataBuffer.pop(0)
except:
self.waitSendDataTask = None
break
try:
self.connectionObject.write_message(msg)
except Exception as e:
self.sendDataBuffer.append(msg)
self.connectionObject = None
yield logClient.tornadoErrorLog(str(e))
self.waitSendDataTask = None
else:
self.ioloop.add_timeout(self.ioloop.time()+1, self.sendDataBufferData)
def updateSelfSchedule(self):
self.scheduleList = []
now_time = datetime.datetime.now()
compare_year = now_time.year
compare_month = now_time.month
compare_day = now_time.day
data = {
'database':
self.companyDb,
'fields': [
'guid', 'room_guid_id', 'title', 'schedule.start_time',
'schedule.stop_time', 'sender', 'member', 'event_id'
],
'eq': {
'is_delete': False,
'room_guid_id': self.guid
},
# 筛选出已结束会议排程,或刚刚结束的会议排程
'gte': {
'start_time':
datetime.datetime(compare_year, compare_month, compare_day, 0,
0, 0)
},
# 筛选出当天会议排除
'lt': {
'start_time':
datetime.datetime(compare_year, compare_month, compare_day, 23,
59, 59)
},
'sortInfo': [
# {'room_guid_id': 'ASC'},
{
'start_time': 'ASC'
},
],
}
msg = yield mysqlClient.tornadoSelectAll('schedule', data)
if msg['ret'] == '0':
for schedule_info in msg.get('msg'):
schedule_object = Schedule(**schedule_info)
self.scheduleList.append(schedule_object)
else:
yield logClient.tornadoErrorLog('获取数据库:排程信息失败')
def updateAllMeetingRoom(self):
'''获取所有的会议室'''
#todo:首先获取所有的商品
yield self.updateGoods()
#todo:然后获取取所有的会议室
for DATABASE in DATABASES:
db = DATABASE['name']
data = {
'database':
db,
'fields': [
'd_meeting_room.guid', 'd_meeting_room.room_name',
'd_meeting_room.sin_minute',
'd_meeting_room.status_group_guid_id as schedule_status',
'd_company.name as company_name'
],
'eq': {
'd_meeting_room.is_delete': False,
'd_company.is_delete': False,
'd_meeting_room.company_guid_id': {
'key': 'd_company.guid'
}
},
}
msg = yield mysqlClient.tornadoSelectAll(
'd_meeting_room,d_company', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog('获取数据库:会议室信息失败')
break
meeting_rooms = msg['msg']
for meeting_room in meeting_rooms:
# 把每一个会议室转换为会议室对象
meeting_room_ = MeetingRoom(company_db=db,
ioloop=self.ioloop,
mqttClient=self.connectObject,
eslCloudClient=self.eslCloudClient,
goods_dict=self.goods_dict,
**meeting_room)
self.meeting_room_list.append(meeting_room_)
# 添加会议室guid和mqtt_name的转换对象
self.GuidToMeetingRoom[meeting_room_.guid] = meeting_room_
else:
yield logClient.tornadoInfoLog('公司：{}会议室初始化完成'.format(db))
def updateCallback(self):
url = self.updateCallbackUrl
body = {'pushUrl': CALLBACK_ADDRESS}
self.headers = {
'content-type': 'application/json',
'Authorization': 'Bearer ' + self.token
}
while True:
result = yield asyncTornadoRequest(url,
method='POST',
headers=self.headers,
params=body,
allow_nonstandard_methods=True)
if result.get('status') == '200' or result.get('status') == 200:
yield logClient.tornadoInfoLog('设定回调地址成功')
return
else:
yield logClient.tornadoErrorLog('设定回调地址失败')
yield self.tokenError()
yield gen.sleep(10)
def mysqlStorage(self, table, info, time=None):
data = {
'database': self.company_db,
'msg': {
'create_time': datetime.datetime.now(),
'update_time': datetime.datetime.now(),
'is_delete': False,
'guid': uuid.uuid1().urn.split(':')[2],
'device_guid_id': self.guid,
}
}
data['msg'] = {**data['msg'], **info}
if time:
data['msg']['create_time'] = time
data['msg']['update_time'] = time
msg = yield mysqlClient.tornadoInsertOne(table, data)
if msg['ret'] == '0':
pass
else:
yield logClient.tornadoErrorLog('数据库插入错误:{}'.format(table))
def getChnnelGuid(self, db, meeting_room_guid, port, channel):
data = {
'database': db,
'fields': ['guid'],
'eq': {
'is_delete': False,
'meeting_room_guid_id': meeting_room_guid,
'port': port,
'channel': channel,
}
}
msg = yield mysqlClient.tornadoSelectOne('d_control_channel', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_control_channel'))
return False
channel_guid = msg['msg'].get('guid')
if channel_guid == None:
return False
return channel_guid
def brushLed(self,mac:str,color:int,total:int=1500,period:int=500,interval:int=1000,brigthness:int=5):
if color == 0:
real_color = 2
elif color == 1:
real_color = 1
elif color == 2:
real_color = 3
else:
real_color = 2
STATUS_TO_NAME = {
0: '空闲中',
1: '准备中',
2: '进行中',
}
yield logClient.tornadoInfoLog('{}:状态切换为{}'.format(self.name, STATUS_TO_NAME[color]),company=self.company_name)
headers = {
'content-type': 'application/json',
'Authorization': 'Bearer ' + self.eslCloudClient.token
}
data = {
'storeUuid': self.eslCloudClient.storeCode,
'mac': mac,
'color': real_color,
'total': total,
'period': period,
'interval': interval,
'brigthness': brigthness,
}
url = self.eslCloudClient.controlLedUrl
result = yield asyncTornadoRequest(url, method='PUT', headers=headers, params=data, body=data)
yield logClient.tornadoInfoLog('会议室:{},led控制推送结果:{}'.format(self.name,result),company=self.company_name)
status = result.get('status')
if status == 200:
self.schedule_status = color
return True
else:
yield logClient.tornadoErrorLog('{}的led推送失败'.format(self.name),company=self.company_name)
yield self.eslCloudClient.tokenError()
self.ioloop.add_timeout(self.ioloop.time() + 60, self.brushLed, mac, color)
return False
def updateMacroStatus(self, meeting_room_guid):
macro_list = self.macro_dict.get(meeting_room_guid)
if macro_list == None:
return
for macro_info in macro_list:
feedbackCondition = macro_info.get('feedbackCondition')
try:
result = eval(feedbackCondition)
except Exception as e:
yield logClient.tornadoErrorLog(str(e))
result = False
if result == True:
new_status = 'on'
else:
new_status = 'off'
if new_status != macro_info.get('status'):
macro_info['status'] = new_status
feedback = macro_info.get('feedback')
port = macro_info.get('port')
channel = macro_info.get('channel')
topic = '/aaiot/{}/receive/controlbus/event/{}/{}/{}'.format(
meeting_room_guid, feedback, port, channel)
yield self.my_publish(topic=topic, payload=new_status)
pass
def initAllMeetingRoom(self):
'''获取所有的会议室,更新全局变量meeting_room_list'''
yield self.getAllocateChannelGuid()
# 获取所有的会议室
for DATABASE in DATABASES:
db = DATABASE['name']
# 获取公司名称
if db == 'aura':
db_name = 'default'
else:
db_name = db
data = {
'database': db,
# 'database':'aura',
'fields': ['name'],
'eq': {
'database_name': db_name,
}
}
msg = yield mysqlClient.tornadoSelectOnly('d_company', data)
if msg['ret'] == '0' and msg['lenght'] == 1:
company_name = msg['msg'][0]['name']
else:
yield logClient.tornadoErrorLog('数据库:{},查询错误:({})'.format(
db, 'd_company'))
continue
data = {
'database':
db,
'fields': [
'guid',
'room_name',
'status_group_guid_id as schedule_status',
],
'eq': {
'is_delete': False,
# 'guid':'ec5eadb8-9744-11e9-922b-5254002d0365',
'virtual_guid': '',
},
}
msg = yield mysqlClient.tornadoSelectAll('d_meeting_room', data)
if msg['ret'] == '0':
meeting_rooms = msg['msg']
else:
yield logClient.tornadoErrorLog(
'数据库查询错误:({})'.format('d_meeting_room'))
continue
for meeting_room in meeting_rooms:
meeting_room['company_name'] = company_name
# 把每一个会议室转换为会议室对象
meeting_room_ = MeetingRoom(db,
mosquitto_object=self,
**meeting_room)
self.meeting_room_list.append(meeting_room_)
# 添加会议室guid和mqtt_name的转换对象
self.GuidToMeetingRoom[meeting_room_.guid] = meeting_room_
# 获取虚拟会议室
data = {
'database':
db,
'fields': [
'guid',
'room_name',
'status_group_guid_id as schedule_status',
],
'eq': {
'is_delete': False,
'virtual_guid': 'virtual',
},
}
msg = yield mysqlClient.tornadoSelectAll('d_meeting_room', data)
if msg['ret'] == '0':
meeting_rooms = msg['msg']
else:
yield logClient.tornadoErrorLog(
'数据库查询错误:({})'.format('d_meeting_room'))
continue
for meeting_room in meeting_rooms:
meeting_room['company_db'] = db
meeting_room['company_name'] = company_name
virtual_meeting_room_guid = meeting_room.get('guid')
# 获取虚拟会议室下的会议室
data = {
'database': db,
'fields': [
'guid',
'real_meeting_room_guid_id',
],
'eq': {
'is_delete': False,
'virtual_meeting_room_guid_id':
virtual_meeting_room_guid,
},
}
msg = yield mysqlClient.tornadoSelectAll(
'd_virtual_meeting_room', data)
if msg['ret'] == '0':
meeting_room['real_meeting_room_guid_list'] = [
x['real_meeting_room_guid_id'] for x in msg['msg']
]
else:
yield logClient.tornadoErrorLog(
'数据库查询错误:({})'.format('d_meeting_room'))
meeting_room['real_meeting_room_guid_list'] = []
self.virtual_meeting_room_list.append(meeting_room)
self.GuidToVirtualMeetingRoom[
virtual_meeting_room_guid] = meeting_room
# 获取分房会议室
'''
分房会议室结构：
self.separate_meeting_room_list = [
{
'real_meeting_room_guid':
'separate_mode':0/1,
'meeting_room_info':[
{
'guid':'',
'room_name':'',
'schedule_status':'',
'company':'',
'company_name':'',
}
]
}
]
'''
for meeting_room_object in self.meeting_room_list:
real_meeting_room_guid = meeting_room_object.guid
company_db = meeting_room_object.company_db
data = {
'database': company_db,
'fields': ['separate_meeting_room_guid_id'],
'eq': {
'real_meeting_room_guid_id': real_meeting_room_guid,
'is_delete': False
}
}
msg = yield mysqlClient.tornadoSelectAll('d_separate_meeting_room',
data)
if msg['ret'] == '0':
separete_meeting_room_guid_list = [
x['separate_meeting_room_guid_id'] for x in msg['msg']
]
else:
yield logClient.tornadoErrorLog(
'数据库查询错误:({})'.format('d_meeting_room'))
continue
if separete_meeting_room_guid_list == []:
continue
separete_group_info = {}
separete_group_info[
'real_meeting_room_guid'] = real_meeting_room_guid
separete_group_info['separate_mode'] = 0
separete_group_info['meeting_room_info'] = []
for separete_meeting_room_guid in separete_meeting_room_guid_list:
data = {
'database':
company_db,
'fields': [
'guid',
'room_name',
'status_group_guid_id as schedule_status',
],
'eq': {
'is_delete': False,
'virtual_guid': 'separate',
'guid': separete_meeting_room_guid,
},
}
msg = yield mysqlClient.tornadoSelectOnly(
'd_meeting_room', data)
if msg['ret'] == '0' and msg['lenght'] == 1:
separete_info = msg['msg'][0]
separete_info['company_db'] = company_db
else:
continue
separete_group_info['meeting_room_info'].append(separete_info)
self.separate_meeting_room_list.append(separete_group_info)
else:
pass
