Merge pull request #2 from limeryls/fix_login

Fix setting login credentials using config_flow and fix mistakes in spelling

README.md

@@ -1,9 +1,8 @@
 # Georide Home assistant
-![Logo Georide](./georide-logo.png)
+![Logo Georide](/georide-logo.png)
 
 ⚠️ This is not an official implementation
-
-[![hacs_badge](https://img.shields.io/badge/HACS-Custom-orange.svg?style=for-the-badge)](https://github.com/custom-components/hacs)
+[![hacs_badge](https://img.shields.io/badge/HACS-Default-orange.svg?style=for-the-badge)](https://github.com/custom-components/hacs)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg?style=for-the-badge)](https://www.gnu.org/licenses/gpl-3.0)
 
 Official GeoRide website: https://georide.fr/

custom_components/georide/.translations/en.json

@@ -16,10 +16,10 @@
       "unknown": "Unknown error"
     },
     "abort": {
-      "one_instance_allowed": "Only a single instance is allowed."
+      "one_instance_allowed": "Only one instance is allowed."
     },
     "create_entry": {
-      "default": "\n\nLogin succes"
+      "default": "\n\nLogin success"
     }
   }
 }

custom_components/georide/.translations/fr.json

@@ -4,7 +4,7 @@
     "step": {
       "georide_login": {
         "title": "Configuration de GeoRide",
-        "description": "T'es un mortard ! V",
+        "description": "T'es un motard ! V",
         "data": {
           "email": "email",
           "password": "password"
@@ -12,14 +12,14 @@
       }
     },
     "error": {
-      "faulty_credentials": "Connexion \u00e9chou\u00e9",
-      "unkonwn": "Erreur inconue"
+      "faulty_credentials": "Connexion \u00e9chou\u00e9e",
+      "unkonwn": "Erreur inconnue"
     },
     "abort": {
-      "one_instance_allowed": "Seulement un instance est authoris\u00e9e"
+      "one_instance_allowed": "Seulement une instance est autoris\u00e9e"
     },
     "create_entry": {
-      "default": "\n\nConnexion r\u00e9ussie!"
+      "default": "\n\nConnexion r\u00e9ussie !"
     }
   }
 }

custom_components/georide/__init__.py

@@ -31,6 +31,7 @@ from .const import (
     CONF_TOKEN,
     TRACKER_ID,
     TOKEN_SAFE_DAY,
+    MIN_UNTIL_REFRESH,
     DOMAIN
 )
 
@@ -66,21 +67,6 @@ async def async_setup(hass, config):
     return True
 
 
-def connect_socket(hass, component):
-    """subscribe to georide socket"""
-    context = hass.data[DOMAIN]["context"]
-
-    socket = GeorideSocket()
-    socket.subscribe_locked(context.on_lock_callback)
-    socket.subscribe_device(context.on_device_callback)
-    socket.subscribe_position(context.on_position_callback)
-
-    context.socket = socket
-
-    socket.init()
-    socket.connect(context.async_get_token())
-
-
 async def async_setup_entry(hass, entry):
     """Set up Georide entry."""
     config = hass.data[DOMAIN]["config"]
@@ -93,13 +79,14 @@ async def async_setup_entry(hass, entry):
         password,
         token
     )
-
+    
+    _LOGGER.info("Context-setup and start the thread")
+    _LOGGER.info("Thread started")
 
     hass.data[DOMAIN]["context"] = context
 
     # We add trackers to the context
-    trackers = GeorideApi.get_trackers(token)
-    context.georide_trackers = trackers
+    context.refresh_trackers()
 
     hass.async_create_task(
         hass.config_entries.async_forward_entry_setup(entry, "device_tracker"))
@@ -108,12 +95,9 @@ async def async_setup_entry(hass, entry):
     hass.async_create_task(
         hass.config_entries.async_forward_entry_setup(entry, "sensor"))
 
-    thread = Thread(target=connect_socket, args=(hass, entry))
-    thread.start()
-
-
     return True
 
+
 async def async_unload_entry(hass, entry):
     """Unload an Georide config entry."""
 
@@ -128,6 +112,19 @@ async def async_unload_entry(hass, entry):
 
     return True
 
+def connect_socket(context):
+    """subscribe to georide socket"""
+    _LOGGER.info("Georide socket connexion")
+    socket = GeorideSocket()
+    socket.subscribe_locked(context.on_lock_callback)
+    socket.subscribe_device(context.on_device_callback)
+    socket.subscribe_position(context.on_position_callback)
+
+    context.socket = socket
+
+    socket.init()
+    socket.connect(context.get_token())
+
 
 class GeorideContext:
     """Hold the current Georide context."""
@@ -140,7 +137,8 @@ class GeorideContext:
         self._georide_trackers = defaultdict(set)
         self._token = token
         self._socket = None
-
+        self._thread_started = False
+        self._previous_refresh = math.floor(time.time()/60)
     @property
     def hass(self):
         """ hass """
@@ -177,7 +175,6 @@ class GeorideContext:
         exp_timestamp = jwt_data['exp']
 
         epoch = math.ceil(time.time())
-
         if (exp_timestamp - TOKEN_SAFE_DAY) < epoch:
             _LOGGER.info("Time reached, renew token")
             account = GeorideApi.get_authorisation_token(self._email, self._password)
@@ -191,11 +188,29 @@ class GeorideContext:
 
     def get_tracker(self, tracker_id):
         """ here we return last tracker by id"""
+        epoch_min = math.floor(time.time()/60)
+        if (epoch_min % MIN_UNTIL_REFRESH) == 0:
+            if epoch_min != self._previous_refresh:
+                self._previous_refresh = epoch_min
+                self.refresh_trackers()
+
+        if not self._thread_started:
+            _LOGGER.info("Start the thread")
+            self._hass.async_add_executor_job(connect_socket, self)
+            # We refresh the tracker list each hours
+            self._thread_started = True
+
         for tracker in self._georide_trackers:
             if tracker.tracker_id == tracker_id:
                 return tracker
         return None
 
+    def refresh_trackers(self):
+        """Used to refresh the tracker list"""
+        _LOGGER.info("Tracker list refresh")
+        self._georide_trackers = GeorideApi.get_trackers(self.get_token())
+
+
     @property
     def socket(self):
         """ hold the georide socket """
@@ -206,7 +221,6 @@ class GeorideContext:
         """set the georide socket"""
         self._socket = socket
 
-
     @callback
     def on_lock_callback(self, data):
         """on lock callback"""

custom_components/georide/config_flow.py

@@ -41,27 +41,32 @@ class GeorideConfigFlow(config_entries.ConfigFlow):
 
     async def async_step_georide_login(self, user_input):
         """ try to seupt GeoRide Account """
-        errors = {}
+
+        schema = vol.Schema({
+            vol.Required(CONF_EMAIL): vol.All(str, vol.Length(min=3)),
+            vol.Required(CONF_PASSWORD): vol.All(str)
+        })
+        
+        if user_input is None:
+            return self.async_show_form(step_id='georide_login', data_schema=schema)
+        
+        email = user_input[CONF_EMAIL]
+        password = user_input[CONF_PASSWORD]
+        
         try:
-            account = GeorideApi.get_authorisation_token(
-                user_input[CONF_EMAIL],
-                user_input[CONF_PASSWORD])
-            return self.async_create_entry(
-                title=user_input[CONF_EMAIL],
-                data={
-                    CONF_EMAIL: user_input[CONF_EMAIL],
-                    CONF_PASSWORD: user_input[CONF_PASSWORD],
-                    CONF_TOKEN: account.auth_token
-                }
-            )
+            account = GeorideApi.get_authorisation_token(email, password)
+            data = {
+                CONF_EMAIL: email,
+                CONF_PASSWORD: password,
+                CONF_TOKEN: account.auth_token
+            }
+            return self.async_create_entry(title=email, data=data)
         except (GeorideException.SeverException, GeorideException.LoginException):
             _LOGGER.error("Invalid credentials provided, config not created")
-            errors["base"] = "faulty_credentials"
-            return self.async_show_form(step_id="georide_login", errors=errors)
+            errors = {"base":  "faulty_credentials"}
+            return self.async_show_form(step_id="georide_login", data_schema=schema, errors=errors)
         except: 
             _LOGGER.error("Unknown error")
-            errors["base"] = "faulty_credentials"
-            return self.async_show_form(step_id="georide_login", errors=errors)
-
-        
+            errors = {"base": "unkonwn"}
+            return self.async_show_form(step_id="georide_login", data_schema=schema, errors=errors)
         

custom_components/georide/const.py

@@ -8,4 +8,6 @@ CONF_TOKEN = "token"
 
 TRACKER_ID = "trackerId"
 
+MIN_UNTIL_REFRESH = 10
+
 TOKEN_SAFE_DAY = 432000 # five days

custom_components/georide/device_tracker.py

@@ -117,9 +117,9 @@ class GeorideTrackerEntity(TrackerEntity):
         """No polling needed."""
         return True
 
-    async def async_update(self):
+    def update(self):
         """ update the current tracker"""
+        _LOGGER.info('update')
         self._data = self._get_tracker_callback(self._tracker_id)
         self._name = self._data.tracker_name
-        return
         

custom_components/georide/manifest.json

@@ -4,7 +4,7 @@
   "config_flow": true,
   "documentation": "https://git.tontontux.fr/mduval/GeorideHA",
   "requirements": [
-    "georideapilib>=0.4.3",
+    "georideapilib>=0.4.4",
     "pyjwt>=1.7.1"
   ],
   "dependencies": [],

custom_components/georide/sensor.py

@@ -52,7 +52,7 @@ class GeorideOdometerSensorEntity(SwitchDevice):
 
     def update(self):
         """ update the current tracker"""
-        _LOGGER.info('async_update ')
+        _LOGGER.info('update')
         self._data = self._get_tracker_callback(self._tracker_id)
         self._name = self._data.tracker_name
         self._state = self._data.odometer

custom_components/georide/switch.py

@@ -80,7 +80,7 @@ class GeorideLockSwitchEntity(SwitchDevice):
 
     def update(self):
         """ update the current tracker"""
-        _LOGGER.info('async_update ')
+        _LOGGER.info('update')
         self._data = self._get_tracker_callback(self._tracker_id)
         self._name = self._data.tracker_name
         self._is_on = self._data.is_locked