carconnectivity-connector-skoda 0.1a1__py3-none-any.whl

carconnectivity_connectors/skoda/auth/skoda_web_session.py

@@ -0,0 +1,239 @@
+"""
+Module implements a VW Web session.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+
+from urllib.parse import parse_qsl, urlparse, urlsplit, urljoin
+
+from urllib3.util.retry import Retry
+
+import requests
+from requests.adapters import HTTPAdapter
+from requests.models import CaseInsensitiveDict
+
+from carconnectivity.errors import APICompatibilityError, AuthenticationError, RetrievalError
+
+from carconnectivity_connectors.skoda.auth.auth_util import CredentialsFormParser, HTMLFormParser, TermsAndConditionsFormParser
+from carconnectivity_connectors.skoda.auth.openid_session import OpenIDSession
+
+if TYPE_CHECKING:
+    from typing import Any, Dict
+
+
+class SkodaWebSession(OpenIDSession):
+    """
+    SkodaWebSession handles the web authentication process for Skoda's web services.
+    """
+    def __init__(self, session_user, cache, accept_terms_on_login=False, **kwargs):
+        super(SkodaWebSession, self).__init__(**kwargs)
+        self.session_user = session_user
+        self.cache = cache
+        self.accept_terms_on_login: bool = accept_terms_on_login
+
+        # Set up the web session
+        retries = Retry(
+            total=self.retries,
+            backoff_factor=0.1,
+            status_forcelist=[500],
+            raise_on_status=False
+        )
+
+        self.websession: requests.Session = requests.Session()
+        self.websession.proxies.update(self.proxies)
+        self.websession.mount('https://', HTTPAdapter(max_retries=retries))
+        self.websession.headers = CaseInsensitiveDict({
+            'user-agent': 'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 '
+                          'Chrome/74.0.3729.185 Mobile Safari/537.36',
+            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,'
+                      'application/signed-exchange;v=b3',
+            'accept-language': 'en-US,en;q=0.9',
+            'accept-encoding': 'gzip, deflate',
+            'x-requested-with': 'cz.skodaauto.connect',
+            'upgrade-insecure-requests': '1',
+        })
+
+    def do_web_auth(self, url: str) -> str:
+        """
+        Perform web authentication using the provided URL.
+
+        This method handles the web authentication process by:
+        1. Retrieving the login form.
+        2. Setting the email to the provided username.
+        3. Retrieving the password form.
+        4. Setting the credentials (email and password).
+        5. Logging in and getting the redirect URL.
+        6. Checking the URL for terms and conditions and handling consent if required.
+        7. Following redirects until the final URL is reached.
+
+        Args:
+            url (str): The URL to start the authentication process.
+
+        Returns:
+            str: The final URL after successful authentication.
+
+        Raises:
+            AuthenticationError: If terms and conditions need to be accepted.
+            RetrievalError: If there is a temporary server error during login.
+            APICompatibilityError: If forwarding occurs without 'Location' in headers.
+        """
+        # Get the login form
+        email_form: HTMLFormParser = self._get_login_form(url)
+
+        # Set email to the provided username
+        email_form.data['email'] = self.session_user.username
+
+        # Get password form
+        password_form = self._get_password_form(
+            urljoin('https://identity.vwgroup.io', email_form.target),
+            email_form.data
+        )
+
+        # Set credentials
+        password_form.data['email'] = self.session_user.username
+        password_form.data['password'] = self.session_user.password
+
+        # Log in and get the redirect URL
+        url = self._handle_login(
+            f'https://identity.vwgroup.io/signin-service/v1/{self.client_id}/{password_form.target}',
+            password_form.data
+        )
+
+        if self.redirect_uri is None:
+            raise ValueError('Redirect URI is not set')
+        # Check URL for terms and conditions
+        while True:
+            if url.startswith(self.redirect_uri):
+                break
+
+            url = urljoin('https://identity.vwgroup.io', url)
+
+            if 'terms-and-conditions' in url:
+                if self.accept_terms_on_login:
+                    url = self._handle_consent_form(url)
+                else:
+                    raise AuthenticationError(f'It seems like you need to accept the terms and conditions. '
+                                              f'Try to visit the URL "{url}" or log into smartphone app.')
+
+            response = self.websession.get(url, allow_redirects=False)
+            if response.status_code == requests.codes['internal_server_error']:
+                raise RetrievalError('Temporary server error during login')
+
+            if 'Location' not in response.headers:
+                raise APICompatibilityError('Forwarding without Location in headers')
+
+            url = response.headers['Location']
+
+        return url.replace(self.redirect_uri + '#', 'https://egal?')
+
+    def _get_login_form(self, url: str) -> HTMLFormParser:
+        while True:
+            response = self.websession.get(url, allow_redirects=False)
+            if response.status_code == requests.codes['ok']:
+                break
+
+            if response.status_code in (requests.codes['found'], requests.codes['see_other']):
+                if 'Location' not in response.headers:
+                    raise APICompatibilityError('Forwarding without Location in headers')
+
+                url = response.headers['Location']
+                continue
+
+            raise APICompatibilityError(f'Retrieving login page was not successful, '
+                                        f'status code: {response.status_code}')
+
+        # Find login form on page to obtain inputs
+        email_form = HTMLFormParser(form_id='emailPasswordForm')
+        email_form.feed(response.text)
+
+        if not email_form.target or not all(x in email_form.data for x in ['_csrf', 'relayState', 'hmac', 'email']):
+            raise APICompatibilityError('Could not find all required input fields on login page')
+
+        return email_form
+
+    def _get_password_form(self, url: str, data: Dict[str, Any]) -> CredentialsFormParser:
+        response = self.websession.post(url, data=data, allow_redirects=True)
+        if response.status_code != requests.codes['ok']:
+            raise APICompatibilityError(f'Retrieving credentials page was not successful, '
+                                        f'status code: {response.status_code}')
+
+        # Find login form on page to obtain inputs
+        credentials_form = CredentialsFormParser()
+        credentials_form.feed(response.text)
+
+        if not credentials_form.target or not all(x in credentials_form.data for x in ['relayState', 'hmac', '_csrf']):
+            raise APICompatibilityError('Could not find all required input fields on credentials page')
+
+        if credentials_form.data.get('error', None) is not None:
+            if credentials_form.data['error'] == 'validator.email.invalid':
+                raise AuthenticationError('Error during login, email invalid')
+            raise AuthenticationError(f'Error during login: {credentials_form.data["error"]}')
+
+        if 'errorCode' in credentials_form.data:
+            raise AuthenticationError('Error during login, is the username correct?')
+
+        if credentials_form.data.get('registerCredentialsPath', None) == 'register':
+            raise AuthenticationError(f'Error during login, account {self.session_user.username} does not exist')
+
+        return credentials_form
+
+    def _handle_login(self, url: str, data: Dict[str, Any]) -> str:
+        response: requests.Response = self.websession.post(url, data=data, allow_redirects=False)
+
+        if response.status_code == requests.codes['internal_server_error']:
+            raise RetrievalError('Temporary server error during login')
+
+        if response.status_code not in (requests.codes['found'], requests.codes['see_other']):
+            raise APICompatibilityError(f'Forwarding expected (status code 302), '
+                                        f'but got status code {response.status_code}')
+
+        if 'Location' not in response.headers:
+            raise APICompatibilityError('Forwarding without Location in headers')
+
+        # Parse parameters from forwarding url
+        params: Dict[str, str] = dict(parse_qsl(urlsplit(response.headers['Location']).query))
+
+        # Check for login error
+        if 'error' in params and params['error']:
+            error_messages: Dict[str, str] = {
+                'login.errors.password_invalid': 'Password is invalid',
+                'login.error.throttled': 'Login throttled, probably too many wrong logins. You have to wait '
+                                         'a few minutes until a new login attempt is possible'
+            }
+
+            raise AuthenticationError(error_messages.get(params['error'], params['error']))
+
+        # Check for user ID
+        if 'userId' not in params or not params['userId']:
+            if 'updated' in params and params['updated'] == 'dataprivacy':
+                raise AuthenticationError('You have to login at myvolkswagen.de and accept the terms and conditions')
+            raise APICompatibilityError('No user ID provided')
+
+        self.user_id = params['userId']  # pylint: disable=unused-private-member
+        return response.headers['Location']
+
+    def _handle_consent_form(self, url: str) -> str:
+        response = self.websession.get(url, allow_redirects=False)
+        if response.status_code == requests.codes['internal_server_error']:
+            raise RetrievalError('Temporary server error during login')
+
+        # Find form on page to obtain inputs
+        tc_form = TermsAndConditionsFormParser()
+        tc_form.feed(response.text)
+
+        # Remove query from URL
+        url = urlparse(response.url)._replace(query='').geturl()
+
+        response = self.websession.post(url, data=tc_form.data, allow_redirects=False)
+        if response.status_code == requests.codes['internal_server_error']:
+            raise RetrievalError('Temporary server error during login')
+
+        if response.status_code not in (requests.codes['found'], requests.codes['see_other']):
+            raise APICompatibilityError('Forwarding expected (status code 302), '
+                                        f'but got status code {response.status_code}')
+
+        if 'Location' not in response.headers:
+            raise APICompatibilityError('Forwarding without Location in headers')
+
+        return response.headers['Location']

carconnectivity_connectors/skoda/capability.py

@@ -0,0 +1,145 @@
+"""Module for Skoda vehicle capability class."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import IntEnum
+
+from carconnectivity.objects import GenericObject
+from carconnectivity.attributes import StringAttribute
+
+if TYPE_CHECKING:
+    from typing import Dict, Optional
+    from carconnectivity_connectors.skoda.vehicle import SkodaVehicle
+
+
+class Capabilities(GenericObject):
+    """
+    Represents the capabilities of a Skoda vehicle.
+    """
+    def __init__(self, vehicle: SkodaVehicle) -> None:
+        super().__init__(object_id='capabilities', parent=vehicle)
+        self.__capabilities: Dict[str, Capability] = {}
+
+    @property
+    def capabilities(self) -> Dict[str, Capability]:
+        """
+        Retrieve the capabilities of the vehicle.
+
+        Returns:
+            Dict[str, Capability]: A dictionary of capabilities.
+        """
+        return self.__capabilities
+
+    def add_capability(self, capability_id: str, capability: Capability) -> None:
+        """
+        Adds a capability to the Capabilities of the vehicle.
+
+        Args:
+            capability_id (str): The unique identifier of the capability.
+            capability (Capability): The capability object to be added.
+
+        Returns:
+            None
+        """
+        self.__capabilities[capability_id] = capability
+
+    def remove_capability(self, capability_id: str) -> None:
+        """
+        Remove a capability from the Capabilities by its capability ID.
+
+        Args:
+            capability_id (str): The ID of the capability to be removed.
+
+        Returns:
+            None
+        """
+        if capability_id in self.__capabilities:
+            del self.__capabilities[capability_id]
+
+    def clear_capabilities(self) -> None:
+        """
+        Remove all capabilities from the Capabilities.
+
+        Returns:
+            None
+        """
+        self.__capabilities.clear()
+
+    def get_capability(self, capability_id: str) -> Optional[Capability]:
+        """
+        Retrieve a capability from the Capabilities by its capability ID.
+
+        Args:
+            capability_id (str): The unique identifier of the capability to retrieve.
+
+        Returns:
+            Capability: The capability object if found, otherwise None.
+        """
+        return self.__capabilities.get(capability_id)
+
+    def has_capability(self, capability_id: str) -> bool:
+        """
+        Check if the Capabilities contains a capability with the specified ID.
+
+        Args:
+            capability_id (str): The unique identifier of the capability to check.
+
+        Returns:
+            bool: True if the capability exists, otherwise False.
+        """
+        return capability_id in self.__capabilities
+
+    def __str__(self) -> str:
+        return_string = 'Capabilities:\n'
+        for capability in self.__capabilities.values():
+            return_string += f'\t{capability}\n'
+        return return_string
+
+
+class Capability(GenericObject):
+    """
+    Represents a capability of a Skoda vehicle.
+    """
+
+    def __init__(self, capability_id: str, capabilities: Capabilities) -> None:
+        if capabilities is None:
+            raise ValueError('Cannot create capability without Capabilities')
+        if id is None:
+            raise ValueError('Capability ID cannot be None')
+        super().__init__(object_id=capability_id, parent=capabilities)
+        self.delay_notifications = True
+        self.capability_id = StringAttribute("id", self, capability_id)
+        self.statuses = list[Capability.Status]
+        self.enabled = True
+        self.delay_notifications = False
+
+    def __str__(self) -> str:
+        return_string = f'{self.capability_id}'
+        return return_string
+
+    class Status(IntEnum):
+        """
+        Enum for capability status.
+        """
+        UNKNOWN = 0
+        DEACTIVATED = 1001
+        INITIALLY_DISABLED = 1003
+        DISABLED_BY_USER = 1004
+        OFFLINE_MODE = 1005
+        WORKSHOP_MODE = 1006
+        MISSING_OPERATION = 1007
+        MISSING_SERVICE = 1008
+        PLAY_PROTECTION = 1009
+        POWER_BUDGET_REACHED = 1010
+        DEEP_SLEEP = 1011
+        LOCATION_DATA_DISABLED = 1013
+        LICENSE_INACTIVE = 2001
+        LICENSE_EXPIRED = 2002
+        MISSING_LICENSE = 2003
+        USER_NOT_VERIFIED = 3001
+        TERMS_AND_CONDITIONS_NOT_ACCEPTED = 3002
+        INSUFFICIENT_RIGHTS = 3003
+        CONSENT_MISSING = 3004
+        LIMITED_FEATURE = 3005
+        AUTH_APP_CERT_ERROR = 3006
+        STATUS_UNSUPPORTED = 4001