Merge branch 'fronzbot:dev' into dev

Author: austinc3030

blinkapp/blinkapp.py

@@ -9,7 +9,7 @@
 from blinkpy.helpers.util import json_load
 
 CREDFILE = environ.get("CREDFILE")
-TIMEDELTA = timedelta(environ.get("TIMEDELTA", "1"))
+TIMEDELTA = timedelta(int(environ.get("TIMEDELTA", "1")))
 
 
 def get_date():

blinkpy/api.py

@@ -9,7 +9,15 @@
     Throttle,
     local_storage_clip_url_template,
 )
-from blinkpy.helpers.constants import DEFAULT_URL, TIMEOUT, DEFAULT_USER_AGENT
+from blinkpy.helpers.constants import (
+    TIMEOUT,
+    DEFAULT_USER_AGENT,
+    OAUTH_CLIENT_ID,
+    OAUTH_GRANT_TYPE_PASSWORD,
+    OAUTH_GRANT_TYPE_REFRESH_TOKEN,
+    OAUTH_SCOPE,
+)
+from urllib.parse import urlencode
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,32 +30,44 @@ async def request_login(
     auth,
     url,
     login_data,
+    is_refresh=False,
     is_retry=False,
 ):
     """
-    Login request.
+    OAuth login request.
 
     :param auth: Auth instance.
     :param url: Login url.
     :param login_data: Dictionary containing blink login data.
     :param is_retry:
+    :param two_fa_code: 2FA code if required
     """
+
     headers = {
-        "Host": DEFAULT_URL,
-        "Content-Type": "application/json",
-        "user-agent": DEFAULT_USER_AGENT,
+        "Content-Type": "application/x-www-form-urlencoded",
+        "User-Agent": DEFAULT_USER_AGENT,
+        "hardware_id": login_data.get("device_id", "Blinkpy"),
     }
 
-    data = dumps(
-        {
-            "email": login_data["username"],
-            "password": login_data["password"],
-            "unique_id": login_data["uid"],
-            "device_identifier": login_data["device_id"],
-            "client_name": "Computer",
-            "reauth": True,
-        }
-    )
+    # Add 2FA code to headers if provided
+    if "2fa_code" in login_data:
+        headers["2fa-code"] = login_data["2fa_code"]
+
+    # Prepare form data for OAuth
+    form_data = {
+        "username": login_data["username"],
+        "client_id": OAUTH_CLIENT_ID,
+        "scope": OAUTH_SCOPE,
+    }
+
+    if is_refresh:
+        form_data["grant_type"] = OAUTH_GRANT_TYPE_REFRESH_TOKEN
+        form_data["refresh_token"] = auth._refresh_token
+    else:
+        form_data["grant_type"] = OAUTH_GRANT_TYPE_PASSWORD
+        form_data["password"] = login_data["password"]
+
+    data = urlencode(form_data)
 
     return await auth.query(
         url=url,
@@ -56,23 +76,23 @@ async def request_login(
         json_resp=False,
         reqtype="post",
         is_retry=is_retry,
+        skip_refresh_check=True,
     )
 
 
-async def request_verify(auth, blink, verify_key):
-    """Send verification key to blink servers."""
-    url = (
-        f"{blink.urls.base_url}/api/v5/accounts/{blink.account_id}"
-        f"/users/{blink.auth.user_id}"
-        f"/clients/{blink.client_id}/client_verification/pin/verify"
-    )
-    data = dumps({"pin": verify_key})
+async def request_tier(auth, url):
+    """Get account tier information from blink servers."""
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "User-Agent": DEFAULT_USER_AGENT,
+        "Authorization": f"Bearer {auth.token}",
+    }
+
     return await auth.query(
         url=url,
-        headers=auth.header,
-        data=data,
-        json_resp=False,
-        reqtype="post",
+        headers=headers,
+        json_resp=True,
+        reqtype="get",
     )
 
 
@@ -214,7 +234,7 @@ async def request_command_status(blink, network, command_id):
 async def request_homescreen(blink, **kwargs):
     """Request homescreen info."""
     url = f"{blink.urls.base_url}/api/v3/accounts/{blink.account_id}/homescreen"
-    return await http_get(blink, url)
+    return await http_get(blink, url, json=False)
 
 
 @Throttle(seconds=MIN_THROTTLE_TIME)

blinkpy/auth.py

@@ -1,5 +1,6 @@
 """Login handler for blink."""
 
+import time
 import logging
 from aiohttp import (
     ClientSession,
@@ -14,6 +15,7 @@
     APP_BUILD,
     DEFAULT_USER_AGENT,
     LOGIN_ENDPOINT,
+    TIER_ENDPOINT,
     TIMEOUT,
 )
 
@@ -45,12 +47,16 @@ def __init__(
             login_data = {}
         self.data = login_data
         self.token = login_data.get("token", None)
+        self.expires_in = login_data.get("expires_in", None)
+        self.expiration_date = None
+        self._refresh_token = login_data.get("refresh_token", None)
         self.host = login_data.get("host", None)
         self.region_id = login_data.get("region_id", None)
         self.client_id = login_data.get("client_id", None)
         self.account_id = login_data.get("account_id", None)
         self.user_id = login_data.get("user_id", None)
         self.login_response = None
+        self.tier_info = None
         self.is_errored = False
         self.no_prompt = no_prompt
         self._agent = agent
@@ -61,6 +67,8 @@ def __init__(
     def login_attributes(self):
         """Return a dictionary of login attributes."""
         self.data["token"] = self.token
+        self.data["expires_in"] = self.expires_in
+        self.data["refresh_token"] = self._refresh_token
         self.data["host"] = self.host
         self.data["region_id"] = self.region_id
         self.data["client_id"] = self.client_id
@@ -74,9 +82,9 @@ def header(self):
         if self.token is None:
             return None
         return {
-            "APP-BUILD": self._app_build,
-            "TOKEN_AUTH": self.token,
-            "User-Agent": self._agent,
+            # "APP-BUILD": self._app_build,
+            "Authorization": f"Bearer {self.token}",
+            # "User-Agent": self._agent,
             "Content-Type": "application/json",
         }
 
@@ -88,23 +96,36 @@ def validate_login(self):
             self.data = util.prompt_login_data(self.data)
         self.data = util.validate_login_data(self.data)
 
-    async def login(self, login_url=LOGIN_ENDPOINT):
-        """Attempt login to blink servers."""
+    def validate_2fa(self):
+        """Check 2FA information and prompt if not available."""
+        self.data["2fa_code"] = self.data.get("2fa_code", None)
+        if not self.no_prompt:
+            self.data = util.prompt_2fa_data(self.data)
+
+    async def login(self, login_url=LOGIN_ENDPOINT, refresh=False):
+        """Attempt OAuth login to blink servers."""
         self.validate_login()
-        _LOGGER.info("Attempting login with %s", login_url)
         response = await api.request_login(
             self,
             login_url,
             self.data,
+            is_refresh=refresh,
             is_retry=False,
         )
         try:
             if response.status == 200:
                 return await response.json()
+            if response.status == 412:
+                self.validate_2fa()
+                return await self.login()
             raise LoginError
         except AttributeError as error:
             raise LoginError from error
 
+    async def get_tier_info(self, tier_url=TIER_ENDPOINT):
+        """Get tier information."""
+        return await api.request_tier(self, tier_url)
+
     def logout(self, blink):
         """Log out."""
         return api.request_logout(blink)
@@ -116,6 +137,8 @@ async def refresh_token(self):
             _LOGGER.info("Token expired, attempting automatic refresh.")
             self.login_response = await self.login()
             self.extract_login_info()
+            self.tier_info = await self.get_tier_info()
+            self.extract_tier_info()
             self.is_errored = False
         except LoginError as error:
             _LOGGER.error("Login endpoint failed. Try again later.")
@@ -127,12 +150,16 @@ async def refresh_token(self):
 
     def extract_login_info(self):
         """Extract login info from login response."""
-        self.region_id = self.login_response["account"]["tier"]
+        self.token = self.login_response["access_token"]
+        self.expires_in = self.login_response["expires_in"]
+        self.expiration_date = time.time() + self.expires_in
+        self._refresh_token = self.login_response["refresh_token"]
+
+    def extract_tier_info(self):
+        """Extract tier info from tier info response."""
+        self.region_id = self.tier_info["tier"]
         self.host = f"{self.region_id}.{BLINK_URL}"
-        self.token = self.login_response["auth"]["token"]
-        self.client_id = self.login_response["account"]["client_id"]
-        self.account_id = self.login_response["account"]["account_id"]
-        self.user_id = self.login_response["account"].get("user_id", None)
+        self.account_id = self.tier_info["account_id"]
 
     async def startup(self):
         """Initialize tokens for communication."""
@@ -161,6 +188,13 @@ async def validate_response(self, response: ClientResponse, json_resp):
         self.is_errored = False
         return json_data
 
+    def need_refresh(self):
+        """Check if token needs refresh."""
+        if self.expiration_date is None:
+            return self._refresh_token is not None
+
+        return self.expiration_date - time.time() < 60
+
     async def query(
         self,
         url=None,
@@ -171,6 +205,7 @@ async def query(
         json_resp=True,
         is_retry=False,
         timeout=TIMEOUT,
+        skip_refresh_check=False,
     ):
         """Perform server requests.
 
@@ -183,6 +218,9 @@ async def query(
         :param is_retry: Is this part of a re-auth attempt? True/FALSE
         """
         try:
+            if not skip_refresh_check and self.need_refresh():
+                await self.login(refresh=True)
+
             if reqtype == "get":
                 response = await self.session.get(
                     url=url, data=data, headers=headers, timeout=timeout
@@ -231,33 +269,6 @@ async def query(
                 _LOGGER.error("Unable to refresh token.")
         return None
 
-    async def send_auth_key(self, blink, key):
-        """Send 2FA key to blink servers."""
-        if key is not None:
-            response = await api.request_verify(self, blink, key)
-            try:
-                json_resp = await response.json()
-                blink.available = json_resp["valid"]
-                if not blink.available:
-                    _LOGGER.error("%s", json_resp["message"])
-                    return False
-            except (KeyError, TypeError, ContentTypeError) as er:
-                _LOGGER.error(
-                    "Did not receive valid response from server. Error: %s",
-                    er,
-                )
-                return False
-        return True
-
-    def check_key_required(self):
-        """Check if 2FA key is required."""
-        try:
-            if self.login_response["account"]["client_verification_required"]:
-                return True
-        except (KeyError, TypeError):
-            pass
-        return False
-
 
 class TokenRefreshFailed(Exception):
     """Class to throw failed refresh exception."""