def userRightsMeetingRoom(self, user_id, company_db):
meeting_room_guid_list = []
# 获取用户所在群组
data = {
'database': company_db,
'fields': ['group_guid_id'],
'eq': {
'is_delete': False,
'user_guid_id': user_id
},
}
msg = yield mysqlClient.tornadoSelectAll('d_user_group', data)
groups = []
if msg['ret'] == '0':
groups = msg['msg']
else:
return meeting_room_guid_list
for group in groups:
# 获取群组下所有会议室
data = {
'database': company_db,
'fields': [
'd_meeting_room_group.meeting_room_guid_id',
'd_meeting_room.room_name'],
'eq': {
'd_meeting_room_group.is_delete': False,
'd_meeting_room.is_delete': False,
'd_meeting_room.guid': {'key': 'd_meeting_room_group.meeting_room_guid_id'},
'd_meeting_room_group.group_guid_id': group['group_guid_id']
},
}
msg = yield mysqlClient.tornadoSelectAll('d_meeting_room_group,d_meeting_room', data)
if msg['ret'] == '0':
meeting_room_guid_list += msg['msg']
return meeting_room_guid_list
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 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 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 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 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 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 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 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 allMeetingRoom(self, company_db):
# 获取所有会议室
data = {
'database': company_db,
'fields': ['guid as meeting_room_guid_id', 'room_name'],
'eq': {
'is_delete': False,
'virtual_guid': '',
},
}
msg = yield mysqlClient.tornadoSelectAll('d_meeting_room', data)
if msg['ret'] == '0':
return msg['msg']
else:
return []
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 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 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
def getMacroBackMessage(self):
'''
前端控制子通道时,可以提前得到聚集通道的状态
self.macro_back_dict
数据结构
{
'聚集通道guid'[
[{
'channel_guid':'子通道guid',
'target_status':'目标状态',
'now_status':'当前状态'
},
{...}],
[{
'channel_guid':'子通道guid',
'target_status':'目标状态',
'now_status':'当前状态'
},
{...}],
...
],
...
}
'''
for DATABASE in DATABASES:
db = DATABASE['name']
data = {
'database': db,
'fields': [
'macro_channel_guid_id',
'macro_message',
],
'eq': {
'is_delete': False,
},
}
msg = yield mysqlClient.tornadoSelectAll('d_macro_back', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_macro_back'))
return
macro_back_list = msg['msg']
for macro_back_info in macro_back_list:
macro_channel_guid = macro_back_info.get(
'macro_channel_guid_id')
macro_message = macro_back_info.get('macro_message')
#获取聚集通道所在会议室
data = {
'database': db,
'fields': ['meeting_room_guid_id'],
'eq': {
'is_delete': False,
'guid': macro_channel_guid,
}
}
msg = yield mysqlClient.tornadoSelectOne(
'd_control_channel', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog(
'数据库查询失败:{}'.format('d_control_channel'))
continue
channel_info = msg['msg']
if channel_info == None:
continue
self.macro_back_dict[macro_channel_guid] = []
macro_message = macro_message.replace('(', '')
macro_message = macro_message.replace(')', '')
meeting_room_guid = msg['msg'].get('meeting_room_guid_id')
or_relation_list = macro_message.split(' or ')
for or_relation in or_relation_list:
and_relation = or_relation.split(' and ')
and_ = []
for and_info in and_relation:
and_info_list = and_info.split(' == ')
r = re.findall('channel\[(.+?)\]\[(.+?)\]',
and_info_list[0])
if r == []:
r = re.findall('level\[(.+?)\]\[(.+?)\]',
and_info_list[0])
port = int(r[0][0])
channel = int(r[0][1])
try:
value = eval(and_info_list[1])
except:
value = and_info_list[1]
channel_guid = yield self.getChnnelGuid(
db, meeting_room_guid, port, channel)
if channel_guid == False:
continue
info = {
'channel_guid': channel_guid,
'target_status': value,
'now_status': None
}
and_.append(info)
self.macro_back_dict[macro_channel_guid].append(and_)
def getMacroSyncChannel(self):
'''
控制聚集通道时,可以提前知道子通道的状态
self.
数据结构 {
‘聚集通道guid’:{
'聚集通道的状态(on)':[
{
‘sync_channel_guid’:'子通道guid'
''sync_channel_status:‘子通道状态’
},{}
]
}
}
'''
for DATABASE in DATABASES:
db = DATABASE['name']
data = {
'database':
db,
'fields': [
'd_sync_channel.control_channel_guid_id',
'd_sync_channel.control_channel_status',
'd_sync_channel.sync_channel_guid_id',
'd_sync_channel.sync_channel_status',
'd_control_channel.meeting_room_guid_id',
],
'eq': {
'd_sync_channel.is_delete': False,
'd_sync_channel.sync_channel_guid_id': {
'key': 'd_control_channel.guid'
}
},
}
msg = yield mysqlClient.tornadoSelectAll(
'd_sync_channel,d_control_channel', data)
if msg['ret'] != '0':
yield logClient.tornadoErrorLog('数据库:{},查询失败:{}'.format(
db, 'd_macro_sync_channel'))
continue
macro_sync_channel_list = msg['msg']
for macro_sync_channel in macro_sync_channel_list:
control_channel_guid = macro_sync_channel[
'control_channel_guid_id']
control_channel_status = macro_sync_channel[
'control_channel_status']
sync_channel_guid = macro_sync_channel['sync_channel_guid_id']
sync_channel_status = macro_sync_channel['sync_channel_status']
meeting_room_guid = macro_sync_channel['meeting_room_guid_id']
info = {
'sync_channel_guid': sync_channel_guid,
'sync_channel_status': sync_channel_status,
'meeting_room_guid': meeting_room_guid,
}
if control_channel_guid not in self.sync_channel_dict.keys():
self.sync_channel_dict[control_channel_guid] = {
control_channel_status: [info]
}
else:
if control_channel_status not in self.sync_channel_dict[
control_channel_guid].keys():
self.sync_channel_dict[control_channel_guid][
control_channel_status] = [info]
else:
self.sync_channel_dict[control_channel_guid][
control_channel_status].append(info)
else:
pass
def getSeparateInfo(self, meeting_room_guid, company_db):
# 判断传入会议室guid是实体会议室还是分房会议室
data = {
'database': company_db,
'fields': ['virtual_guid'],
'eq': {
'is_delete': False,
'guid': meeting_room_guid,
}
}
msg = yield mysqlClient.tornadoSelectOnly('d_meeting_room', data)
if msg['ret'] == '0' and msg['lenght'] == 1:
virtual_guid = msg['msg'][0]['virtual_guid']
else:
return False
if virtual_guid == '':
# 实体会议室
real_meeting_room_guid_list = [meeting_room_guid]
elif virtual_guid == 'separate':
# 获取分房会议室所在的实体会议室
data = {
'database': company_db,
'fields': ['real_meeting_room_guid_id'],
'eq': {
'is_delete': False,
'separate_meeting_room_guid_id': meeting_room_guid
},
}
msg = yield mysqlClient.tornadoSelectAll('d_separate_meeting_room', data)
if msg['ret'] == '0':
real_meeting_room_guid_list = [x['real_meeting_room_guid_id'] for x in msg['msg']]
else:
return False
else:
return False
separate_info_list = []
for real_meeting_room_guid in real_meeting_room_guid_list:
data = {
'database': company_db,
'fields': ['guid as real_meeting_room_guid_id', 'room_name'],
'eq': {
'guid': real_meeting_room_guid
}
}
msg = yield mysqlClient.tornadoSelectAll('d_meeting_room', data)
if msg['ret'] == '0':
separate_info_list += msg['msg']
else:
return False
# 分房会议室
data = {
'database': company_db,
'fields': ['d_separate_meeting_room.separate_meeting_room_guid_id',
'd_meeting_room.room_name'],
'eq': {
'd_separate_meeting_room.is_delete': False,
'd_meeting_room.is_delete': False,
'd_separate_meeting_room.separate_meeting_room_guid_id': {'key': 'd_meeting_room.guid'},
'real_meeting_room_guid_id': real_meeting_room_guid
},
}
# 获取所有会议室
msg = yield mysqlClient.tornadoSelectAll('d_separate_meeting_room,d_meeting_room', data)
if msg['ret'] == '0':
separate_info_list += msg['msg']
else:
return False
return separate_info_list
