def __init__(self, **opts):
opts['type'] = 'group'
opts['addText'] = "Add"
opts['addList'] = []
for seting in settings_r():
opts['addList'].append(seting)
#opts['addList'] = ['str', 'float', 'int']
pTypes.GroupParameter.__init__(self, **opts)
def update(self):
if self.tabWidget.currentIndex() ==6:
self.add_wecker()
settings = settings_r()
for btn in self.buttons:
name = btn.objectName()
if str(name) in settings:
print name, settings.get(str(name))
btn.setText(settings.get(str(name)))
QApplication.processEvents()
def update_values(self):
try:
settings = settings_r()
self.lbl.setText(self.checkWecker())
for btn in self.buttons:
name = btn.objectName()
if str(name) in settings:
btn.setText(settings.get(str(name)))
QApplication.processEvents()
except:
pass
refresh = Timer(5, self.update_values, [])
if running:
refresh.start()
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(700, 500)
settings = settings_r()
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.tabWidget = QtGui.QTabWidget(self.centralwidget)
self.tabWidget.setGeometry(QtCore.QRect(0, 0, 800, 500))
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.tabWidget.setStyleSheet("QTabBar::tab { height: 50px;}")
# Keller
self.tab_0 = QtGui.QWidget()
#self.tab_0.setStyleSheet("QWidget {background-image:url(./EG.png)}")
self.tab_0.setObjectName(_fromUtf8("Keller"))
self.tabWidget.addTab(self.tab_0, _fromUtf8(""))
#Erdgeschoss
self.tab = QtGui.QWidget()
self.tab.setStyleSheet("background-image:url(./EG.png)")
self.tab.setObjectName(_fromUtf8("Erdgeschoss"))
self.buttons = []
for btn in eg_buttons:
self.buttons.append(QtGui.QPushButton(self.tab))
self.buttons[-1].setGeometry(QtCore.QRect(btn.get('pos_x'), btn.get('pos_y'), 50, 50))
self.buttons[-1].setObjectName(btn.get('Name'))
self.buttons[-1].setStyleSheet("background-image:url(./EG3.png);background-color: rgb(255,255,255);border: 2px solid #222222")
if btn.get('type') == 'dev':
self.buttons[-1].clicked.connect(self.make_set_popup(btn.get('Name')))
self.buttons[-1].setText(_fromUtf8(btn.get('desc')))
elif btn.get('type') == 'sens':
self.buttons[-1].clicked.connect(self.make_set_g_popup(btn.get('Name')))
self.buttons[-1].setText(settings.get(btn.get('Name')))
self.tabWidget.addTab(self.tab, _fromUtf8(""))
#1. Stock
self.tab_1 = QtGui.QWidget()
self.tab_1.setStyleSheet("QWidget {background-image:url(./OG.png)}")
self.tab_1.setObjectName(_fromUtf8("1_Stock"))
for btn in og_buttons:
self.buttons.append(QtGui.QPushButton(self.tab_1))
self.buttons[-1].setGeometry(QtCore.QRect(btn.get('pos_x'), btn.get('pos_y'), 50, 50))
self.buttons[-1].setObjectName(btn.get('Name'))
if btn.get('type') == 'dev':
self.buttons[-1].clicked.connect(self.make_set_popup(btn.get('Name')))
self.buttons[-1].setText(_fromUtf8(btn.get('desc')))
elif btn.get('type') == 'sens':
self.buttons[-1].clicked.connect(self.make_set_g_popup(btn.get('Name')))
self.buttons[-1].setText(settings.get(btn.get('Name')))
self.tabWidget.addTab(self.tab_1, _fromUtf8(""))
#2. Stock
self.tab_2 = QtGui.QWidget()
#self.tab_2.setStyleSheet("QWidget {background-image:url(./EG.png)}")
self.tab_2.setObjectName(_fromUtf8("2_Stock"))
self.tabWidget.addTab(self.tab_2, _fromUtf8(""))
#Direkt
self.tab_3 = QtGui.QWidget()
self.tab_3.setObjectName(_fromUtf8("tab_3"))
for btn in self.set_buttons:
self.buttons.append(QtGui.QPushButton(self.tab_3))
self.buttons[-1].setGeometry(QtCore.QRect(btn.get('pos_x'), btn.get('pos_y'), 91, 24))
self.buttons[-1].setObjectName(btn.get('Name'))
if btn.get('type') == 'dev':
self.buttons[-1].clicked.connect(self.make_set_popup(btn.get('Name')))
self.buttons[-1].setText(_fromUtf8(btn.get('desc')))
elif btn.get('type') == 'sens':
self.buttons[-1].clicked.connect(self.make_set_g_popup(btn.get('Name')))
self.buttons[-1].setText(settings.get(btn.get('Name')))
elif btn.get('type') == 'int':
self.buttons[-1].clicked.connect(btn.get('command'))
self.buttons[-1].setText(_fromUtf8(btn.get('desc')))
self.pushButton_2 = QtGui.QPushButton(self.tab_3)
self.pushButton_2.setGeometry(QtCore.QRect(0, 40, 91, 24))
self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))
self.pushButton_2.clicked.connect(self.hue_clicked)
self.pushButton_3 = QtGui.QPushButton(self.tab_3)
self.pushButton_3.setGeometry(QtCore.QRect(100, 10, 91, 24))
self.pushButton_3.setObjectName(_fromUtf8("pushButton_3"))
self.pushButton_3.clicked.connect(self.sns_clicked)
self.pushButton_4 = QtGui.QPushButton(self.tab_3)
self.pushButton_4.setGeometry(QtCore.QRect(100, 40, 91, 24))
self.pushButton_4.setObjectName(_fromUtf8("pushButton_4"))
self.pushButton_4.clicked.connect(self.tvs_clicked)
self.pushButton_5 = QtGui.QPushButton(self.tab_3)
self.pushButton_5.setGeometry(QtCore.QRect(200, 10, 91, 24))
self.pushButton_5.setObjectName(_fromUtf8("pushButton_5"))
self.pushButton_5.clicked.connect(self.sat_clicked)
self.scrollLayout = QtGui.QFormLayout()
self.scrollArea = QtGui.QScrollArea(self.tab_3)
self.scrollArea.setGeometry(QtCore.QRect(10, 70, 250, 350))
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName(_fromUtf8("scrollArea"))
self.scrollAreaWidgetContents = QtGui.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 0, 360))
self.scrollAreaWidgetContents.setObjectName(_fromUtf8("scrollAreaWidgetContents"))
self.scrollAreaWidgetContents.setLayout(self.scrollLayout)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.scrollLayout2 = QtGui.QFormLayout()
self.scrollArea2 = QtGui.QScrollArea(self.tab_3)
self.scrollArea2.setGeometry(QtCore.QRect(260, 70, 250, 350))
self.scrollArea2.setWidgetResizable(True)
self.scrollArea2.setObjectName(_fromUtf8("scrollArea2"))
self.scrollAreaWidgetContents2 = QtGui.QWidget()
self.scrollAreaWidgetContents2.setGeometry(QtCore.QRect(0, 0, 165, 360))
self.scrollAreaWidgetContents2.setObjectName(_fromUtf8("scrollAreaWidgetContents2"))
self.scrollAreaWidgetContents2.setLayout(self.scrollLayout2)
self.scrollArea2.setWidget(self.scrollAreaWidgetContents2)
self.xs1_clicked()
self.fill_szenen_favs()
self.tabWidget.addTab(self.tab_3, _fromUtf8(""))
#Settings
self.tab_4 = QtGui.QWidget()
self.tab_4.setObjectName(_fromUtf8("tab_4"))
self.pushButton_6 = QtGui.QPushButton(self.tab_4)
self.pushButton_6.setGeometry(QtCore.QRect(0, 10, 100, 50))
self.pushButton_6.setObjectName(_fromUtf8("gitupdate"))
self.pushButton_6.clicked.connect(self.git_update)
self.pushButton_7 = QtGui.QPushButton(self.tab_4)
self.pushButton_7.setGeometry(QtCore.QRect(0, 110, 100, 50))
self.pushButton_7.setObjectName(_fromUtf8("gitupdate"))
self.pushButton_7.setText('Update')
self.pushButton_7.clicked.connect(self.update_values)
self.pushButton_8 = QtGui.QPushButton(self.tab_4)
self.pushButton_8.setGeometry(QtCore.QRect(160, 10, 100, 50))
self.pushButton_8.setObjectName(_fromUtf8("AEs"))
self.pushButton_8.setText('AlarmEvents')
self.pushButton_8.clicked.connect(self.showAlarmEvents)
self.pushButton_9 = QtGui.QPushButton(self.tab_4)
self.pushButton_9.setGeometry(QtCore.QRect(160, 110, 100, 50))
self.pushButton_9.setObjectName(_fromUtf8("Close"))
self.pushButton_9.setText('Close')
self.pushButton_9.clicked.connect(self.close)
self.tabWidget.addTab(self.tab_4, _fromUtf8(""))
#Wecker
self.tab_5 = QtGui.QWidget()
self.tab_5.setObjectName(_fromUtf8("tab_5"))
self.tabWidget.addTab(self.tab_5, _fromUtf8(""))
self.scrollLayout3 = QtGui.QFormLayout()
self.scrollArea = QtGui.QScrollArea(self.tab_5)
self.scrollArea.setGeometry(QtCore.QRect(0, 0, 790, 375))
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName(_fromUtf8("scrollArea"))
self.scrollAreaWidgetContents = QtGui.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 165, 360))
self.scrollAreaWidgetContents.setObjectName(_fromUtf8("scrollAreaWidgetContents"))
self.scrollAreaWidgetContents.setLayout(self.scrollLayout3)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.lbl = QtGui.QLabel(self.tab_5)
self.lbl.setText(self.checkWecker())
self.lbl.setGeometry(QtCore.QRect(120, 380, 500, 50))
#self.add_wecker()
self.pushButton_9 = QtGui.QPushButton(self.tab_5)
self.pushButton_9.setGeometry(QtCore.QRect(10, 380, 91, 50))
self.pushButton_9.setObjectName(_fromUtf8("saveAlarm"))
self.pushButton_9.setText('Speichere')
self.pushButton_9.clicked.connect(self.makeSaveWecker(self))
# self.pushButton_10 = QtGui.QPushButton(self.tab_5)
# self.pushButton_10.setGeometry(QtCore.QRect(320, 380, 91, 50))
# self.pushButton_10.setObjectName(_fromUtf8("chekAlarm"))
# self.pushButton_10.setText('Check')
# self.pushButton_10.clicked.connect(self.checkWecker)
self.tab_5.connect(self.tabWidget, SIGNAL('currentChanged(int)'), self.update)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
self.menubar.setObjectName(_fromUtf8("menubar"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(1)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
refresh = Timer(5, self.update_values, [])
refresh.start()
def add_bedingung(self):
global p
self.p.param(self.name, 'Bedingung').addChild({'name': 'Bedingung ','type': 'group', 'children':[{'name': 'Setting', 'type': 'list','values':sorted(settings_r()), 'value': ''},
{'name': 'Operand', 'type': 'list', 'values':['==','=','<','>','<=','>=','in','!'], 'value': ''},{'name': 'Bedingung', 'type': 'str', 'value': ''}]}, autoIncrementName=True)
def set_paratree(self):
global p, name
#szenen = mdb_get_table(db='set_Szenen')
tipps = mdb_read_table_entry(db='set_Szenen',entry='Description')
stock_list = []
stockwerke = []
zimmer_list = []
zimmer = []
for szene in self.szenen:
for item in szene:
if str(item) in cmd_devs:
name = str(item)
stock_list.append(name[0:3])
zimmer_list.append(name[0:6])
stock_list = list(set(stock_list))
zimmer_list = list(set(zimmer_list))
for stock in stock_list:
stockwerke.append(StockRaum(stock))
for zim in zimmer_list:
zimmer.append(StockRaum(zim))
params = []
for szene in self.szenen:
if szene.get('Name') == 'LeereVorlage' or self.neue_szene:
szene['Name']= 'NeueSzene'
szene['Id'] = maxSzenenId()-maxSzenenId()%10 +10
self.neue_szene = False
szn_dict = {}
if str(szene.get('Beschreibung')) <> 'None':
self.name = szene.get('Beschreibung')
else:
self.name = 'Szenen Name: '+str(szene.get('Name'))
szn_dict['name'] = self.name
szn_dict['type']='group'
szn_dict['expanded'] = True
szn_l_child = []
#del szene['Name']
for item in szene:
szn_d_child = {}
szn_d_child_l = []
if str(item) in cmd_devs:
zwname = szenen_beschreibung.get(item)
if zwname == None:
zwname = str(item)
kom_group = KommandoGroup(name=str(item), title = zwname,cmds=self.get_commando_set(str(item)), children=self.dict_constructor_(str(item),self.__return_enum__(szene.get(item))))
for zim in zimmer:
if zim.name in str(item):
zim.addChild(kom_group)
if kom_group.shouldExpand():
zim.expand(True)
#Stockwerke auch expandieren
elif str(item) in ['Setting']:
for child in self.__return_enum__(szene.get(item)):
if type(self.__return_enum__(szene.get(item))) == dict:
szn_d_child_l.append({'name': child, 'type': 'str', 'value': self.__return_enum__(szene.get(item)).get(child)})
szn_d_child = ScalableGroup(name= item, children= szn_d_child_l, expanded = False)
szn_l_child.append(szn_d_child)
elif str(item) in ['Bedingung']:
szn_d_child = {'name': item, 'type': 'action', 'expanded': True}
kinder = self.__return_enum__(szene.get(item))
for child in kinder:
if type(kinder) == dict:
szn_d_child_l.append({'name': 'Bedingung %d' % (len(szn_d_child_l)+1), 'type': 'group', 'children':[{'name': 'Setting', 'type': 'str', 'value': child},
{'name': 'Operand', 'type': 'list', 'values':['==','=','<','>','<=','>=','in','!'], 'value': '='},{'name': 'Bedingung', 'type': 'str', 'value': kinder.get(child)}],'tip': "This is a checkbox"})
else:
if child <> None:
szn_d_child_l.append({'name': 'Bedingung %d' % (len(szn_d_child_l)+1), 'type': 'group', 'children':[{'name': 'Setting', 'type': 'list','values':['']+sorted(settings_r()), 'value': child[0]},
{'name': 'Operand', 'type': 'list', 'values':['==','=','<','>','<=','>=','in','!'],'value': child[1]},{'name': 'Bedingung', 'type': 'str', 'value': child[2]}]})
szn_d_child['children']= szn_d_child_l
szn_l_child.append(szn_d_child)
elif str(item) in ['setTask']:
szn_d_child = {'name': 'Befehl an Handys', 'type': 'action', 'expanded': True}
kinder = self.__return_enum__(szene.get(item))
for kind in kinder:
if kind <> None:
szn_d_child_l.append({'name': 'Befehl %d' % (len(szn_d_child_l)+1), 'type': 'group', 'children':[{'name': 'An wen', 'type': 'str', 'value': kind[0]},
{'name': 'Befehl', 'type': 'str', 'value': kind[1]}]})
szn_d_child['children']= szn_d_child_l
szn_l_child.append(szn_d_child)
elif str(item) in ['Follows']:
szn_d_child = {'name': 'Szene folgt', 'type': 'action', 'expanded': True}
kinder = self.__return_enum__(szene.get(item))
for kind in kinder:
if kind <> None:
if len(kind)<4:
immer = True
else:
immer = kind[3]
if len(kind)<5:
depErfolg = 0
else:
depErfolg = kind[4]
szn_d_child_l.append({'name': 'Szene %d' % (len(szn_d_child_l)+1), 'type': 'action', 'children':[{'name': 'Szene', 'type': 'list','value': kind[0], 'values':szn_lst},
{'name': 'nach [s]', 'type': 'str', 'value': kind[1]},{'name': 'Verlaengerbar', 'type': 'list', 'values':{'Verlaengerbar':0,'nur exact':1,'fest':2}, 'value': kind[2]},{'name': 'Abhaengig Bedingung', 'type': 'bool', 'value': immer}
,{'name': 'Abhaengig Erfolg', 'type': 'list', 'values':{'egal':0,'bei Erfolg':1,'bei Nichterfolg':2}, 'value': depErfolg}]})
szn_d_child['children']= szn_d_child_l
szn_l_child.append(szn_d_child)
elif str(item) in ['Cancels']:
szn_d_child = {'name': 'Folgende stoppen', 'type': 'action', 'expanded': True}
kinder = self.__return_enum__(szene.get(item))
for kind in kinder:
if kind <> None:
szn_d_child_l.append({'name': 'Stops %d' % (len(szn_d_child_l)+1), 'type': 'list','value': kind, 'values':szn_lst})
szn_d_child['children']= szn_d_child_l
szn_l_child.append(szn_d_child)
elif str(item) in ['AutoMode']:
szn_d_child['name'] = str(item)
szn_d_child['type'] = 'bool'
szn_d_child['expanded'] = False
if str(szene.get(item)) <> "None":
szn_d_child['value'] = eval(szene.get(item))
else:
szn_d_child['value'] = False
szn_l_child.append(szn_d_child)
else:
szn_d_child['name'] = str(item)
if str(item) in ['Delay']:
szn_d_child['type'] = 'float'
szn_d_child['step'] = 0.1
if str(szene.get(item)) <> "None":
szn_d_child['value'] = float(szene.get(item))
else:
szn_d_child['value'] = None
elif str(item) in ['Prio']:
szn_d_child['type'] ='list'
szn_d_child['values'] = {'Kein Event':-1,'Normales Event':0,'Problem ohne Hinweis':1,'Hinweis wenn zuhause':2,'immer Hinweis':3,'Hinweis wenn wach':4,
'Achtung wenn wach':5,'Alarm':6}
if str(szene.get(item)) <> "None":
szn_d_child['value'] = float(szene.get(item))
elif str(item) in ['Gruppe']:
szn_d_child['type'] ='list'
szn_d_child['values'] = szn_typs
if str(szene.get(item)) <> "None":
szn_d_child['value'] = str(szene.get(item))
else:
szn_d_child['value'] = ''
else:
szn_d_child['type'] = 'str'
if str(szene.get(item)) <> "None":
szn_d_child['value'] = str(szene.get(item))
else:
szn_d_child['value'] = ''
try:
if tipps[str(item)] <> None:
szn_d_child['tip'] = str(tipps[str(item)])
except:
pass
szn_d_child['expanded'] = False
szn_l_child.append(szn_d_child)
for stock in stockwerke:
for zim in zimmer:
if stock.name in zim.name:
stock.addChild(zim.build())
if zim.expanded:
stock.expand(True)
szn_l_child.append(stock.build())
szn_dict['children']= szn_l_child
params.append(szn_dict)
ichilds, schilds = [], []
iquellen, squellen = getSzenenSources(self.szene_to_read)
for quelle in iquellen:
ichilds.append({'name': quelle.get('Name'), 'type': 'action', 'value': quelle.get('Name'),'autoIncrementName':True})
for quelle in squellen:
schilds.append({'name': quelle.get('Name'), 'type': 'action', 'value': quelle.get('Name'),'autoIncrementName':True})
szn_dict = {'name': 'Sources', 'type': 'group', 'children': [
{'name': 'Inputs', 'type': 'group', 'autoIncrementName':True, 'children':ichilds },
{'name': 'Szenen', 'type': 'group', 'autoIncrementName':True, 'children':schilds }
]}
params.append(szn_dict)
szn_dict = {'name': 'Save/Restore functionality', 'type': 'group', 'children': [
{'name': 'Speichere Szene', 'type': 'action'},
{'name': u'Prüfe Bedingung', 'type': 'action'},
{'name': 'Execute', 'type': 'action'},
{'name': 'Neue Szene', 'type': 'action'},
{'name': 'Dupliziere Szene', 'type': 'action'}
]}
params.append(szn_dict)
self.p = Parameter.create(name='params', type='group', children=params)
try:
self.p.param('Save/Restore functionality', 'Speichere Szene').sigActivated.connect(self.save)
self.p.param('Save/Restore functionality', u'Prüfe Bedingung').sigActivated.connect(self.check_bedingung)
self.p.param('Save/Restore functionality', 'Execute').sigActivated.connect(self.execute)
#self.p.param('Save/Restore functionality', 'Neue Szene').sigActivated.connect(self.newSzene)
self.p.param(self.name, 'Befehl an Handys').sigActivated.connect(self.add_task)
self.p.param(self.name, 'Bedingung').sigActivated.connect(self.add_bedingung)
self.p.param(self.name, 'Szene folgt').sigActivated.connect(self.addSzene)
self.p.param(self.name, 'Folgende stoppen').sigActivated.connect(self.addCancels)
self.linkSzene()
except:
pass
return params
def addNew(self, typ):
values = settings_r()
val=values.get(typ)
self.addChild(dict(name=typ, type="str", value=val, removable=True, renamable=True))
def __bedingung__(self,bedingungen, verbose = False):
erfuellt = True
settings = settings_r()
if type(bedingungen) == dict:
#==============================================================================
# Deprecated
#==============================================================================
for bedingung in bedingungen:
if settings.get(bedingung) == None:
setting_s(bedingung, '')
try:
groesser = bedingungen.get(bedingung).find('>')
kleiner = bedingungen.get(bedingung).find('<')
if groesser >-1 and kleiner >-1:
schwelle_u = float(bedingungen.get(bedingung)[groesser+1:kleiner])
if float(settings.get(bedingung)) <= schwelle_u:
erfuellt = False
schwelle_o = float(bedingungen.get(bedingung)[kleiner+1:len(bedingungen.get(bedingung))])
if float(settings.get(bedingung)) >= schwelle_o:
erfuellt = False
elif groesser >-1:
schwelle = float(bedingungen.get(bedingung)[groesser+1:len(bedingungen.get(bedingung))])
if float(settings.get(bedingung)) <= schwelle:
erfuellt = False
elif kleiner >-1:
schwelle = float(bedingungen.get(bedingung)[kleiner+1:len(bedingungen.get(bedingung))])
if float(settings.get(bedingung)) >= schwelle:
erfuellt = False
else:
if not(str(settings.get(bedingung)) in bedingungen.get(bedingung)):
erfuellt = False
except Exception:
if not(str(settings.get(bedingung)) in bedingungen.get(bedingung)):
erfuellt = False
elif type(bedingungen) == list:
#==============================================================================
# new way
#==============================================================================
#[('Temperatur_Rose','>',['sett','Temperatur_Balkon'])]
for bedingung in bedingungen:
if settings.get(bedingung[0]) == None:
setting_s(bedingung, '')
item, operand, wert = bedingung
item = settings.get(item)
if verbose: print item, operand, wert
if operand == '=':
if not float(item) == float(wert):
erfuellt = False
elif operand == '==':
if not str(item) == str(wert):
erfuellt = False
elif operand == '<':
if not float(item) < float(wert):
erfuellt = False
elif operand == '>':
if not float(item) > float(wert):
erfuellt = False
elif operand == '<=':
if not float(item) <= float(wert):
erfuellt = False
elif operand == '>=':
if not float(item) >= float(wert):
erfuellt = False
elif operand == '!':
if (item) == (wert):
erfuellt = False
elif operand == 'in':
if not (item) in (wert):
erfuellt = False
if verbose: print "Ergebniss: ",erfuellt
return erfuellt
def set_szene(name):
global schlummern
global bad_ir
if str(name) == "None" or str(name) == "":
return
if "Tuer_auf" in str(name):
#if str(name) == "Tuer_auf":
t = threading.Thread(target=Tuer_auf)
t.start()
if str(name) == "Schluessel_weg":
t = threading.Thread(target=Schluessel_weg)
t.start()
szene = mdb_read_table_entry(constants.sql_tables.szenen.name,name)
if str(szene) == "{}": return
no_list = ["Priority", "Beschreibung", "Status", "Durchsage"]
bedingungen = {}
erfuellt = True
if str(szene.get("Bedingung")) <> "None":
bedingungen = eval(szene.get("Bedingung"))
erfuellt = True
settings = settings_r()
for bedingung in bedingungen:
try:
groesser = bedingungen.get(bedingung).find('>')
kleiner = bedingungen.get(bedingung).find('<')
if groesser >-1 and kleiner >-1:
schwelle_u = float(bedingungen.get(bedingung)[groesser+1:kleiner])
if float(settings.get(bedingung)) <= schwelle_u:
erfuellt = False
schwelle_o = float(bedingungen.get(bedingung)[kleiner+1:len(bedingungen.get(bedingung))])
if float(settings.get(bedingung)) >= schwelle_o:
erfuellt = False
elif groesser >-1:
schwelle = float(bedingungen.get(bedingung)[groesser+1:len(bedingungen.get(bedingung))])
if float(settings.get(bedingung)) <= schwelle:
erfuellt = False
elif kleiner >-1:
schwelle = float(bedingungen.get(bedingung)[kleiner+1:len(bedingungen.get(bedingung))])
if float(settings.get(bedingung)) >= schwelle:
erfuellt = False
else:
if not(str(settings.get(bedingung)) in bedingungen.get(bedingung)):
erfuellt = False
except Exception as e:
if not(str(settings.get(bedingung)) in bedingungen.get(bedingung)):
erfuellt = False
if str(szene.get("XS1_Bedingung")) <> "None" :
xs1_bedingung = eval(szene.get("XS1_Bedingung"))
if str(ezcontrol.GetSwitch(str(xs1_bedingung.keys()[0]))) <> str(xs1_bedingung[xs1_bedingung.keys()[0]]):
erfuellt = False
if not(name in no_event) and erfuellt:
if str(szene.get("Beschreibung")) in ['None','']:
aes.new_event(description="Szenen: " + name, prio=eval(szene.get("Priority")), karenz = 0.03)
else:
aes.new_event(description= str(szene.get("Beschreibung")), prio=eval(szene.get("Priority")), karenz = 0.03)
if erfuellt:
interlocks = {}
if str(szene.get("Auto_Mode")) == "True":
interlocks = mdb_read_table_entry(constants.sql_tables.szenen.name,"Auto_Mode")
hue_count = 0
hue_delay = 0
if str(szene.get("Durchsage")) <> "None":
setting_s("Durchsage", str(szene.get("Durchsage")))
if ((szene.get("Amp") <> "") and (str(szene.get("Amp")) <> "None")):
setting_s("AV_cmd", "1")
setting_s("Kommando", str(szene.get("Amp")))
if name in ["WeckerMute", "WeckerPhase1"] or "Schlummern" in name:
schlummern.cancel()
if name in ["Bad_ir"]:
bad_ir.cancel()
for idk, key in enumerate(szene):
if ((szene.get(key) <> "") and (str(szene.get(key)) <> "None") and (str(interlocks.get(key)) in ["None", "auto"])):
if (type(szene.get(key)) == str) and (not(str(key) in no_list)):
try:
if type(eval(szene.get(key))) == list or type(eval(szene.get(key))) == dict:
kommandos = eval(szene.get(key))
else:
kommandos = [szene.get(key)]
except NameError as serr:
kommandos = [szene.get(key)]
else:
kommandos = [szene.get(key)]
if constants.redundancy_.master:
if key in ezcontrol_devices:
for kommando in kommandos:
t = threading.Thread(target=xs1_set_szene, args=[key, kommando])
t.start()
elif key == "set_Task":
for kommando in kommandos:
mes.send_direkt(to=mes.alle, titel="Setting", text=str(kommando))
elif key == "set_Task_zuhause":
for kommando in kommandos:
mes.send_zuhause(to=mes.alle, titel="Setting", text=str(kommando))
#mes.send_direkt(mes.tf201,"Setting",str(kommando))
elif key in sonos_devices:
#for kommando in kommandos:
t = threading.Thread(target=sonos_set_szene, args=[sonos_devices.get(key), kommandos])
t.start()
elif key in hue_devices:
for kommando in kommandos:
if hue_count > 1:
hue_delay += 0.75
hue_count = 0
hue_del = Timer(hue_delay, hue_set_szene, [key, kommando])
hue_del.start()
hue_count += 1
elif key in sat_names:
for kommando in kommandos:
t = threading.Thread(target=send_cmd_satellite, args=[key,kommando])
t.start()
elif key == "TV":
for idx, kommando in enumerate(kommandos):
folgen = Timer((float(idx)/5), tv_set_szene, [kommando])
folgen.start()
elif key == "Interner_Befehl":
for kommando in kommandos:
t = threading.Thread(target=interner_befehl, args=[kommando])
t.start()
for idk, key in enumerate(szene):
if ((szene.get(key) <> "") and (str(szene.get(key)) <> "None") and (str(interlocks.get(key)) in ["None", "auto"])):
if (type(szene.get(key)) == str) and (not(str(key) in no_list)):
try:
if type(eval(szene.get(key))) == list or type(eval(szene.get(key))) == dict:
kommandos = eval(szene.get(key))
else:
kommandos = [szene.get(key)]
except NameError as serr:
kommandos = [szene.get(key)]
else:
kommandos = [szene.get(key)]
if key in setting:
for kommando in kommandos:
aes.new_event(description=key + ": " + str(kommando), prio=0)
setting_s(key, str(kommando))
elif key == "Zusatz_Status":
for kommando in kommandos:
set_del = Timer(1, setting_s, [str(kommando), str(kommandos.get(kommando))])
set_del.start()
if ((szene.get("Szene_folgt") <> "") and (str(szene.get("Szene_folgt")) <> "None")):
try:
if type(eval(szene.get("Szene_folgt"))) == list:
kommandos = eval(szene.get("Szene_folgt"))
else:
kommandos = [szene.get("Szene_folgt")]
except NameError as serr:
kommandos = [szene.get("Szene_folgt")]
try:
if type(eval(szene.get("folgt_nach"))) == list:
delays = eval(szene.get("folgt_nach"))
else:
delays = [szene.get("folgt_nach")]
except NameError as serr:
delays = [szene.get("folgt_nach")]
for index, kommando in enumerate(kommandos):
if "Schlummern" in name:
schlummern = Timer(float(delays[index]), set_szene, [str(kommando)])
schlummern.start()
elif "Bad_ir" in name:
bad_ir = Timer(float(delays[index]), set_szene, [str(kommando)])
bad_ir.start()
else:
folgen = Timer(float(delays[index]), set_szene, [str(kommando)])
folgen.start()
con = mdb.connect(constants.sql_.IP, constants.sql_.USER, constants.sql_.PASS, constants.sql_.DB)
with con:
cur = con.cursor()
sql = 'UPDATE Szenen SET LastUsed = CURRENT_TIMESTAMP WHERE Name = "'+ name + '"'
cur.execute(sql)
con.close()
