def dawndusk_trig_cb(self, message):
"""
General callback for all command messages
@param message : an XplMessage object
"""
self.log.debug("dawndusk.dawndusk_trig_cb() : Start ...")
mtype = None
if 'type' in message.data:
mtype = message.data['type']
status = None
if 'status' in message.data:
status = message.data['status']
self.log.debug("dawndusk.dawndusk_trig_cb : type %s received \
with status %s" % (mtype, status))
if mtype == "dawndusk" and status != None:
#We receive a trig indicating that the dawn or dus has occured.
#We need to schedule the next one
self.add_next_event()
for dev in self.devices:
self.log.debug("sendMessages() : Send message to device %s" %
dev)
mess = XplMessage()
mess.set_type(self.devices[dev]["xpltype"])
mess.set_schema(self.devices[dev]["schema"])
mess.add_data({self.devices[dev]["command"] : \
self.devices[dev][status]})
mess.add_data({self.devices[dev]["addname"]: dev})
self.myxpl.send(mess)
self.log.debug("dawndusk.dawndusk_trig_cb() : Done :)")
def test_260_add_duplicate_testjob1(self):
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("sensor.basic")
message.add_data({"current": "high"})
message.add_data({"device": "tsjob1"})
self.assertFalse(
self.cronquery.start_timer_job("testjob1", message, 45))
def test_510_resume_cron1(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("timer.basic")
message.add_data({"action" : "resume"})
message.add_data({"device" : "cron1"})
keys = ['devicetype']
keyvalss = {"device":"cron1", "devicetype":"cron", "state":"started"}
self.assertTrue(self.query("device",message,keys,keyvalss))
def test_410_stop_dawnalarm1(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("timer.basic")
message.add_data({"action" : "stop"})
message.add_data({"device" : "alarm1"})
keys = ['devicetype']
keyvalss = {"device":"alarm1", "devicetype":"dawnalarm", "state":"stopped"}
self.assertTrue(self.query("device", message, keys, keyvalss))
def test_710_status(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema(self.schema)
message.add_data({"action" : "status"})
message.add_data({"device" : "bluez"})
keys = None
keyvalss = {"device":"bluez", "status":"started"}
self.assertTrue(self.query("device", message, keys, keyvalss))
def test_940_halt_dawnalarm4(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("timer.basic")
message.add_data({"action" : "halt"})
message.add_data({"device" : "alarm4"})
keys = ['device']
keyvalss = {"device":"alarm4", "state":"halted"}
self.assertTrue(self.query("device", message, keys, keyvalss))
def test_460_simulate_lastquarter(self):
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("earth.basic")
message.add_data({"type": "lastquarter"})
message.add_data({"current": "fired"})
keys = ['uptime', 'fullruntime', 'runtime', 'runs', 'next']
keyvalss = {"type": "lastquarter", 'current': "started"}
self.assertTrue(self.query("type", message, keys, keyvalss))
def test_420_add_bad_interval(self):
self.cronquery.halt_job("testjob1")
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("sensor.basic")
message.add_data({"current": "high"})
message.add_data({"device": "tsjob1"})
self.assertTrue(
self.cronquery.start_interval_job("testjob1", message) != True)
def test_520_add_bad_date(self):
self.cronquery.halt_job("testjob1")
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("sensor.basic")
message.add_data({"current": "high"})
message.add_data({"device": "tsjob1"})
self.assertTrue(self.cronquery.start_date_job("testjob1",message,\
datetime.datetime.today() - datetime.timedelta(seconds=120)) != True)
def _discover_hosts(self):
""" Send a hbeat.request to discover managers
"""
mess = XplMessage()
mess.set_type('xpl-cmnd')
mess.set_target("*")
mess.set_schema('hbeat.request')
mess.add_data({'command': 'request'})
self.myxpl.send(mess)
def test_310_info_interval1(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("timer.basic")
message.add_data({"action" : "status"})
message.add_data({"device" : "interval1"})
keys = ['devicetype']
keyvalss = {"device":"interval1", "devicetype":"interval", "state":"started"}
self.assertTrue(self.query("device",message,keys,keyvalss))
def test_260_add_duplicate_testjob1(self):
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("sensor.basic")
message.add_data({"current": "high"})
message.add_data({"device": "tsjob1"})
self.assertFalse(self.cronquery.start_timer_job("testjob1", message, 45))
def dawndusk_trig_cb(self, message):
"""
General callback for all command messages
@param message : an XplMessage object
"""
self.log.debug("dawndusk.dawndusk_trig_cb() : Start ...")
mtype = None
if 'type' in message.data:
mtype = message.data['type']
status = None
if 'status' in message.data:
status = message.data['status']
self.log.debug("dawndusk.dawndusk_trig_cb : type %s received \
with status %s" % (mtype, status))
if mtype == "dawndusk" and status != None:
#We receive a trig indicating that the dawn or dus has occured.
#We need to schedule the next one
self.add_next_event()
for dev in self.devices:
self.log.debug("sendMessages() : Send message to device %s"%dev)
mess = XplMessage()
mess.set_type(self.devices[dev]["xpltype"])
mess.set_schema(self.devices[dev]["schema"])
mess.add_data({self.devices[dev]["command"] : \
self.devices[dev][status]})
mess.add_data({self.devices[dev]["addname"] : dev})
self.myxpl.send(mess)
self.log.debug("dawndusk.dawndusk_trig_cb() : Done :)")
def send_xPL(self, xPLmsg, args = None):
""" Envoie une commande ou message zwave vers xPL"""
mess = XplMessage()
mess.set_type(xPLmsg['type'])
mess.set_schema(xPLmsg['schema'])
if xPLmsg.has_key('data') : mess.add_data(xPLmsg['data'])
print '********************* Dans send_xPL *****************'
if args :
mess.add_data({'data': self.getUIdata2dict(args)})
print mess
self.myxpl.send(mess)
def send_xpl(self, num):
""" Send xPL message on network
@param num : call number
"""
print("Input call : %s " % num)
msg = XplMessage()
msg.set_type("xpl-trig")
msg.set_schema("cid.basic")
msg.add_data({"calltype": "INBOUND"})
msg.add_data({"phone": num})
self.myxpl.send(msg)
def send_cid_basic(self, device, calltype, phone_number):
# Notice that device is not used in this xpl schema
mess = "cid.basic : calltype=%s, phone=%s" % (calltype, phone_number)
print(mess)
self.log.debug(mess)
msg = XplMessage()
msg.set_type("xpl-trig")
msg.set_schema("cid.basic")
msg.add_data({ 'calltype' : calltype })
msg.add_data({ 'phone' : phone_number })
self.myxpl.send(msg)
def _get_installed_packages_from_manager(self):
""" Send a xpl message to all managers to get installed packages list
"""
### Send xpl message to get list
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("domogik.package")
message.add_data({"command": "installed-packages-list"})
message.add_data({"host": "*"})
self.myxpl.send(message)
def test_410_wait_for_low_stat(self):
self.schema = "sensor.basic"
self.xpltype = "xpl-stat"
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema(self.schema)
message.add_data({"action" : "status"})
message.add_data({"device" : "bluez"})
keys = None
keyvalss = {"device":"myphone", "bluez":"bluez", "type":"ping", "current":"low"}
self.assertTrue(self.query_many("device", message, keys, keyvalss))
def test_420_add_bad_interval(self):
self.cronquery.halt_job("testjob1")
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("sensor.basic")
message.add_data({"current": "high"})
message.add_data({"device": "tsjob1"})
self.assertTrue(self.cronquery.start_interval_job("testjob1", message) != True)
def stat_scnlist_scene(self, myxpl, scene):
"""
@param myxpl : The XPL sender
@param message : The XPL message
"""
mess = XplMessage()
mess.set_type("xpl-cmnd")
mess.set_schema("lighting.config")
mess.add_data({"client" : self._name})
mess.add_data({"command" : "scninfo"})
mess.add_data({"scene" : scene})
myxpl.send(mess)
def test_450_status_moonphase(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.request")
message.add_data({"command" : "status"})
message.add_data({"query" : "moonphase"})
keys = []
keyvalss = {'type' : 'moonphase','status':'newmoon'}
self.assertTrue(self.query_many("type",message,keys,keyvalss))
def test_310_parameter_get(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.request")
message.add_data({"command" : "get"})
message.add_data({"param" : "dawndusk"})
keys = ['value']
keyvalss = {"param" : "dawndusk"}
self.assertTrue(self.query_many("param",message,keys,keyvalss))
def _discover_hosts(self):
""" Send a hbeat.request to discover managers
"""
mess = XplMessage()
mess.set_type('xpl-cmnd')
mess.set_target("*")
mess.set_schema('hbeat.request')
mess.add_data({'command' : 'request'})
self.myxpl.send(mess)
def test_230_simulate_dawn(self):
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("earth.basic")
message.add_data({"type" : "dawn"})
message.add_data({"current" : "fired"})
keys = ['uptime', 'fullruntime', 'runtime', 'runs', 'next']
keyvalss = {"type":"dawn", "delay":"0", 'current' : "started"}
self.assertTrue(self.query("type", message, keys, keyvalss))
def test_920_halt_firstquarter(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.basic")
message.add_data({"action" : "halt"})
message.add_data({"type" : "firstquarter"})
keys = ['uptime', 'fullruntime', 'runtime', 'runs', 'next']
keyvalss = {"type" : "firstquarter", 'current' : 'halted', 'delay' : '0'}
self.assertTrue(self.query_many("type", message, keys, keyvalss))
def test_130_info(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.request")
message.add_data({"command" : "info"})
message.add_data({"type" : "fullmoon"})
keys = ['delay', 'current', 'uptime', 'fullruntime', 'runtime', 'runs', 'next']
keyvalss = {"type" : "fullmoon", "delay":"0"}
self.assertTrue(self.query_many("type",message,keys,keyvalss))
def test_907_resume_newmoon(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.basic")
message.add_data({"action" : "resume"})
message.add_data({"type" : "newmoon"})
keys = ['uptime', 'fullruntime', 'runtime', 'runs', 'next']
keyvalss = {"type":"newmoon", 'current' : 'started', 'delay' : '0'}
self.assertTrue(self.query_many("type", message, keys, keyvalss))
def test_460_simulate_lastquarter(self):
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("earth.basic")
message.add_data({"type" : "lastquarter"})
message.add_data({"current" : "fired"})
keys = ['uptime', 'fullruntime', 'runtime', 'runs', 'next']
keyvalss = {"type":"lastquarter", 'current' : "started"}
self.assertTrue(self.query_many("type", message, keys, keyvalss))
def test_630_status_moonphase_not_changed(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.request")
message.add_data({"command" : "status"})
message.add_data({"query" : "moonphase"})
keys = []
keyvalss = {'type' : 'moonphase','status':'firstquarter'}
self.assertFalse(self.query_many("type",message,keys,keyvalss))
def set_relay(self, device, value):
""" Send xpl-trig to give status change
@param device : device
@param value : HIGH/LOW
"""
self.log.info("Send command '%s' on device '%s'" % (value, device))
msg = XplMessage()
msg.set_type("xpl-cmnd")
msg.set_schema('control.basic')
msg.add_data({'device': device})
msg.add_data({'type': 'output'})
msg.add_data({'current': value})
self.myxpl.send(msg)
def send_xpl_weather_forecast(self, data):
""" Send xPL message on network
"""
self.log.debug(u"Forecast data : {0}".format(data))
msg = XplMessage()
msg.set_type("xpl-stat")
msg.set_schema("weather.forecast")
msg.add_data({"provider": "yahoo weather"})
for key in data:
val = data[key]
if val != "":
msg.add_data({key: val})
self.myxpl.send(msg)
def send_xplTrig(self, data):
""" Send xPL fake message on network
"""
global xpl_plugin
msg = XplMessage()
msg.set_type("xpl-trig")
msg.set_header(source="domogik-{0}.{1}".format(
self.name, get_sanitized_hostname()))
msg.set_schema("sensor.basic")
msg.add_data(data)
print(u"send fake xpl switch on : {0}".format(msg))
xpl_plugin.myxpl.send(msg)
def _broadcast_events(self, events):
""" Send xPL message on network
@param events : list of events
"""
for entry in events:
my_temp_message = XplMessage()
my_temp_message.set_type("xpl-trig")
my_temp_message.set_schema("calendar.basic")
print("entry = ")
print(entry)
my_temp_message.add_data({"object": entry["object"]})
my_temp_message.add_data({"startdate": entry["startdate"]})
self.myxpl.send(my_temp_message)
def test_610_wait_for_phone_off(self):
#time.sleep(30)
self.schema = "sensor.basic"
self.xpltype = "xpl-trig"
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema(self.schema)
message.add_data({"action" : "status"})
message.add_data({"device" : "bluez"})
keys = None
keyvalss = {"device":"myphone", "bluez":"bluez", "type":"ping", "current":"low"}
print("")
print("You must now turn OFF bluetooth on your phone")
self.assertTrue(self.query_many("device", message, keys, keyvalss))
def test_610_list_dawnalarm1(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("timer.basic")
message.add_data({"action" : "list"})
keys = ['devices']
self.assertTrue(self.query("device", message, keys))
def halt_job(self, device, extkey="state"):
"""
Stop a job and delete the device. Job is permanently deleted.
:param device: the device/job to halt
:type device: str
:param extkey: the message key to look for ("state" by default)
:type extkey: str
:return: the state sent by cron plugin : "started"|"stopped"|"halted"
:rtype: str
"""
configmess = XplMessage()
configmess.set_type("xpl-cmnd")
configmess.set_schema("timer.basic")
configmess.add_data({"action": "halt"})
configmess.add_data({"device": device})
try:
res = self.query(device, configmess, extkey=extkey)
#print res
return res
except:
if self.log != None:
self.log.error("cron_query : %s" % (traceback.format_exc()))
return False
def tsChacon_monitor_cb(self, house, unit, order, args=None):
"""
Callback for TellStick Chacon monitoring
@param house : the house of the element controled
@param unit : the unit of the element controled
@param order : the order sent to the unit
"""
self.log.debug("tschacon Callback YEDfor %s" % unit)
mess = XplMessage()
mess.set_type("xpl-trig")
mess.set_schema("ts.arctech")
mess.add_data({"device": house + unit})
mess.add_data({"command": order})
self.myxpl.send(mess)
def stop_job(self, device, extkey="state"):
"""
Stop a job to the cron plugin. The cron job could be restarted via a
resume command.
:param device: the device/job to stop
:type device: str
:param extkey: the message key to look for ("state" by default)
:type extkey: str
:return: the state sent by cron plugin : "started"|"stopped"|"halted"
:rtype: str
"""
configmess = XplMessage()
configmess.set_type("xpl-cmnd")
configmess.set_schema("timer.basic")
configmess.add_data({"action": "stop"})
configmess.add_data({"device": device})
try:
res = self.query(device, configmess, extkey=extkey)
return res
except:
if self.log != None:
self.log.error("cron_query : %s" % (traceback.format_exc()))
return False
def send_xpl(self, num):
""" Send xPL message on network
@param num : call number
"""
print("Input call : %s " % num)
msg = XplMessage()
msg.set_type("xpl-trig")
msg.set_schema("cid.basic")
msg.add_data({"calltype" : "INBOUND"})
msg.add_data({"phone" : num})
self.myxpl.send(msg)
def _get_installed_packages_from_manager(self):
""" Send a xpl message to all managers to get installed packages list
"""
### Send xpl message to get list
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("domogik.package")
message.add_data({"command" : "installed-packages-list"})
message.add_data({"host" : "*"})
self.myxpl.send(message)
def test_860_add_new_moon_moins_bad(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.basic")
message.add_data({"action" : "start"})
message.add_data({"type" : "newmoon"})
delay = "-%s" % (60*60*24*28+3600)
message.add_data({"delay" : delay })
keys = ['uptime', 'fullruntime', 'runtime', 'runs', 'next']
keyvalss = {"type" : "newmoon", 'current' : 'started','delay' : delay}
self.assertFalse(self.query_many("type", message, keys, keyvalss))
def test_550_wait_for_high_stat(self):
#time.sleep(30)
self.schema = "sensor.basic"
self.xpltype = "xpl-stat"
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema(self.schema)
message.add_data({"action" : "status"})
message.add_data({"device" : "bluez"})
keys = None
keyvalss = {"device":"myphone", "bluez":"bluez", "type":"ping", "current":"high"}
self.assertTrue(self.query_many("device", message, keys, keyvalss))
duration = datetime.datetime.now() - self.time_start
print("")
print("Delay before getting message is %s seconds" % duration.seconds)
def send_xplStat(self, data):
""" Send xPL cmd message on network
"""
msg = XplMessage()
msg.set_type("xpl-stat")
msg.set_schema("sensor.basic")
msg.add_data(data)
self.myxpl.send(msg)
def _send_previsionnal(self, device, data):
""" Send weather.basic xPL schema
@param device : device
@param data : dictionnary of data to send
"""
print("D=%s, %s" % (device, data))
msg = XplMessage()
msg.set_type("xpl-stat")
msg.set_schema("weather.basic")
msg.add_data({"device": device})
for key in data:
if data[key] != "":
msg.add_data({key: data[key]})
self.myxpl.send(msg)
def send_action_xpl(self, action):
### Send an xpl message define in scene action
### action['type_message'] =xpl-type
### action['schema'] = xpl schema
### action['value'] = xpl val
msg = XplMessage()
msg.set_source(self.senderscene)
msg.set_schema(action['schema'])
msg.set_type(action['type_message'])
# if "Eval" in action['value'] or "eval" in action['value']:
# msg.add_data(eval(action['value'].replace('Eval','')))
# else:
# msg.add_data(action['value'])
msg.add_data(action['value'])
self.myxpl.send(msg)
def test_510_add_date(self):
self.cronquery.halt_job("testjob1")
message = XplMessage()
message.set_type("xpl-trig")
message.set_schema("sensor.basic")
message.add_data({"current": "high"})
message.add_data({"device": "tsjob1"})
self.assertTrue(
self.cronquery.start_date_job(
"testjob1", message, datetime.datetime.today() + datetime.timedelta(seconds=120)
)
)
def send_xplTrig(self, data):
""" Send xPL fake message on network
"""
global xpl_plugin
msg = XplMessage()
msg.set_type("xpl-trig")
msg.set_header(source ="domogik-{0}.{1}".format(self.name, get_sanitized_hostname()))
msg.set_schema("sensor.basic")
msg.add_data(data)
print (u"send fake xpl switch on : {0}".format(msg))
xpl_plugin.myxpl.send(msg)
def _broadcast_events(self, events):
""" Send xPL message on network
@param events : list of events
"""
for entry in events:
my_temp_message = XplMessage()
my_temp_message.set_type("xpl-trig")
my_temp_message.set_schema("calendar.basic")
print("entry = ")
print(entry)
my_temp_message.add_data({"object" : entry["object"]})
my_temp_message.add_data({"startdate" : entry["startdate"]})
self.myxpl.send(my_temp_message)
def set_relay(self, device, value):
""" Send xpl-trig to give status change
@param device : device
@param value : HIGH/LOW
"""
self.log.info("Send command '%s' on device '%s'" % (value, device))
msg = XplMessage()
msg.set_type("xpl-cmnd")
msg.set_schema('control.basic')
msg.add_data({'device' : device})
msg.add_data({'type' : 'output'})
msg.add_data({'current' : value})
self.myxpl.send(msg)
def send_xpl_weather_forecast(self, data):
""" Send xPL message on network
"""
self.log.debug(u"Forecast data : {0}".format(data))
msg = XplMessage()
msg.set_type("xpl-stat")
msg.set_schema("weather.forecast")
msg.add_data({"provider" : "yahoo weather"})
for key in data:
val = data[key]
if val != "":
msg.add_data({key : val})
self.myxpl.send(msg)
def test_310_memory(self):
message = XplMessage()
message.set_type("xpl-cmnd")
message.set_schema("earth.request")
message.add_data({"command" : "memory"})
keys = ['memory']
self.assertTrue(self.query_many("memory",message,keys))
