mirror of
https://github.com/micahqcade/custom_vesync.git
synced 2025-02-11 09:39:00 +01:00
704 lines
23 KiB
Python
704 lines
23 KiB
Python
"""Etekcity Outlets."""
|
|
|
|
import json
|
|
import logging
|
|
import time
|
|
from abc import ABCMeta, abstractmethod
|
|
|
|
from .helpers import Helpers
|
|
from .vesyncbasedevice import VeSyncBaseDevice
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
outlet_config = {
|
|
"wifi-switch-1.3": {"module": "VeSyncOutlet7A"},
|
|
"ESW03-USA": {"module": "VeSyncOutlet10A"},
|
|
"ESW01-EU": {"module": "VeSyncOutlet10A"},
|
|
"ESW15-USA": {"module": "VeSyncOutlet15A"},
|
|
"ESO15-TB": {"module": "VeSyncOutdoorPlug"},
|
|
}
|
|
|
|
outlet_modules = {k: v["module"] for k, v in outlet_config.items()}
|
|
|
|
__all__ = list(outlet_modules.values()) + ["outlet_modules"]
|
|
|
|
|
|
class VeSyncOutlet(VeSyncBaseDevice):
|
|
"""Base class for Etekcity Outlets."""
|
|
|
|
__metaclass__ = ABCMeta
|
|
|
|
def __init__(self, details, manager):
|
|
"""Initialize VeSync Outlet base class."""
|
|
super().__init__(details, manager)
|
|
|
|
self.details = {}
|
|
self.energy = {}
|
|
self.update_energy_ts = None
|
|
self._energy_update_interval = manager.energy_update_interval
|
|
|
|
@property
|
|
def update_time_check(self) -> bool:
|
|
"""Test if energy update interval has been exceeded."""
|
|
if self.update_energy_ts is None:
|
|
return True
|
|
|
|
if (time.time() - self.update_energy_ts) > self._energy_update_interval:
|
|
return True
|
|
return False
|
|
|
|
@abstractmethod
|
|
def turn_on(self) -> bool:
|
|
"""Return True if device has beeeen turned on."""
|
|
|
|
@abstractmethod
|
|
def turn_off(self) -> bool:
|
|
"""Return True if device has beeeen turned off."""
|
|
|
|
@abstractmethod
|
|
def get_details(self) -> None:
|
|
"""Build details dictionary."""
|
|
|
|
@abstractmethod
|
|
def get_weekly_energy(self) -> None:
|
|
"""Build weekly energy history dictionary."""
|
|
|
|
@abstractmethod
|
|
def get_monthly_energy(self) -> None:
|
|
"""Build Monthly Energy History Dictionary."""
|
|
|
|
@abstractmethod
|
|
def get_yearly_energy(self):
|
|
"""Build Yearly Energy Dictionary."""
|
|
|
|
@abstractmethod
|
|
def get_config(self):
|
|
"""Get configuration and firmware details."""
|
|
|
|
def update(self):
|
|
"""Get Device Energy and Status."""
|
|
self.get_details()
|
|
|
|
def update_energy(self, bypass_check: bool = False):
|
|
"""Build weekly, monthly and yearly dictionaries."""
|
|
if bypass_check or self.update_time_check:
|
|
self.update_energy_ts = time.time()
|
|
self.get_weekly_energy()
|
|
if "week" in self.energy:
|
|
self.get_monthly_energy()
|
|
self.get_yearly_energy()
|
|
if not bypass_check:
|
|
self.update_energy_ts = time.time()
|
|
|
|
@property
|
|
def active_time(self) -> int:
|
|
"""Return active time of a device in minutes."""
|
|
return self.details.get("active_time", 0)
|
|
|
|
@property
|
|
def energy_today(self) -> float:
|
|
"""Return energy."""
|
|
return self.details.get("energy", 0)
|
|
|
|
@property
|
|
def power(self) -> float:
|
|
"""Return current power in watts."""
|
|
return float(self.details.get("power", 0))
|
|
|
|
@property
|
|
def voltage(self) -> float:
|
|
"""Return current voltage."""
|
|
return float(self.details.get("voltage", 0))
|
|
|
|
@property
|
|
def monthly_energy_total(self) -> float:
|
|
"""Return total energy usage over the month."""
|
|
return self.energy.get("month", {}).get("total_energy", 0)
|
|
|
|
@property
|
|
def weekly_energy_total(self) -> float:
|
|
"""Return total energy usage over the week."""
|
|
return self.energy.get("week", {}).get("total_energy", 0)
|
|
|
|
@property
|
|
def yearly_energy_total(self) -> float:
|
|
"""Return total energy usage over the year."""
|
|
return self.energy.get("year", {}).get("total_energy", 0)
|
|
|
|
def display(self):
|
|
"""Return formatted device info to stdout."""
|
|
super().display()
|
|
disp1 = [
|
|
("Active Time : ", self.active_time, " minutes"),
|
|
("Energy: ", self.energy_today, " kWh"),
|
|
("Power: ", self.power, " Watts"),
|
|
("Voltage: ", self.voltage, " Volts"),
|
|
("Energy Week: ", self.weekly_energy_total, " kWh"),
|
|
("Energy Month: ", self.monthly_energy_total, " kWh"),
|
|
("Energy Year: ", self.yearly_energy_total, " kWh"),
|
|
]
|
|
for line in disp1:
|
|
print(f"{line[0]:.<15} {line[1]} {line[2]}")
|
|
|
|
def displayJSON(self):
|
|
"""Return JSON details for outlet."""
|
|
sup = super().displayJSON()
|
|
sup_val = json.loads(sup)
|
|
sup_val.update(
|
|
{
|
|
"Active Time": str(self.active_time),
|
|
"Energy": str(self.energy_today),
|
|
"Power": str(self.power),
|
|
"Voltage": str(self.voltage),
|
|
"Energy Week": str(self.weekly_energy_total),
|
|
"Energy Month": str(self.monthly_energy_total),
|
|
"Energy Year": str(self.yearly_energy_total),
|
|
}
|
|
)
|
|
|
|
return sup_val
|
|
|
|
|
|
class VeSyncOutlet7A(VeSyncOutlet):
|
|
"""Etekcity 7A Round Outlet Class."""
|
|
|
|
def __init__(self, details, manager):
|
|
"""Initialize Etekcity 7A round outlet class."""
|
|
super().__init__(details, manager)
|
|
self.det_keys = ["deviceStatus", "activeTime", "energy", "power", "voltage"]
|
|
self.energy_keys = ["energyConsumptionOfToday", "maxEnergy", "totalEnergy"]
|
|
|
|
def get_details(self) -> None:
|
|
"""Get 7A outlet details."""
|
|
r, _ = Helpers.call_api(
|
|
f"/v1/device/{self.cid}/detail",
|
|
"get",
|
|
headers=Helpers.req_headers(self.manager),
|
|
)
|
|
|
|
if r is not None and all(x in r for x in self.det_keys):
|
|
self.device_status = r.get("deviceStatus", self.device_status)
|
|
self.details["active_time"] = r.get("activeTime", 0)
|
|
self.details["energy"] = r.get("energy", 0)
|
|
power = r.get("power", "0:0")
|
|
power = round(float(Helpers.calculate_hex(power)), 2)
|
|
self.details["power"] = power
|
|
voltage = r.get("voltage", "0:0")
|
|
voltage = round(float(Helpers.calculate_hex(voltage)), 2)
|
|
self.details["voltage"] = voltage
|
|
else:
|
|
logger.debug("Unable to get %s details", self.device_name)
|
|
|
|
def get_weekly_energy(self) -> None:
|
|
"""Get 7A outlet weekly energy info and build weekly energy dict."""
|
|
r, _ = Helpers.call_api(
|
|
f"/v1/device/{self.cid}/energy/week",
|
|
"get",
|
|
headers=Helpers.req_headers(self.manager),
|
|
)
|
|
|
|
if r is not None and all(x in r for x in self.energy_keys):
|
|
self.energy["week"] = Helpers.build_energy_dict(r)
|
|
else:
|
|
logger.debug("Unable to get %s weekly data", self.device_name)
|
|
|
|
def get_monthly_energy(self) -> None:
|
|
"""Get 7A outlet monthly energy info and build monthly energy dict."""
|
|
r, _ = Helpers.call_api(
|
|
f"/v1/device/{self.cid}/energy/month",
|
|
"get",
|
|
headers=Helpers.req_headers(self.manager),
|
|
)
|
|
|
|
if r is not None and all(x in r for x in self.energy_keys):
|
|
self.energy["month"] = Helpers.build_energy_dict(r)
|
|
else:
|
|
logger.warning("Unable to get %s monthly data", self.device_name)
|
|
|
|
def get_yearly_energy(self) -> None:
|
|
"""Get 7A outlet yearly energy info and build yearly energy dict."""
|
|
r, _ = Helpers.call_api(
|
|
f"/v1/device/{self.cid}/energy/year",
|
|
"get",
|
|
headers=Helpers.req_headers(self.manager),
|
|
)
|
|
|
|
if r is not None and all(x in r for x in self.energy_keys):
|
|
self.energy["year"] = Helpers.build_energy_dict(r)
|
|
else:
|
|
logger.debug("Unable to get %s yearly data", self.device_name)
|
|
|
|
def turn_on(self) -> bool:
|
|
"""Turn 7A outlet on - return True if successful."""
|
|
return self._toggle("on")
|
|
|
|
def turn_off(self) -> bool:
|
|
"""Turn 7A outlet off - return True if successful."""
|
|
return self._toggle("off")
|
|
|
|
def _toggle(self, state):
|
|
_, status_code = Helpers.call_api(
|
|
f"/v1/wifi-switch-1.3/{self.cid}/status/{state}",
|
|
"put",
|
|
headers=Helpers.req_headers(self.manager),
|
|
)
|
|
|
|
if status_code is not None and status_code == 200:
|
|
self.device_status = state
|
|
return True
|
|
logger.warning("Error turning %s %s", self.device_name, state)
|
|
return False
|
|
|
|
def get_config(self) -> None:
|
|
"""Get 7A outlet configuration info."""
|
|
r, _ = Helpers.call_api(
|
|
f"/v1/device/{self.cid}/configurations",
|
|
"get",
|
|
headers=Helpers.req_headers(self.manager),
|
|
)
|
|
|
|
if "currentFirmVersion" in r:
|
|
self.config = Helpers.build_config_dict(r)
|
|
else:
|
|
logger.debug("Error getting configuration info for %s", self.device_name)
|
|
|
|
|
|
class VeSyncOutlet10A(VeSyncOutlet):
|
|
"""Etekcity 10A Round Outlets."""
|
|
|
|
def __init__(self, details, manager):
|
|
"""Initialize 10A outlet class."""
|
|
super().__init__(details, manager)
|
|
|
|
def get_details(self) -> None:
|
|
"""Get 10A outlet details."""
|
|
body = Helpers.req_body(self.manager, "devicedetail")
|
|
body["uuid"] = self.uuid
|
|
|
|
r, _ = Helpers.call_api(
|
|
"/10a/v1/device/devicedetail",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(r):
|
|
self.device_status = r.get("deviceStatus", self.device_status)
|
|
self.connection_status = r.get("connectionStatus", self.connection_status)
|
|
self.details = Helpers.build_details_dict(r)
|
|
else:
|
|
logger.debug("Unable to get %s details", self.device_name)
|
|
|
|
def get_config(self) -> None:
|
|
"""Get 10A outlet configuration info."""
|
|
body = Helpers.req_body(self.manager, "devicedetail")
|
|
body["method"] = "configurations"
|
|
body["uuid"] = self.uuid
|
|
|
|
r, _ = Helpers.call_api(
|
|
"/10a/v1/device/configurations",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(r):
|
|
self.config = Helpers.build_config_dict(r)
|
|
else:
|
|
logger.debug("Error getting %s config info", self.device_name)
|
|
|
|
def get_weekly_energy(self) -> None:
|
|
"""Get 10A outlet weekly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_week")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/10a/v1/device/energyweek",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["week"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s weekly data", self.device_name)
|
|
|
|
def get_monthly_energy(self) -> None:
|
|
"""Get 10A outlet monthly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_month")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/10a/v1/device/energymonth",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["month"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s monthly data", self.device_name)
|
|
|
|
def get_yearly_energy(self) -> None:
|
|
"""Get 10A outlet yearly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_year")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/10a/v1/device/energyyear",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["year"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s yearly data", self.device_name)
|
|
|
|
def turn_on(self) -> bool:
|
|
"""Turn 10A outlet on - return True if successful."""
|
|
body = Helpers.req_body(self.manager, "devicestatus")
|
|
body["uuid"] = self.uuid
|
|
body["status"] = "on"
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/10a/v1/device/devicestatus",
|
|
"put",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.device_status = "on"
|
|
return True
|
|
logger.warning("Error turning %s on", self.device_name)
|
|
return False
|
|
|
|
def turn_off(self) -> bool:
|
|
"""Turn 10A outlet off - return True if successful."""
|
|
body = Helpers.req_body(self.manager, "devicestatus")
|
|
body["uuid"] = self.uuid
|
|
body["status"] = "off"
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/10a/v1/device/devicestatus",
|
|
"put",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.device_status = "off"
|
|
return True
|
|
logger.warning("Error turning %s off", self.device_name)
|
|
return False
|
|
|
|
|
|
class VeSyncOutlet15A(VeSyncOutlet):
|
|
"""Class for Etekcity 15A Rectangular Outlets."""
|
|
|
|
def __init__(self, details, manager):
|
|
"""Initialize 15A rectangular outlets."""
|
|
super().__init__(details, manager)
|
|
self.nightlight_status = "off"
|
|
self.nightlight_brightness = 0
|
|
|
|
def get_details(self) -> None:
|
|
"""Get 15A outlet details."""
|
|
body = Helpers.req_body(self.manager, "devicedetail")
|
|
body["uuid"] = self.uuid
|
|
|
|
r, _ = Helpers.call_api(
|
|
"/15a/v1/device/devicedetail",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
attr_list = (
|
|
"deviceStatus",
|
|
"activeTime",
|
|
"energy",
|
|
"power",
|
|
"voltage",
|
|
"nightLightStatus",
|
|
"nightLightAutomode",
|
|
"nightLightBrightness",
|
|
)
|
|
|
|
if Helpers.code_check(r) and all(k in r for k in attr_list):
|
|
|
|
self.device_status = r.get("deviceStatus")
|
|
self.connection_status = r.get("connectionStatus")
|
|
self.nightlight_status = r.get("nightLightStatus")
|
|
self.nightlight_brightness = r.get("nightLightBrightness")
|
|
self.details = Helpers.build_details_dict(r)
|
|
else:
|
|
logger.debug("Unable to get %s details", self.device_name)
|
|
|
|
def get_config(self) -> None:
|
|
"""Get 15A outlet configuration info."""
|
|
body = Helpers.req_body(self.manager, "devicedetail")
|
|
body["method"] = "configurations"
|
|
body["uuid"] = self.uuid
|
|
|
|
r, _ = Helpers.call_api(
|
|
"/15a/v1/device/configurations",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(r):
|
|
self.config = Helpers.build_config_dict(r)
|
|
else:
|
|
logger.debug("Unable to get %s config info", self.device_name)
|
|
|
|
def get_weekly_energy(self) -> None:
|
|
"""Get 15A outlet weekly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_week")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/15a/v1/device/energyweek",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["week"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s weekly data", self.device_name)
|
|
|
|
def get_monthly_energy(self) -> None:
|
|
"""Get 15A outlet monthly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_month")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/15a/v1/device/energymonth",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["month"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s monthly data", self.device_name)
|
|
|
|
def get_yearly_energy(self) -> None:
|
|
"""Get 15A outlet yearly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_year")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/15a/v1/device/energyyear",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["year"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s yearly data", self.device_name)
|
|
|
|
def turn_on(self) -> bool:
|
|
"""Turn 15A outlet on - return True if successful."""
|
|
body = Helpers.req_body(self.manager, "devicestatus")
|
|
body["uuid"] = self.uuid
|
|
body["status"] = "on"
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/15a/v1/device/devicestatus",
|
|
"put",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.device_status = "on"
|
|
return True
|
|
logger.warning("Error turning %s on", self.device_name)
|
|
return False
|
|
|
|
def turn_off(self) -> bool:
|
|
"""Turn 15A outlet off - return True if successful."""
|
|
body = Helpers.req_body(self.manager, "devicestatus")
|
|
body["uuid"] = self.uuid
|
|
body["status"] = "off"
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/15a/v1/device/devicestatus",
|
|
"put",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.device_status = "off"
|
|
return True
|
|
|
|
logger.warning("Error turning %s off", self.device_name)
|
|
return False
|
|
|
|
def turn_on_nightlight(self) -> bool:
|
|
"""Turn on nightlight."""
|
|
return self._extracted_from_turn_off_nightlight_3("auto")
|
|
|
|
def turn_off_nightlight(self) -> bool:
|
|
"""Turn Off Nightlight."""
|
|
return self._extracted_from_turn_off_nightlight_3("manual")
|
|
|
|
def _extracted_from_turn_off_nightlight_3(self, mode):
|
|
body = Helpers.req_body(self.manager, "devicestatus")
|
|
body["uuid"] = self.uuid
|
|
body["mode"] = mode
|
|
response, _ = Helpers.call_api(
|
|
"/15a/v1/device/nightlightstatus",
|
|
"put",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
return True
|
|
logger.debug(
|
|
"Error turning %s %s nightlight",
|
|
"on" if mode == "auto" else "off",
|
|
self.device_name,
|
|
)
|
|
return False
|
|
|
|
|
|
class VeSyncOutdoorPlug(VeSyncOutlet):
|
|
"""Class to hold Etekcity outdoor outlets."""
|
|
|
|
def __init__(self, details, manager):
|
|
"""Initialize Etekcity Outdoor Plug class."""
|
|
super().__init__(details, manager)
|
|
|
|
def get_details(self) -> None:
|
|
"""Get details for outdoor outlet."""
|
|
body = Helpers.req_body(self.manager, "devicedetail")
|
|
body["uuid"] = self.uuid
|
|
r, _ = Helpers.call_api(
|
|
"/outdoorsocket15a/v1/device/devicedetail",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(r):
|
|
self.details = Helpers.build_details_dict(r)
|
|
self.connection_status = r.get("connectionStatus")
|
|
|
|
dev_no = self.sub_device_no
|
|
sub_device_list = r.get("subDevices")
|
|
if sub_device_list and dev_no <= len(sub_device_list):
|
|
self.device_status = sub_device_list[(dev_no + -1)].get(
|
|
"subDeviceStatus"
|
|
)
|
|
return
|
|
logger.debug("Unable to get %s details", self.device_name)
|
|
|
|
def get_config(self) -> None:
|
|
"""Get configuration info for outdoor outlet."""
|
|
body = Helpers.req_body(self.manager, "devicedetail")
|
|
body["method"] = "configurations"
|
|
body["uuid"] = self.uuid
|
|
|
|
r, _ = Helpers.call_api(
|
|
"/outdoorsocket15a/v1/device/configurations",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(r):
|
|
self.config = Helpers.build_config_dict(r)
|
|
logger.debug("Error getting %s config info", self.device_name)
|
|
|
|
def get_weekly_energy(self) -> None:
|
|
"""Get outdoor outlet weekly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_week")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/outdoorsocket15a/v1/device/energyweek",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["week"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s weekly data", self.device_name)
|
|
|
|
def get_monthly_energy(self) -> None:
|
|
"""Get outdoor outlet monthly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_month")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/outdoorsocket15a/v1/device/energymonth",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["month"] = Helpers.build_energy_dict(response)
|
|
logger.debug("Unable to get %s monthly data", self.device_name)
|
|
|
|
def get_yearly_energy(self) -> None:
|
|
"""Get outdoor outlet yearly energy info and populate energy dict."""
|
|
body = Helpers.req_body(self.manager, "energy_year")
|
|
body["uuid"] = self.uuid
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/outdoorsocket15a/v1/device/energyyear",
|
|
"post",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.energy["year"] = Helpers.build_energy_dict(response)
|
|
else:
|
|
logger.debug("Unable to get %s yearly data", self.device_name)
|
|
|
|
def toggle(self, status) -> bool:
|
|
"""Toggle power for outdoor outlet."""
|
|
body = Helpers.req_body(self.manager, "devicestatus")
|
|
body["uuid"] = self.uuid
|
|
body["status"] = status
|
|
body["switchNo"] = self.sub_device_no
|
|
|
|
response, _ = Helpers.call_api(
|
|
"/outdoorsocket15a/v1/device/devicestatus",
|
|
"put",
|
|
headers=Helpers.req_headers(self.manager),
|
|
json=body,
|
|
)
|
|
|
|
if Helpers.code_check(response):
|
|
self.device_status = status
|
|
return True
|
|
logger.warning("Error turning %s %s", self.device_name, status)
|
|
return False
|
|
|
|
def turn_on(self) -> bool:
|
|
"""Turn outdoor outlet on and return True if successful."""
|
|
return bool(self.toggle("on"))
|
|
|
|
def turn_off(self) -> bool:
|
|
"""Turn outdoor outlet off and return True if successful."""
|
|
return bool(self.toggle("off"))
|