def on_api_command(self, command, data):
if command in ['turnPSUOn', 'turnPSUOff', 'togglePSU']:
try:
if not Permissions.PLUGIN_PSUCONTROL_CONTROL.can():
return make_response("Insufficient rights", 403)
except:
if not user_permission.can():
return make_response("Insufficient rights", 403)
elif command in ['getPSUState']:
try:
if not Permissions.STATUS.can():
return make_response("Insufficient rights", 403)
except:
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == 'turnPSUOn':
self.turn_psu_on()
elif command == 'turnPSUOff':
self.turn_psu_off()
elif command == 'togglePSU':
if self.isPSUOn:
self.turn_psu_off()
else:
self.turn_psu_on()
elif command == 'getPSUState':
return jsonify(isPSUOn=self.isPSUOn)
def on_api_command(self, command, data):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
configuration = self._settings.get(["gpio_configurations"
])[int(data["id"])]
pin = self.get_pin_number(int(configuration["pin"]))
if command == "getGpioState":
return flask.jsonify(
"" if pin < 0 else self._get_pin_state(pin, configuration))
elif command == "turnGpioOn":
if pin > 0:
self.pin_states[pin] = True
GPIO.output(pin,
self.active_states[configuration["active_mode"]])
self._logger.info("Turned on GPIO{}".format(
configuration["pin"]))
elif command == "turnGpioOff":
if pin > 0:
self.pin_states[pin] = False
GPIO.output(
pin, not self.active_states[configuration["active_mode"]])
self._logger.info("Turned off GPIO{}".format(
configuration["pin"]))
def on_api_command(self, command, data):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
if command == 'turnOn':
response = self.turn_on("{ip}".format(**data))
self._plugin_manager.send_plugin_message(self._identifier,
response)
elif command == 'turnOff':
response = self.turn_off("{ip}".format(**data))
self._plugin_manager.send_plugin_message(self._identifier,
response)
elif command == 'checkStatus':
response = self.check_status("{ip}".format(**data))
elif command == 'getEnergyData':
db = sqlite3.connect(self.db_path)
cursor = db.cursor()
cursor.execute(
'''SELECT timestamp, current, power, total, voltage FROM energy_data WHERE ip=? ORDER BY timestamp DESC LIMIT ?,?''',
(
data["ip"],
data["record_offset"],
data["record_limit"],
))
response = {'energy_data': cursor.fetchall()}
db.close()
self._logger.info(response)
#SELECT * FROM energy_data WHERE ip = '192.168.0.102' LIMIT 0,30
else:
response = dict(ip=data.ip, currentState="unknown")
return flask.jsonify(response)
def on_api_command(self, command, data):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
if command == "register_printer":
"""
if "manufacturer" not in data:
data["manufacturer"] = "cars"
if "model" not in data:
data["model"] = "fdm-printer"
"""
self._on_regist_printer(data)
if command == "forget_printer":
# new_supported_printers = self.get_supported_printers()
self.mqtt_disconnect(force=True)
self._settings.set(["printer_serial_number"], "")
self._settings.set(["printer_token"], "")
self._settings.set_boolean(["registration_complete"], False)
# self._settings.set(["supported_printers"],new_supported_printers)
self._settings.save()
# self._plugin_manager.send_plugin_message(self._identifier, dict(printer_removed=True))
return flask.jsonify(
{"printer_removed":
True}) #,"supported_printers":new_supported_printers})
if command == "mmf_print_complete":
self._mmf_print = False
self._current_action_code = "000"
self._settings.set_boolean(["mmf_print_complete"], False)
self._settings.set_boolean(["mmf_print_cancelled"], False)
self._settings.save()
return flask.jsonify(bed_cleared=True)
def on_api_command(self, command, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == "enable":
self._shutdown_printer_enabled = True
elif command == "disable":
self._shutdown_printer_enabled = False
elif command == "shutdown":
self._shutdown_printer_API_CMD(
data["mode"]
) #mode 1 = gcode, mode 2 = api, mode 3 = custom api
elif command == "abort":
if self._abort_timer is not None:
self._abort_timer.cancel()
self._abort_timer = None
self._abort_timer_temp.cancel()
self._abort_timer_temp = None
self._timeout_value = None
self._logger.info("Shutdown aborted.")
if command == "enable" or command == "disable":
self.lastCheckBoxValue = self._shutdown_printer_enabled
if self.rememberCheckBox:
self._settings.set_boolean(["lastCheckBoxValue"],
self.lastCheckBoxValue)
self._settings.save()
eventManager().fire(Events.SETTINGS_UPDATED)
self._plugin_manager.send_plugin_message(
self._identifier,
dict(shutdownprinterEnabled=self._shutdown_printer_enabled,
type="timeout",
timeout_value=self._timeout_value))
def on_api_get(self, request): if not user_permission.can(): return flask.abort(403, "Insufficient permissions") if self._prompt is None: return flask.jsonify() else: return flask.jsonify(text=self._prompt.text, choices=self._prompt.choices)
def on_api_command(self, command, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == "enable":
self._automatic_shutdown_enabled = True
elif command == "disable":
self._automatic_shutdown_enabled = False
elif command == "abort":
if self._wait_for_timelapse_timer is not None:
self._wait_for_timelapse_timer.cancel()
self._wait_for_timelapse_timer = None
if self._abort_timer is not None:
self._abort_timer.cancel()
self._abort_timer = None
self._timeout_value = None
self._logger.info("Shutdown aborted.")
if command == "enable" or command == "disable":
self.lastCheckBoxValue = self._automatic_shutdown_enabled
if self.rememberCheckBox:
self._settings.set_boolean(["lastCheckBoxValue"], self.lastCheckBoxValue)
self._settings.save()
eventManager().fire(Events.SETTINGS_UPDATED)
self._plugin_manager.send_plugin_message(self._identifier, dict(automaticShutdownEnabled=self._automatic_shutdown_enabled, type="timeout", timeout_value=self._timeout_value))
def on_api_command(self, command, data):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
configuration = self._settings.get(["gpio_configurations"
])[int(data["id"])]
pin = self.get_pin_number(int(configuration["pin"]))
if command == "getGpioState":
if pin < 0:
return flask.jsonify("")
elif configuration["active_mode"] == "active_low":
return flask.jsonify("off" if GPIO.input(pin) else "on")
elif configuration["active_mode"] == "active_high":
return flask.jsonify("on" if GPIO.input(pin) else "off")
elif command == "turnGpioOn":
if pin > 0:
self._logger.info("Turned on GPIO{}".format(
configuration["pin"]))
if configuration["active_mode"] == "active_low":
GPIO.output(pin, GPIO.LOW)
elif configuration["active_mode"] == "active_high":
GPIO.output(pin, GPIO.HIGH)
elif command == "turnGpioOff":
if pin > 0:
self._logger.info("Turned off GPIO{}".format(
configuration["pin"]))
if configuration["active_mode"] == "active_low":
GPIO.output(pin, GPIO.HIGH)
elif configuration["active_mode"] == "active_high":
GPIO.output(pin, GPIO.LOW)
def on_api_command(self, command, data):
self._tasmota_logger.debug(data)
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'turnOn':
if "username" in data and data["username"] != "":
self._tasmota_logger.debug("Using authentication for %s." % "{ip}".format(**data))
self.turn_on("{ip}".format(**data),"{idx}".format(**data),username="******".format(**data),password="******".format(**data))
else:
self.turn_on("{ip}".format(**data),"{idx}".format(**data))
elif command == 'turnOff':
if "username" in data and data["username"] != "":
self._tasmota_logger.debug("Using authentication for %s." % "{ip}".format(**data))
self.turn_off("{ip}".format(**data),"{idx}".format(**data),username="******".format(**data),password="******".format(**data))
else:
self.turn_off("{ip}".format(**data),"{idx}".format(**data))
elif command == 'checkStatus':
if "username" in data and data["username"] != "":
self._tasmota_logger.debug("Using authentication for %s." % "{ip}".format(**data))
self.check_status("{ip}".format(**data),"{idx}".format(**data),username="******".format(**data),password="******".format(**data))
else:
self.check_status("{ip}".format(**data),"{idx}".format(**data))
elif command == 'connectPrinter':
self._tasmota_logger.debug("Connecting printer.")
self._printer.connect()
elif command == 'disconnectPrinter':
self._tasmota_logger.debug("Disconnecting printer.")
self._printer.disconnect()
elif command == 'sysCommand':
self._tasmota_logger.debug("Running system command %s." % "{cmd}".format(**data))
os.system("{cmd}".format(**data))
def on_api_command(self, command, data):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
if command == 'updateToken':
# Convert from ASCII to UTF-8 since somce chars will fail otherwise
data["deviceName"] = data["deviceName"].encode("utf-8")
printer_name = data[
"printerName"] if 'printerName' in data else None
language_code = data[
"languageCode"] if 'languageCode' in data else None
self.update_token("{oldToken}".format(**data),
"{newToken}".format(**data),
"{deviceName}".format(**data),
"{printerID}".format(**data), printer_name,
language_code)
elif command == 'test':
payload = dict(state_id="OPERATIONAL", state_string="Operational")
code = self._job_notifications.send__print_job_notification(
self._settings, self._printer, payload, data["server_url"],
data["camera_snapshot_url"], True)
return flask.jsonify(dict(code=code))
elif command == 'snooze':
if data["eventCode"] == 'mmu-event':
self._mmu_assitance.snooze(data["minutes"])
else:
return flask.make_response("Snooze for unknown event", 400)
else:
return flask.make_response("Unknown command", 400)
def on_api_command(self, command, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == 'turnPSUOn':
self.turn_psu_on()
elif command == 'turnPSUOff':
self.turn_psu_off()
def on_api_command(self, command, data):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
if command == 'turnOn':
response = self.turn_on("{ip}".format(**data))
self._plugin_manager.send_plugin_message(self._identifier, response)
elif command == 'turnOff':
response = self.turn_off("{ip}".format(**data))
self._plugin_manager.send_plugin_message(self._identifier, response)
elif command == 'checkStatus':
response = self.check_status("{ip}".format(**data))
elif command == 'getEnergyData':
db = sqlite3.connect(self.db_path)
cursor = db.cursor()
cursor.execute('''SELECT timestamp, current, power, total, voltage FROM energy_data WHERE ip=? ORDER BY timestamp DESC LIMIT ?,?''', (data["ip"],data["record_offset"],data["record_limit"]))
response = {'energy_data' : cursor.fetchall()}
db.close()
self._tplinksmartplug_logger.debug(response)
#SELECT * FROM energy_data WHERE ip = '192.168.0.102' LIMIT 0,30
elif command == 'enableAutomaticShutdown':
self.powerOffWhenIdle = True
self._reset_idle_timer()
elif command == 'disableAutomaticShutdown':
self.powerOffWhenIdle = False
self._stop_idle_timer()
if self._abort_timer is not None:
self._abort_timer.cancel()
self._abort_timer = None
self._timeout_value = None
elif command == 'abortAutomaticShutdown':
if self._abort_timer is not None:
self._abort_timer.cancel()
self._abort_timer = None
self._timeout_value = None
for plug in self._settings.get(["arrSmartplugs"]):
if plug["useCountdownRules"] and int(plug["countdownOffDelay"]) > 0:
if "/" in plug["ip"]:
plug_ip, plug_num = plug["ip"].split("/")
else:
plug_ip = plug["ip"]
plug_num = -1
self.sendCommand(json.loads('{"count_down":{"delete_all_rules":null}}'),plug_ip,plug_num)
self._tplinksmartplug_logger.debug("Cleared countdown rules for %s" % plug["ip"])
self._tplinksmartplug_logger.debug("Power off aborted.")
self._tplinksmartplug_logger.debug("Restarting idle timer.")
self._reset_idle_timer()
else:
response = dict(ip = data.ip, currentState = "unknown")
if command == "enableAutomaticShutdown" or command == "disableAutomaticShutdown":
self._tplinksmartplug_logger.debug("Automatic power off setting changed: %s" % self.powerOffWhenIdle)
self._settings.set_boolean(["powerOffWhenIdle"], self.powerOffWhenIdle)
self._settings.save()
#eventManager().fire(Events.SETTINGS_UPDATED)
if command == "enableAutomaticShutdown" or command == "disableAutomaticShutdown" or command == "abortAutomaticShutdown":
self._plugin_manager.send_plugin_message(self._identifier, dict(powerOffWhenIdle=self.powerOffWhenIdle, type="timeout", timeout_value=self._timeout_value))
else:
return flask.jsonify(response)
def on_api_command(self, comm, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if comm == 'executeCommand':
return self.execute_command(data)
if comm == 'sendMessage':
return self.unpack_message(data)
def on_api_command(self, command, data):
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'toggleRelay' or command == "turnOn" or command == "turnOff":
for relay in self._settings.get(["arrRelays"]):
if relay["topic"] == "{topic}".format(
**data) and relay["relayN"] == "{relayN}".format(
**data):
if command == "turnOff" or (command == "toggleRelay" and
relay["currentstate"] == "ON"):
self._logger.info(
"turning off {topic} relay {relayN}".format(
**data))
self.turn_off(relay)
if command == "turnOn" or (command == "toggleRelay" and
relay["currentstate"] == "OFF"):
self._logger.info(
"turning on {topic} relay {relayN}".format(**data))
self.turn_on(relay)
if command == 'checkStatus':
for relay in self._settings.get(["arrRelays"]):
self._logger.info("checking status of %s relay %s" %
(relay["topic"], relay["relayN"]))
try:
self.mqtt_publish(
self.generate_mqtt_full_topic(relay, "cmnd"), "")
except:
self._plugin_manager.send_plugin_message(
self._identifier, dict(noMQTT=True))
if command == 'checkRelay':
self._logger.info(
"subscribing to {topic} relay {relayN}".format(**data))
for relay in self._settings.get(["arrRelays"]):
if relay["topic"] == "{topic}".format(
**data) and relay["relayN"] == "{relayN}".format(
**data):
self.mqtt_subscribe(
self.generate_mqtt_full_topic(relay, "stat"),
self._on_mqtt_subscription,
kwargs=dict(top="{topic}".format(**data),
relayN="{relayN}".format(**data)))
self._logger.info(
"checking {topic} relay {relayN}".format(**data))
self.mqtt_publish(
self.generate_mqtt_full_topic(relay, "cmnd"), "")
if command == 'removeRelay':
for relay in self._settings.get(["arrRelays"]):
if relay["topic"] == "{topic}".format(
**data) and relay["relayN"] == "{relayN}".format(
**data):
self.mqtt_unsubscribe(self._on_mqtt_subscription,
topic=self.generate_mqtt_full_topic(
relay, "stat"))
def on_api_command(self, command, data):
self._domoticz_logger.debug(data)
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == "turnOn":
if "username" in data and data["username"] != "":
self._domoticz_logger.debug(
"Using authentication for %s." % "{ip}".format(**data)
)
self.turn_on(
"{ip}".format(**data),
"{idx}".format(**data),
username="******".format(**data),
password="******".format(**data),
)
else:
self.turn_on("{ip}".format(**data), "{idx}".format(**data))
elif command == "turnOff":
if "username" in data and data["username"] != "":
self._domoticz_logger.debug(
"Using authentication for %s." % "{ip}".format(**data)
)
self.turn_off(
"{ip}".format(**data),
"{idx}".format(**data),
username="******".format(**data),
password="******".format(**data),
)
else:
self.turn_off("{ip}".format(**data), "{idx}".format(**data))
elif command == "checkStatus":
if "username" in data and data["username"] != "":
self._domoticz_logger.debug(
"Using authentication for %s." % "{ip}".format(**data)
)
self.check_status(
"{ip}".format(**data),
"{idx}".format(**data),
username="******".format(**data),
password="******".format(**data),
)
else:
self.check_status("{ip}".format(**data), "{idx}".format(**data))
elif command == "connectPrinter":
self._domoticz_logger.debug("Connecting printer.")
self._printer.connect()
elif command == "disconnectPrinter":
self._domoticz_logger.debug("Disconnecting printer.")
self._printer.disconnect()
elif command == "sysCommand":
self._domoticz_logger.debug(
"Running system command %s." % "{cmd}".format(**data)
)
os.system("{cmd}".format(**data))
def on_api_command(self, command, data):
self._mylogger("called - {}".format(command), forceinfo=True)
if not user_permission.can():
self._mylogger("Insufficient rights {}".format(command),
forceinfo=True)
return make_response("Insufficient rights", 403)
cmd = command.lower()
if cmd == 'refreshfilamentstatus':
self._mylogger("Filament status update call")
self.reportfilamentstate()
if cmd == 'turnatxpsuoff':
self._mylogger("Turned Off Supply")
self.turnoff()
if cmd == 'turnatxpsuon':
self._mylogger("Turned On Supply")
self.turnon()
if cmd == 'issmartboard':
smartflag = 'true' if self._smartboard else 'false'
self._mylogger("sending IsSmartBoard {} ".format(smartflag),
forceinfo=True)
return make_response(smartflag)
if not self._smartboard:
return
if cmd == "toggleextswitch":
self._mylogger("Toggle External Switch")
self.toggle_extswitch()
if cmd == 'updateextswitch':
self._mylogger("Update External Switch PWM value")
data.pop('command', 0)
self._settings.set(['ExternalSwitchValue'],
int(data['ExternalSwitchValue']))
self._settings.save()
self.initialize_extswitch()
if cmd == 'updateled' and self._settings.getBoolean(['UseLEDS']):
if data['LEDRed'] > -1 and data['LEDGreen'] > -1 and data[
'LEDBlue'] > -1:
self._mylogger(
"Status Sent - {LEDRed} - {LEDGreen} - {LEDBlue}".format(
**data))
data.pop('command', 0)
self._settings.set(['LEDRed'], int(data['LEDRed']))
self._settings.set(['LEDGreen'], int(data['LEDGreen']))
self._settings.set(['LEDBlue'], int(data['LEDBlue']))
self._settings.set(['LEDBrightness'],
int(data['LEDBrightness']))
self._settings.save()
self.initialize_leds()
def on_api_command(self, command, data):
self._logger.debug("received an api_command: " + str(command) +" , "+ str(data["percentage"]))
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'dim':
call("gpio -g pwm " + str(self.pwmPin) + " " + str(data["percentage"]), shell=True) #pin, duty cycle
self.current_pwm_value= data["percentage"]
self._logger.debug("changed current_duty_cycle: " + str(self.current_pwm_value))
def on_api_command(self, command, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == 'turnoffPSU':
self.turn_psu_off()
elif command == 'turnPSUOff':
self.turn_psu_off()
elif command == 'getPSUState':
return jsonify(isPSUOn=self.isPSUOn)
def on_api_command(self, command, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == 'turnOn':
self.turn_on()
elif command == 'turnOff':
self.turn_off()
elif command == 'checkStatus':
self.check_status()
def on_api_command(self, command, data):
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'publishcommand':
try:
self.mqtt_publish("{topic}".format(**data), "{publishcommand}".format(**data))
self._plugin_manager.send_plugin_message(self._identifier, dict(topic="{topic}".format(**data),publishcommand="{publishcommand}".format(**data)))
except:
self._plugin_manager.send_plugin_message(self._identifier, dict(noMQTT=True))
def on_api_command(self, command, data):
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'turnOn':
self.turn_on("{ip}".format(**data))
elif command == 'turnOff':
self.turn_off("{ip}".format(**data))
elif command == 'checkStatus':
self.check_status("{ip}".format(**data))
def on_api_command(self, command, data):
self._logger.debug("received an api_command: " + str(command) + " , " +
str(data["percentage"]))
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'dim':
self.pwm_instance.ChangeDutyCycle(float(data["percentage"]))
self.current_pwm_value = data["percentage"]
self._logger.debug("changed current_duty_cycle: " +
str(self.current_pwm_value))
def on_api_command(self, command, data):
if command == "select":
if not user_permission.can():
return flask.abort(403, "Insufficient permissions")
if self._active is False:
return flask.abort(409, "No active prompt")
choice = data["choice"]
if not isinstance(choice, int) or not choice < 5 or not choice >= 0:
return flask.abort(400, "{!r} is not a valid value for filament choice".format(choice+1))
self._done_prompt("T" + str(choice))
def on_api_command(self, command, data):
if command == "select":
if not user_permission.can():
return flask.abort(403, "Insufficient permissions")
if self._prompt is None:
return flask.abort(409, "No active prompt")
choice = data["choice"]
if not isinstance(choice, int) or not self._prompt.validate_choice(choice):
return flask.abort(400, "{!r} is not a valid value for choice".format(choice))
self._answer_prompt(choice)
def on_api_command(self, command, data):
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'turnOn':
self.turn_on("{ip}".format(**data))
elif command == 'turnOff':
self.turn_off("{ip}".format(**data))
elif command == 'checkStatus':
self.check_status("{ip}".format(**data))
elif command == 'eufyDownload':
return self.eufy_download(data["username"], data["password"])
def on_api_command(self, command, data):
import flask
from octoprint.server import user_permission
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
if command == "crawl_files":
self._logger.debug("Crawling Files")
file_list = self._file_manager.list_files(recursive=True)
local_files = file_list["local"]
results = {'no_thumbnail': [], 'no_thumbnail_src': []}
for key, file in local_files.items():
results = self._process_gcode(local_files[key], results)
return flask.jsonify(results)
def on_api_command(self, command, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == 'turnfanOn':
self.turn_fan_on()
elif command == 'turnfanOff':
self.turn_fan_off()
elif command == 'togglefan':
if self.isfanOn:
self.turn_fan_off()
else:
self.turn_fan_on()
elif command == 'getfanState':
return jsonify(isfanOn=self.isfanOn)
def on_api_command(self, command, data):
if not user_permission.can():
return make_response("Insufficient rights", 403)
if command == 'turnPowerOn':
if not self.isPowerOn:
self.turn_power_on()
elif command == 'turnPowerOff':
if self.isPowerOn:
self.turn_power_off()
elif command == 'togglePower':
self.toggle_power()
elif command == 'turnLightOn':
self.turn_light_on()
elif command == 'getPowerState':
return jsonify(isPowerOn=self.isPowerOn)
def on_api_command(self, command, data):
import flask
import json
from octoprint.server import user_permission
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
if command == "crawl_files":
self._logger.debug("Crawling Files")
FileList = self._file_manager.list_files(recursive=True)
self._logger.info(FileList)
LocalFiles = FileList["local"]
results = dict(no_thumbnail=[], no_thumbnail_src=[])
for key, file in LocalFiles.items():
results = self._process_gcode(LocalFiles[key], results)
return flask.jsonify(results)
def on_api_command(self, command, data):
if not user_permission.can():
from flask import make_response
return make_response("Insufficient rights", 403)
if command == 'startStream':
self._logger.info("Start stream command received.")
self._start_stream()
if command == 'stopStream':
self._logger.info("Stop stream command received.")
self._stop_stream()
if command == 'checkStream':
self._logger.info("Checking stream status.")
self._check_stream()
def on_api_command(self, command, data):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
if command == 'turnOn':
response = self.turn_on("{ip}".format(**data))
self._plugin_manager.send_plugin_message(self._identifier,
response)
elif command == 'turnOff':
response = self.turn_off("{ip}".format(**data))
self._plugin_manager.send_plugin_message(self._identifier,
response)
elif command == 'checkStatus':
response = self.check_status("{ip}".format(**data))
else:
response = dict(ip=data.ip, currentState="unknown")
return flask.jsonify(response)
def on_api_get(self, request):
if not user_permission.can():
return flask.make_response("Insufficient rights", 403)
return flask.jsonify(self._warnings)
