mduval
/
GeoRideHA
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

GeoRide wording update

Browse Source
master
Matthieu DUVAL 4 years ago
parent a8274f7fd1
commit 4593c694d5
11 changed files with 67 additions and 66 deletions
Show Stats Download Patch File Download Diff File

4
README.md
Unescape View File

@ -1,5 +1,5 @@
# Georide Home assistant # GeoRide Home assistant
![Logo Georide](/georide-logo.png) ![Logo GeoRide](https://brands.home-assistant.io/georide/logo.png)
⚠️ This is not an official implementation ⚠️ This is not an official implementation
[![hacs_badge](https://img.shields.io/badge/HACS-Default-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)

39
custom_components/georide/__init__.py
Unescape View File

@ -11,11 +11,10 @@ import voluptuous as vol
import jwt import jwt
from aiohttp.web import json_response from aiohttp.web import json_response
from georideapilib.objects import GeorideAccount from georideapilib.objects import GeorideAccount as GeoRideAccount
import georideapilib.api as GeorideApi import georideapilib.api as GeoRideApi
from georideapilib.socket import GeorideSocket
from georideapilib.socket import GeorideSocket as GeoRideSocket
from homeassistant import config_entries from homeassistant import config_entries
from homeassistant.const import CONF_WEBHOOK_ID from homeassistant.const import CONF_WEBHOOK_ID
@ -51,7 +50,7 @@ CONFIG_SCHEMA = vol.Schema(
async def async_setup(hass, config): async def async_setup(hass, config):
"""Setup Georide component.""" """Setup GeoRide component."""
hass.data[DOMAIN] = {"config": config[DOMAIN], "devices": {}, "unsub": None} hass.data[DOMAIN] = {"config": config[DOMAIN], "devices": {}, "unsub": None}
hass.async_create_task( hass.async_create_task(
hass.config_entries.flow.async_init( hass.config_entries.flow.async_init(
@ -68,12 +67,12 @@ async def async_setup(hass, config):
async def async_setup_entry(hass, entry): async def async_setup_entry(hass, entry):
"""Set up Georide entry.""" """Set up GeoRide entry."""
config = hass.data[DOMAIN]["config"] config = hass.data[DOMAIN]["config"]
email = config.get(CONF_EMAIL) or entry.data[CONF_EMAIL] email = config.get(CONF_EMAIL) or entry.data[CONF_EMAIL]
password = config.get(CONF_PASSWORD) or entry.data[CONF_PASSWORD] password = config.get(CONF_PASSWORD) or entry.data[CONF_PASSWORD]
token = config.get(CONF_TOKEN) or entry.data[CONF_TOKEN] token = config.get(CONF_TOKEN) or entry.data[CONF_TOKEN]
context = GeorideContext( context = GeoRideContext(
hass, hass,
email, email,
password, password,
@ -99,7 +98,7 @@ async def async_setup_entry(hass, entry):
async def async_unload_entry(hass, entry): async def async_unload_entry(hass, entry):
"""Unload an Georide config entry.""" """Unload an GeoRide config entry."""
await hass.config_entries.async_forward_entry_unload(entry, "device_tracker") await hass.config_entries.async_forward_entry_unload(entry, "device_tracker")
await hass.config_entries.async_forward_entry_unload(entry, "switch") await hass.config_entries.async_forward_entry_unload(entry, "switch")
@ -113,9 +112,9 @@ async def async_unload_entry(hass, entry):
return True return True
def connect_socket(context): def connect_socket(context):
"""subscribe to georide socket""" """subscribe to GeoRide socket"""
_LOGGER.info("Georide socket connexion") _LOGGER.info("GeoRide socket connexion")
socket = GeorideSocket() socket = GeoRideSocket()
socket.subscribe_locked(context.on_lock_callback) socket.subscribe_locked(context.on_lock_callback)
socket.subscribe_device(context.on_device_callback) socket.subscribe_device(context.on_device_callback)
socket.subscribe_position(context.on_position_callback) socket.subscribe_position(context.on_position_callback)
@ -126,11 +125,11 @@ def connect_socket(context):
socket.connect(context.get_token()) socket.connect(context.get_token())
class GeorideContext: class GeoRideContext:
"""Hold the current Georide context.""" """Hold the current GeoRide context."""
def __init__(self, hass, email, password, token): def __init__(self, hass, email, password, token):
"""Initialize an Georide context.""" """Initialize an GeoRide context."""
self._hass = hass self._hass = hass
self._email = email self._email = email
self._password = password self._password = password
@ -161,12 +160,12 @@ class GeorideContext:
@property @property
def georide_trackers(self): def georide_trackers(self):
""" georide tracker list """ """ GeoRide tracker list """
return self._georide_trackers return self._georide_trackers
@georide_trackers.setter @georide_trackers.setter
def georide_trackers(self, trackers): def georide_trackers(self, trackers):
""" georide tracker list """ """ GeoRide tracker list """
self._georide_trackers = trackers self._georide_trackers = trackers
def get_token(self): def get_token(self):
@ -177,7 +176,7 @@ class GeorideContext:
epoch = math.ceil(time.time()) epoch = math.ceil(time.time())
if (exp_timestamp - TOKEN_SAFE_DAY) < epoch: if (exp_timestamp - TOKEN_SAFE_DAY) < epoch:
_LOGGER.info("Time reached, renew token") _LOGGER.info("Time reached, renew token")
account = GeorideApi.get_authorisation_token(self._email, self._password) account = GeoRideApi.get_authorisation_token(self._email, self._password)
config = self._hass.data[DOMAIN]["config"] config = self._hass.data[DOMAIN]["config"]
config[CONF_TOKEN] = account.auth_token config[CONF_TOKEN] = account.auth_token
self._token = account.auth_token self._token = account.auth_token
@ -208,17 +207,17 @@ class GeorideContext:
def refresh_trackers(self): def refresh_trackers(self):
"""Used to refresh the tracker list""" """Used to refresh the tracker list"""
_LOGGER.info("Tracker list refresh") _LOGGER.info("Tracker list refresh")
self._georide_trackers = GeorideApi.get_trackers(self.get_token()) self._georide_trackers = GeoRideApi.get_trackers(self.get_token())
@property @property
def socket(self): def socket(self):
""" hold the georide socket """ """ hold the GeoRide socket """
return self._socket return self._socket
@socket.setter @socket.setter
def socket(self, socket): def socket(self, socket):
"""set the georide socket""" """set the GeoRide socket"""
self._socket = socket self._socket = socket
@callback @callback

14
custom_components/georide/config_flow.py
Unescape View File

@ -3,8 +3,8 @@
import logging import logging
from homeassistant import config_entries from homeassistant import config_entries
import voluptuous as vol import voluptuous as vol
import georideapilib.api as GeorideApi import georideapilib.api as GeoRideApi
import georideapilib.exception as GeorideException import georideapilib.exception as GeoRideException
from .const import CONF_EMAIL, CONF_PASSWORD, CONF_TOKEN from .const import CONF_EMAIL, CONF_PASSWORD, CONF_TOKEN
@ -13,11 +13,11 @@ from .const import CONF_EMAIL, CONF_PASSWORD, CONF_TOKEN
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@config_entries.HANDLERS.register("georide") @config_entries.HANDLERS.register("georide")
class GeorideConfigFlow(config_entries.ConfigFlow): class GeoRideConfigFlow(config_entries.ConfigFlow):
"""Georide config flow """ """GeoRide config flow """
async def async_step_user(self, user_input=None): #pylint: disable=W0613 async def async_step_user(self, user_input=None): #pylint: disable=W0613
""" handle info to help to configure georide """ """ handle info to help to configure GeoRide """
if self._async_current_entries(): if self._async_current_entries():
return self.async_abort(reason="one_instance_allowed") return self.async_abort(reason="one_instance_allowed")
@ -54,14 +54,14 @@ class GeorideConfigFlow(config_entries.ConfigFlow):
password = user_input[CONF_PASSWORD] password = user_input[CONF_PASSWORD]
try: try:
account = GeorideApi.get_authorisation_token(email, password) account = GeoRideApi.get_authorisation_token(email, password)
data = { data = {
CONF_EMAIL: email, CONF_EMAIL: email,
CONF_PASSWORD: password, CONF_PASSWORD: password,
CONF_TOKEN: account.auth_token CONF_TOKEN: account.auth_token
} }
return self.async_create_entry(title=email, data=data) return self.async_create_entry(title=email, data=data)
except (GeorideException.SeverException, GeorideException.LoginException): except (GeoRideException.SeverException, GeoRideException.LoginException):
_LOGGER.error("Invalid credentials provided, config not created") _LOGGER.error("Invalid credentials provided, config not created")
errors = {"base": "faulty_credentials"} errors = {"base": "faulty_credentials"}
return self.async_show_form(step_id="georide_login", data_schema=schema, errors=errors) return self.async_show_form(step_id="georide_login", data_schema=schema, errors=errors)

2
custom_components/georide/const.py
Unescape View File

@ -1,4 +1,4 @@
""" Georide const file """ """ GeoRide const file """
DOMAIN = "georide" DOMAIN = "georide"
CONF_EMAIL = "email" CONF_EMAIL = "email"

15
custom_components/georide/device_tracker.py
Unescape View File

@ -1,11 +1,11 @@
""" device tracker for Georide object """ """ device tracker for GeoRide object """
import logging import logging
from homeassistant.components.device_tracker.const import DOMAIN, SOURCE_TYPE_GPS from homeassistant.components.device_tracker.const import DOMAIN, SOURCE_TYPE_GPS
from homeassistant.components.device_tracker.config_entry import TrackerEntity from homeassistant.components.device_tracker.config_entry import TrackerEntity
import georideapilib.api as GeorideApi import georideapilib.api as GeoRideApi
from .const import DOMAIN as GEORIDE_DOMAIN from .const import DOMAIN as GEORIDE_DOMAIN
@ -20,15 +20,15 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
if georide_context.get_token() is None: if georide_context.get_token() is None:
return False return False
_LOGGER.info('Current georide token: %s', georide_context.get_token()) _LOGGER.debug('Current GeoRide token: %s', georide_context.get_token())
trackers = GeorideApi.get_trackers(georide_context.get_token()) trackers = GeoRideApi.get_trackers(georide_context.get_token())
tracker_entities = [] tracker_entities = []
for tracker in trackers: for tracker in trackers:
entity = GeorideTrackerEntity(tracker.tracker_id, georide_context.get_token, entity = GeoRideTrackerEntity(tracker.tracker_id, georide_context.get_token,
georide_context.get_tracker, tracker) georide_context.get_tracker, tracker)
@ -40,11 +40,11 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
return True return True
class GeorideTrackerEntity(TrackerEntity): class GeoRideTrackerEntity(TrackerEntity):
"""Represent a tracked device.""" """Represent a tracked device."""
def __init__(self, tracker_id, get_token_callback, get_tracker_callback, tracker): def __init__(self, tracker_id, get_token_callback, get_tracker_callback, tracker):
"""Set up Georide entity.""" """Set up GeoRide entity."""
self._tracker_id = tracker_id self._tracker_id = tracker_id
self._get_token_callback = get_token_callback self._get_token_callback = get_token_callback
self._get_tracker_callback = get_tracker_callback self._get_tracker_callback = get_tracker_callback
@ -88,6 +88,7 @@ class GeorideTrackerEntity(TrackerEntity):
@property @property
def icon(self): def icon(self):
"""return the entity icon"""
return "mdi:map-marker" return "mdi:map-marker"

2
custom_components/georide/manifest.json
Unescape View File

@ -1,6 +1,6 @@
{ {
"domain": "georide", "domain": "georide",
"name": "Georide", "name": "GeoRide",
"config_flow": true, "config_flow": true,
"documentation": "https://github.com/ptimatth/GeorideHA", "documentation": "https://github.com/ptimatth/GeorideHA",
"requirements": [ "requirements": [

18
custom_components/georide/sensor.py
Unescape View File

@ -1,4 +1,4 @@
""" odometter sensor for Georide object """ """ odometter sensor for GeoRide object """
import logging import logging
@ -6,7 +6,7 @@ from homeassistant.core import callback
from homeassistant.components.switch import SwitchEntity from homeassistant.components.switch import SwitchEntity
from homeassistant.components.switch import ENTITY_ID_FORMAT from homeassistant.components.switch import ENTITY_ID_FORMAT
import georideapilib.api as GeorideApi import georideapilib.api as GeoRideApi
from .const import DOMAIN as GEORIDE_DOMAIN from .const import DOMAIN as GEORIDE_DOMAIN
@ -15,17 +15,17 @@ _LOGGER = logging.getLogger(__name__)
async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: disable=W0613 async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: disable=W0613
"""Set up Georide tracker based off an entry.""" """Set up GeoRide tracker based off an entry."""
georide_context = hass.data[GEORIDE_DOMAIN]["context"] georide_context = hass.data[GEORIDE_DOMAIN]["context"]
if georide_context.get_token() is None: if georide_context.get_token() is None:
return False return False
trackers = GeorideApi.get_trackers(georide_context.get_token()) trackers = GeoRideApi.get_trackers(georide_context.get_token())
odometer_switch_entities = [] odometer_switch_entities = []
for tracker in trackers: for tracker in trackers:
entity = GeorideOdometerSensorEntity(tracker.tracker_id, georide_context.get_token, entity = GeoRideOdometerSensorEntity(tracker.tracker_id, georide_context.get_token,
georide_context.get_tracker, data=tracker) georide_context.get_tracker, data=tracker)
hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = entity hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = entity
odometer_switch_entities.append(entity) odometer_switch_entities.append(entity)
@ -34,7 +34,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
return True return True
class GeorideOdometerSensorEntity(SwitchEntity): class GeoRideOdometerSensorEntity(SwitchEntity):
"""Represent a tracked device.""" """Represent a tracked device."""
def __init__(self, tracker_id, get_token_callback, get_tracker_callback, data): def __init__(self, tracker_id, get_token_callback, get_tracker_callback, data):
@ -64,7 +64,7 @@ class GeorideOdometerSensorEntity(SwitchEntity):
@property @property
def name(self): def name(self):
""" Georide switch name """ """ GeoRide odometer name """
return self._name return self._name
@property @property
@ -77,12 +77,12 @@ class GeorideOdometerSensorEntity(SwitchEntity):
@property @property
def get_token_callback(self): def get_token_callback(self):
""" Georide switch token callback method """ """ GeoRide switch token callback method """
return self._get_token_callback return self._get_token_callback
@property @property
def get_tracker_callback(self): def get_tracker_callback(self):
""" Georide switch token callback method """ """ GeoRide switch token callback method """
return self._get_tracker_callback return self._get_tracker_callback
@property @property

2
custom_components/georide/strings.json
Unescape View File

@ -4,7 +4,7 @@
"step": { "step": {
"georide_login": { "georide_login": {
"title": "Set up GeoRide", "title": "Set up GeoRide",
"description": "Sign-in to georide", "description": "Sign-in to GeoRide",
"data": { "data": {
"email": "email", "email": "email",
"password": "password" "password": "password"

33
custom_components/georide/switch.py
Unescape View File

@ -1,4 +1,4 @@
""" device tracker for Georide object """ """ device tracker for GeoRide object """
import logging import logging
@ -6,7 +6,7 @@ from homeassistant.core import callback
from homeassistant.components.switch import SwitchEntity from homeassistant.components.switch import SwitchEntity
from homeassistant.components.switch import ENTITY_ID_FORMAT from homeassistant.components.switch import ENTITY_ID_FORMAT
import georideapilib.api as GeorideApi import georideapilib.api as GeoRideApi
from .const import DOMAIN as GEORIDE_DOMAIN from .const import DOMAIN as GEORIDE_DOMAIN
@ -15,7 +15,7 @@ _LOGGER = logging.getLogger(__name__)
async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: disable=W0613 async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: disable=W0613
"""Set up Georide tracker based off an entry.""" """Set up GeoRide tracker based off an entry."""
georide_context = hass.data[GEORIDE_DOMAIN]["context"] georide_context = hass.data[GEORIDE_DOMAIN]["context"]
if georide_context.get_token() is None: if georide_context.get_token() is None:
@ -23,11 +23,11 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
_LOGGER.info('Current georide token: %s', georide_context.get_token()) _LOGGER.info('Current georide token: %s', georide_context.get_token())
trackers = GeorideApi.get_trackers(georide_context.get_token()) trackers = GeoRideApi.get_trackers(georide_context.get_token())
lock_switch_entities = [] lock_switch_entities = []
for tracker in trackers: for tracker in trackers:
entity = GeorideLockSwitchEntity(tracker.tracker_id, georide_context.get_token, entity = GeoRideLockSwitchEntity(tracker.tracker_id, georide_context.get_token,
georide_context.get_tracker, data=tracker) georide_context.get_tracker, data=tracker)
hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = entity hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = entity
lock_switch_entities.append(entity) lock_switch_entities.append(entity)
@ -38,11 +38,11 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
class GeorideLockSwitchEntity(SwitchEntity): class GeoRideLockSwitchEntity(SwitchEntity):
"""Represent a tracked device.""" """Represent a tracked device."""
def __init__(self, tracker_id, get_token_callback, get_tracker_callback, data): def __init__(self, tracker_id, get_token_callback, get_tracker_callback, data):
"""Set up Georide entity.""" """Set up GeoRide entity."""
self._tracker_id = tracker_id self._tracker_id = tracker_id
self._data = data or {} self._data = data or {}
self._get_token_callback = get_token_callback self._get_token_callback = get_token_callback
@ -54,17 +54,17 @@ class GeorideLockSwitchEntity(SwitchEntity):
def turn_on(self, **kwargs): def turn_on(self, **kwargs):
""" lock the georide tracker """ """ lock the GeoRide tracker """
_LOGGER.info('async_turn_on %s', kwargs) _LOGGER.info('async_turn_on %s', kwargs)
success = GeorideApi.lock_tracker(self._get_token_callback(), self._tracker_id) success = GeoRideApi.lock_tracker(self._get_token_callback(), self._tracker_id)
if success: if success:
self._data.is_locked = True self._data.is_locked = True
self._is_on = True self._is_on = True
def turn_off(self, **kwargs): def turn_off(self, **kwargs):
""" unlock the georide tracker """ """ unlock the GeoRide tracker """
_LOGGER.info('async_turn_off %s', kwargs) _LOGGER.info('async_turn_off %s', kwargs)
success = GeorideApi.unlock_tracker(self._get_token_callback(), self._tracker_id) success = GeoRideApi.unlock_tracker(self._get_token_callback(), self._tracker_id)
if success: if success:
self._data.is_locked = False self._data.is_locked = False
self._is_on = False self._is_on = False
@ -72,7 +72,7 @@ class GeorideLockSwitchEntity(SwitchEntity):
async def async_toggle(self, **kwargs): async def async_toggle(self, **kwargs):
""" toggle lock the georide tracker """ """ toggle lock the georide tracker """
_LOGGER.info('async_toggle %s', kwargs) _LOGGER.info('async_toggle %s', kwargs)
result = GeorideApi.toogle_lock_tracker(self._get_token_callback(), result = GeoRideApi.toogle_lock_tracker(self._get_token_callback(),
self._tracker_id) self._tracker_id)
self._data.is_locked = result self._data.is_locked = result
self._is_on = result self._is_on = result
@ -92,26 +92,27 @@ class GeorideLockSwitchEntity(SwitchEntity):
@property @property
def name(self): def name(self):
""" Georide switch name """ """ GeoRide switch name """
return self._name return self._name
@property @property
def is_on(self): def is_on(self):
""" Georide switch status """ """ GeoRide switch status """
return self._is_on return self._is_on
@property @property
def get_token_callback(self): def get_token_callback(self):
""" Georide switch token callback method """ """ GeoRide switch token callback method """
return self._get_token_callback return self._get_token_callback
@property @property
def get_tracker_callback(self): def get_tracker_callback(self):
""" Georide switch token callback method """ """ GeoRide switch token callback method """
return self._get_tracker_callback return self._get_tracker_callback
@property @property
def icon(self): def icon(self):
"""return the entity icon"""
if self._is_on: if self._is_on:
return "mdi:lock" return "mdi:lock"
return "mdi:lock-open" return "mdi:lock-open"

2
custom_components/georide/translations/en.json
Unescape View File

@ -4,7 +4,7 @@
"step": { "step": {
"georide_login": { "georide_login": {
"title": "Set up GeoRide", "title": "Set up GeoRide",
"description": "Sign-in to georide", "description": "Sign-in to GeoRide",
"data": { "data": {
"email": "email", "email": "email",
"password": "password" "password": "password"

2
hacs.json
Unescape View File

@ -1,5 +1,5 @@
{ {
"name": "Georide integration", "name": "GeoRide integration",
"content_in_root": false, "content_in_root": false,
"render_readme": true, "render_readme": true,
"domains": ["devices_tracker", "sensor"], "domains": ["devices_tracker", "sensor"],

Write Preview
Loading…
Cancel
Save