added files

matthiaslexer · matthiaslexer · commit 6a6d5b974de5 · 2021-02-26T11:51:07.000+01:00
diff --git a/custom_components/weback/weback_unofficial/__init__.py b/custom_components/weback/weback_unofficial/__init__.py
diff --git a/custom_components/weback/weback_unofficial/client.py b/custom_components/weback/weback_unofficial/client.py
@@ -0,0 +1,193 @@
+import requests
+import datetime
+import boto3 
+import json
+from hashlib import md5
+
+
+class WebackApi(object):
+
+    # boto3 session object
+    aws_session = None
+    aws_identity_id = None
+
+    # Expiration time of session
+    expiration_time = None
+
+    # Creds for WeBack API
+    __api_login = None
+    __api_password = None
+    __api_country_code = None
+
+    def __init__(self, login: str = None, password: str = None, country_code: str = None, aws_session: boto3.Session = None, aws_session_expiration: int = None):
+        self.aws_session = aws_session
+        self.aws_session_expiration = None
+        self.__api_login = login
+        self.__api_password = password
+        self.__api_country_code = country_code
+
+    def auth(self, login: str = None, password: str = None) -> dict:
+        if login is None:
+            if self.__api_login is None:
+                raise Exception(
+                    "Login is not provided via params or class constructor")
+            if self.__api_country_code is None:
+                login = self.__api_login
+            else:
+                login = f"+{self.__api_country_code}-{self.__api_login}"
+        if password is None:
+            if self.__api_password is None:
+                raise Exception(
+                    "Password is not provided via params or class constructor")
+            password = self.__api_password
+
+        req = {
+            "App_Version": "android_3.9.3",
+            "Password": md5(password.encode('utf-8')).hexdigest(),
+            "User_Account": login
+        }
+        r = requests.post(
+            'https://www.weback-login.com/WeBack/WeBack_Login_Ats_V3', json=req)
+        resp_content = r.json()
+        return resp_content
+
+    def auth_cognito(self, region: str, identity_id: str, token: str) -> dict:
+        cl = boto3.client('cognito-identity', region)
+        aws_creds = cl.get_credentials_for_identity(
+            IdentityId=identity_id,
+            Logins={
+                "cognito-identity.amazonaws.com": token
+            }
+        )
+        return aws_creds
+
+    def make_session_from_cognito(self, aws_creds: dict, region: str) -> boto3.Session:
+        session = boto3.Session(
+            aws_access_key_id=aws_creds['Credentials']['AccessKeyId'],
+            aws_secret_access_key=aws_creds['Credentials']['SecretKey'],
+            aws_session_token=aws_creds['Credentials']['SessionToken'],
+            region_name=region
+        )
+        return session
+
+    def device_list(self, session: boto3.Session = None, identity_id: str = None):
+        if (session == None):
+            session = self.get_session()
+            identity_id = self.aws_identity_id
+        
+        client = session.client('lambda')
+        resp =  client.invoke(
+            FunctionName='Device_Manager_V2',
+            InvocationType="RequestResponse",
+            Payload= json.dumps({
+                "Device_Manager_Request":"query",
+                "Identity_Id": self.aws_identity_id,
+                "Region_Info": session.region_name
+            })
+        )
+        payload = json.loads(resp['Payload'].read())
+        return payload['Request_Cotent']
+
+    def get_device_description(self, device_name, session = None):
+        if (session == None):
+            session = self.get_session()
+        client = session.client('iot')
+        resp = client.describe_thing(thingName=device_name)
+        return resp
+
+    def get_endpoint(self, session):
+        iot_client = session.client('iot')
+        return "https://" + iot_client.describe_endpoint(endpointType="iot:Data-ATS").get("endpointAddress")
+
+    def get_device_shadow(self, device_name, session = None, return_full = False):
+        if (session == None):
+            session = self.get_session()
+        client = session.client('iot-data', endpoint_url=self.get_endpoint(session))
+        resp = client.get_thing_shadow(thingName=device_name)
+        shadow = json.loads(resp['payload'].read())
+        if return_full:
+            return shadow
+        return shadow['state']['reported']
+
+    def publish_device_msg(self, device_name, desired_payload = {}, session = None):
+        if (session == None):
+            session = self.get_session()
+        client = session.client('iot-data', endpoint_url=self.get_endpoint(session))
+        topic = f"$aws/things/{device_name}/shadow/update"
+        payload = {
+            'state': {
+                'desired': desired_payload
+            }
+        }
+        resp = client.publish(topic=topic, qos = 0, payload = json.dumps(payload))
+        return resp
+
+    def is_renewal_required(self):
+        return True if (self.expiration_time < datetime.datetime.now(self.expiration_time.tzinfo)) else False
+
+    def get_session(self) -> boto3.Session:
+        if self.aws_session and not self.is_renewal_required():
+            return self.aws_session
+
+        if not self.__api_login or not self.__api_password:
+            raise Exception("You should provide login and password via constructor to use session management")
+        
+        weback_data = self.auth()
+        if weback_data['Request_Result'] != 'success':
+            raise Exception(f"Could not authenticate. {weback_data['Fail_Reason']}")
+
+        region = weback_data['Region_Info']
+        self.aws_identity_id = weback_data['Identity_Id']
+
+        aws_creds = self.auth_cognito(
+            region, weback_data['Identity_Id'], weback_data['Token'])
+        self.expiration_time = aws_creds['Credentials'].get('Expiration')
+
+        sess = self.make_session_from_cognito(aws_creds, region)
+        self.aws_session = sess
+        return sess
+
+class BaseDevice(object):
+    client: WebackApi = None
+    name: str = None
+    shadow: list = {}
+    _description: dict = None
+    nickname: str = None
+
+    def __init__(self, name: str, client: WebackApi, shadow: list = None, description = None, nickname = None):
+        super().__init__()
+        self.client = client
+        self.name = name
+        self.description = description
+        self.nickname = nickname if nickname is not None else self.name
+
+        if (shadow):
+            self.shadow = shadow
+
+    def update(self):
+        """Update device state"""
+        shadow = self.client.get_device_shadow(self.name)
+        self.shadow = shadow
+        return self
+
+    def description(self):
+        """Get Amazon IoT device description"""
+        if (self._description is not None):
+            return self.description
+        description = self.client.get_device_description(self.name)
+        self._description = description
+        return description
+    
+    def publish(self, desired_payload):
+        """Publish 'desired' payload via MQTT"""
+        resp = self.client.publish_device_msg(self.name, desired_payload)
+        return resp
+    
+    def publish_single(self, attribute, value):
+        """Publish single attribute via MQTT."""
+        return self.publish({attribute: value})
+    
+    def raise_invalid_value(self, valid):
+        """Helper: prevent publish unsupported values."""
+        raise Exception("Only this set of values supported: %s" % ", ".join(valid))
+
diff --git a/custom_components/weback/weback_unofficial/thermostat.py b/custom_components/weback/weback_unofficial/thermostat.py
@@ -0,0 +1,82 @@
+from weback_unofficial.client import WebackApi, BaseDevice
+
+# uses a weekly plan (Mon, Tues, Wed, Thur, Fri, Sat, Sun)
+AUTO = 'auto'
+# uses the temperature you set in the set_temp property
+MANUAL = 'hand'
+
+WORKING_MODES = {AUTO, MANUAL}
+# temperature is always times two (e.g. 25 degrees = 50 degrees in shadow object)
+TEMP_MULTIPLIER = 2
+
+# temperature is given like 250, which means 25.0 degrees
+TEMP_DISPLAY_DIVIDER = 10
+
+CURRENT_TEMPERATURE = 'air_tem'
+GOAL_TEMPERATURE = 'set_tem'
+CONNECTED = 'connected'
+WORKMODE = 'workmode'
+WORKING_STATUS = 'working_status'
+
+
+class Thermostat(BaseDevice):
+    def __init__(self, name, client, shadow=None, description=None, nickname=None):
+        super().__init__(name, client, shadow=shadow, description=description, nickname=nickname)
+
+    def setMode(self, mode: str):
+        if not mode in WORKING_MODES:
+            self.raise_invalid_value(WORKING_MODES)
+        self.publish_single('workmode', mode)
+
+    def setTemp(self, temp: str):
+        self.setMode(MANUAL)
+        self.publish_single('set_tem', temp * TEMP_MULTIPLIER)
+
+
+    @property
+    def is_available(self):
+        return True if self.shadow.get(CONNECTED) == 'false' else True
+
+    @property
+    def mode(self):
+        return self.shadow.get(WORKMODE)
+
+    @property
+    def temperature(self):
+        return self.shadow.get(CURRENT_TEMPERATURE) / TEMP_DISPLAY_DIVIDER
+
+    @property
+    def goal_temperature(self):
+        return self.shadow.get(GOAL_TEMPERATURE) / TEMP_MULTIPLIER
+
+    @property
+    def is_heating(self):
+        return True if self.shadow.get(WORKING_STATUS) == 'on' else False    
+
+    @property
+    def autosettings(self):
+        return {
+            "Mon": self.format_auto_settings('Mon'),
+            "Tue": self.format_auto_settings('Tues'),
+            "Wed": self.format_auto_settings('Wed'),
+            "Thu": self.format_auto_settings('Thur'),
+            "Fri": self.format_auto_settings('Fri'),
+            "Sat": self.format_auto_settings('Sat'),
+            "Sun": self.format_auto_settings('Sun')
+        }
+
+    # the shadow object includes a string for every day where the actions are concatenated
+    # this function is used to split them up
+    # input: "04:50_043C,08:00_030C,17:00_043C,20:00_030C,20:00_030C,20:00_030C"
+    # output: [
+    #     "04:50_043C",
+    #     "08:00_030C",
+    #     "17:00_043C",
+    #     "20:00_030C",
+    #     "20:00_030C",
+    #     "20:00_030C"
+    # ]
+    def format_auto_settings(self, day):
+        command_string = self.shadow.get(day)
+        commands = command_string.split(',')
+        return commands
diff --git a/custom_components/weback/weback_unofficial/vacuum.py b/custom_components/weback/weback_unofficial/vacuum.py
@@ -0,0 +1,121 @@
+from weback_unofficial.client import WebackApi, BaseDevice
+
+CLEAN_MODE_AUTO = 'AutoClean'
+CLEAN_MODE_EDGE = 'EdgeClean'
+CLEAN_MODE_SPOT = 'SpotClean'
+CLEAN_MODE_SINGLE_ROOM = 'RoomClean'
+CLEAN_MODE_MOP = 'MopClean'
+CLEAN_MODE_STOP = 'Standby'
+CLEAN_MODE_SMART = 'SmartClean'
+
+FAN_DISABLED = 'Pause'
+FAN_SPEED_QUIET = 'Quiet'
+FAN_SPEED_NORMAL = 'Normal'
+FAN_SPEED_HIGH = 'Strong'
+FAN_SPEEDS = {FAN_SPEED_QUIET, FAN_SPEED_NORMAL, FAN_SPEED_HIGH}
+
+CHARGE_MODE_RETURNING = 'BackCharging'
+CHARGE_MODE_CHARGING = 'Charging'
+CHARGE_MODE_DOCK_CHARGING = 'PileCharging'
+CHARGE_MODE_DIRECT_CHARGING = 'DirCharging'
+CHARGE_MODE_IDLE = 'Hibernating'
+
+MOP_DISABLED = 'None'
+MOP_SPEED_LOW = 'Low'
+MOP_SPEED_NORMAL = 'Default'
+MOP_SPEED_HIGH = 'High'
+MOP_SPEEDS = {MOP_SPEED_LOW, MOP_SPEED_NORMAL, MOP_SPEED_HIGH}
+
+ROBOT_ERROR = "Malfunction"
+
+CLEANING_STATES = {CLEAN_MODE_AUTO, CLEAN_MODE_EDGE, CLEAN_MODE_SPOT, CLEAN_MODE_SINGLE_ROOM, CLEAN_MODE_MOP, CLEAN_MODE_SMART}
+CHARGING_STATES = {CHARGE_MODE_CHARGING, CHARGE_MODE_DOCK_CHARGING, CHARGE_MODE_DIRECT_CHARGING}
+DOCKED_STATES = {CHARGE_MODE_IDLE, CHARGE_MODE_CHARGING, CHARGE_MODE_DOCK_CHARGING, CHARGE_MODE_DIRECT_CHARGING}
+
+class CleanRobot(BaseDevice):
+    def __init__(self, name, client, shadow=None, description=None, nickname=None):
+        super().__init__(name, client, shadow=shadow, description=description, nickname=nickname)
+
+    def turn_on(self):
+        return self.publish_single('working_status', CLEAN_MODE_AUTO)
+
+    def turn_off(self):
+        return self.publish_single('working_status', CHARGE_MODE_RETURNING)
+
+    def return_home(self):
+        return self.turn_off()
+
+    def stop(self):
+        return self.publish_single('working_status', CLEAN_MODE_STOP)
+
+    def setFan(self, mode: str):
+        if not mode in FAN_SPEEDS:
+            self.raise_invalid_value(FAN_SPEEDS)
+        
+        self.publish_single('fan_status', mode)
+    
+    def setMop(self, mode: str):
+        if not mode in MOP_SPEEDS:
+            self.raise_invalid_value(MOP_SPEEDS)
+        self.publish_single('water_level', mode)
+
+    @property
+    def is_available(self):
+        return True if self.shadow.get('connected') == 'false' else True
+
+    @property
+    def clean_tine(self) -> int:
+        return self.shadow.get('clean_time')
+
+    @property
+    def battery_level(self) -> int:
+        return self.shadow.get('battery_level')
+
+    @property
+    def current_mode(self) -> str:
+        return self.shadow.get('working_status')
+
+    @property
+    def error(self) -> str:
+        return self.shadow.get('error_info')
+
+    @property
+    def is_cleaning(self) -> bool:
+        return True if self.current_mode in CLEANING_STATES else False
+    
+    @property
+    def is_docked(self) -> bool:
+        return True if self.current_mode in DOCKED_STATES else False
+    
+    @property
+    def is_paused(self) -> bool:
+        return True if self.current_mode == CLEAN_MODE_STOP else False
+    
+    @property
+    def is_idle(self) -> bool:
+        return not (self.is_docked or self.is_cleaning or self.is_paused \
+            or self.is_returning or self.is_error)
+    
+    @property
+    def is_returning(self) -> bool:
+        return True if self.current_mode == CHARGE_MODE_RETURNING else False
+
+    @property
+    def is_error(self) -> bool:
+        return True if self.current_mode == ROBOT_ERROR else False
+
+    @property
+    def state(self):
+        if self.current_mode == None:
+            return 'unknown'
+        if self.is_error:
+            return 'error'
+        if self.is_cleaning:
+            return 'cleaning'
+        if self.is_docked:
+            return 'docked'
+        if self.is_returning:
+            return 'returning'
+        if self.is_paused:
+            return 'paused'
+        return 'idle'
