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

carconnectivity_connectors/seatcupra/auth/vw_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.seatcupra.auth.auth_util import CredentialsFormParser, HTMLFormParser, TermsAndConditionsFormParser
+from carconnectivity_connectors.seatcupra.auth.openid_session import OpenIDSession
+
+if TYPE_CHECKING:
+    from typing import Any, Dict
+
+
+class VWWebSession(OpenIDSession):
+    """
+    VWWebSession handles the web authentication process for Cupra's web services.
+    """
+    def __init__(self, session_user, cache, accept_terms_on_login=False, **kwargs):
+        super(VWWebSession, 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': 'com.volkswagen.weconnect',
+            '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 https://www.cupraofficial.com 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/seatcupra/charging.py

@@ -0,0 +1,74 @@
+"""
+Module for charging for Seat/Cupra vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import Enum
+
+from carconnectivity.charging import Charging
+from carconnectivity.vehicle import ElectricVehicle
+
+if TYPE_CHECKING:
+    from typing import Optional, Dict
+
+
+class SeatCupraCharging(Charging):  # pylint: disable=too-many-instance-attributes
+    """
+    SeatCupraCharging class for handling SeatCupra vehicle charging information.
+
+    This class extends the Charging class and includes an enumeration of various
+    charging states specific to SeatCupra vehicles.
+    """
+    def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Charging] = None) -> None:
+        if origin is not None:
+            super().__init__(origin=origin)
+        else:
+            super().__init__(vehicle=vehicle)
+
+    class SeatCupraChargingState(Enum,):
+        """
+        Enum representing the various charging states for a SeatCupra vehicle.
+        """
+        OFF = 'off'
+        READY_FOR_CHARGING = 'readyForCharging'
+        NOT_READY_FOR_CHARGING = 'NotReadyForCharging'
+        CONSERVATION = 'conservation'
+        CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING = 'chargePurposeReachedAndNotConservationCharging'
+        CHARGE_PURPOSE_REACHED_CONSERVATION = 'chargePurposeReachedAndConservation'
+        CHARGING = 'charging'
+        ERROR = 'error'
+        UNSUPPORTED = 'unsupported'
+        DISCHARGING = 'discharging'
+        UNKNOWN = 'unknown charging state'
+
+    class SeatCupraChargeMode(Enum,):
+        """
+        Enum class representing different SeatCupra charge modes.
+        """
+        MANUAL = 'manual'
+        INVALID = 'invalid'
+        OFF = 'off'
+        TIMER = 'timer'
+        ONLY_OWN_CURRENT = 'onlyOwnCurrent'
+        PREFERRED_CHARGING_TIMES = 'preferredChargingTimes'
+        TIMER_CHARGING_WITH_CLIMATISATION = 'timerChargingWithClimatisation'
+        HOME_STORAGE_CHARGING = 'homeStorageCharging'
+        IMMEDIATE_DISCHARGING = 'immediateDischarging'
+        UNKNOWN = 'unknown charge mode'
+
+
+# Mapping of Cupra charging states to generic charging states
+mapping_seatcupra_charging_state: Dict[SeatCupraCharging.SeatCupraChargingState, Charging.ChargingState] = {
+    SeatCupraCharging.SeatCupraChargingState.OFF: Charging.ChargingState.OFF,
+    SeatCupraCharging.SeatCupraChargingState.NOT_READY_FOR_CHARGING: Charging.ChargingState.OFF,
+    SeatCupraCharging.SeatCupraChargingState.READY_FOR_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SeatCupraCharging.SeatCupraChargingState.CONSERVATION: Charging.ChargingState.CONSERVATION,
+    SeatCupraCharging.SeatCupraChargingState.CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SeatCupraCharging.SeatCupraChargingState.CHARGE_PURPOSE_REACHED_CONSERVATION: Charging.ChargingState.CONSERVATION,
+    SeatCupraCharging.SeatCupraChargingState.CHARGING: Charging.ChargingState.CHARGING,
+    SeatCupraCharging.SeatCupraChargingState.ERROR: Charging.ChargingState.ERROR,
+    SeatCupraCharging.SeatCupraChargingState.UNSUPPORTED: Charging.ChargingState.UNSUPPORTED,
+    SeatCupraCharging.SeatCupraChargingState.DISCHARGING: Charging.ChargingState.DISCHARGING,
+    SeatCupraCharging.SeatCupraChargingState.UNKNOWN: Charging.ChargingState.UNKNOWN
+}