Rework of GeoRide objects and add missing fields on Traker

develop
Matthieu DUVAL 1 year ago
parent edf209272d
commit 7e399cf982

@ -1,9 +1,7 @@
""" Example georideapilib code """
import logging.config
import time
import datetime
logging.config.fileConfig('logging.conf')
from georideapilib.objects import GeoRideAccount
import georideapilib.api as GeoRideApi
@ -13,11 +11,13 @@ from threading import Thread
_LOGGER = logging.getLogger('example')
DATE_START="2019-10-10"
DATE_END="2019-10-24"
def example():
""" simple example function """
# token = "<your_token>"# pylint: disable=C0301
# account = GeorideAccount(0, "<your_email>", False, token)
# account = GeoRideAccount(0, "<your_email>", False, token)
account = GeoRideApi.get_authorisation_token("<your_email>", "<your_password>")
@ -40,7 +40,7 @@ def example():
time.sleep(10)
socket.disconnect()
thread = Thread(target=connect_socket, args=(account))
thread = Thread(target=connect_socket, args=[account])
thread.start()
"""
@ -55,21 +55,26 @@ def example():
tracker = trackers[0]
_LOGGER.info("Tracker name: %s", tracker.tracker_name)
trips = GeoRideApi.get_trips(account.auth_token, tracker.tracker_id, "2019-10-10", "2019-10-24")
trip = trips[0]
trip_date = datetime.datetime.strptime("2019-10-10T06:45:34.000Z", '%Y-%m-%dT%H:%M:%S.%fZ')
_LOGGER.info("Trip date: %s, from: %s, to: %s", trip_date, trip.nice_start_address,
trip.nice_end_address)
trips = GeoRideApi.get_trips(account.auth_token, tracker.tracker_id, DATE_START, DATE_END)
if len(trips) < 1:
_LOGGER.info("No trip found for tracker name: %s between: %s and %s", tracker.tracker_name, DATE_START, DATE_END)
else:
trip = trips[0]
trip_date = datetime.datetime.strptime("2019-10-10T06:45:34.000Z", '%Y-%m-%dT%H:%M:%S.%fZ')
_LOGGER.info("Trip date: %s, from: %s, to: %s", trip_date, trip.nice_start_address,
trip.nice_end_address)
positions = GeoRideApi.get_positions(account.auth_token, tracker.tracker_id,
"2019-10-10", "2019-10-24")
position = positions[0]
_LOGGER.info("Position speed: %s, lon: %s, lat: %s", position.speed, position.longitude,
position.latitude)
DATE_START, DATE_END)
if len(positions) < 1:
_LOGGER.info("No positions found for tracker name: %s between: %s and %s", tracker.tracker_name, DATE_START, DATE_END)
else:
position = positions[0]
_LOGGER.info("Position speed: %s, lon: %s, lat: %s", position.speed, position.longitude,
position.latitude)
trip_shared = GeoRideApi.share_a_trip_by_date(account.auth_token, tracker.tracker_id,
"2019-10-10", "2019-10-24")
DATE_START, DATE_END)
_LOGGER.info("tripShared url: %s, id: %s", trip_shared.url, trip_shared.share_id)
time.sleep(10)

@ -6,7 +6,6 @@ Georide api lib
import json
import logging
import requests
from georideapilib.objects import (
GeoRideTracker,
GeoRideAccount,
@ -29,18 +28,18 @@ GEORIDE_API_ENDPOINT_NEW_TOKEN = "/user/new-token"
GEORIDE_API_ENDPOINT_LOGOUT = "/user/logout"
GEORIDE_API_ENDPOINT_USER = "/user"
GEORIDE_API_ENDPOINT_TRACKERS = "/user/trackers"
GEORIDE_API_ENDPOINT_TRIPS = "/tracker/:trackerId/trips"
GEORIDE_API_ENDPOINT_LOCK = "/tracker/:trackerId/lock"
GEORIDE_API_ENDPOINT_TRACKER_BEACON = "/tracker/:trackerId/beacon"
GEORIDE_API_ENDPOINT_UNLOCK = "/tracker/:trackerId/unlock"
GEORIDE_API_ENDPOINT_TOGGLE_LOCK = "/tracker/:trackerId/toggleLock"
GEORIDE_API_ENDPOINT_POSITIONS = "/tracker/:trackerId/trips/positions"
GEORIDE_API_ENDPOINT_TRIP_SHARE = "/tracker/:trackerId/share/trip"
GEORIDE_API_ENDPOINT_SHUTDOWN_TRACKER = "/tracker/:trackerId/shutdown"
GEORIDE_API_ENDPOINT_TRACKER_ALARM_OFF = "/tracker/:trackerId/sonor-alarm/off"
GEORIDE_API_ENDPOINT_TRACKER_ALARM_ON = "/tracker/:trackerId/sonor-alarm/on"
GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_OFF = "/tracker/:trackerId/eco-mode/off"
GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_ON = "/tracker/:trackerId/eco-mode/on"
GEORIDE_API_ENDPOINT_TRIPS = "/tracker/{trackerId}/trips"
GEORIDE_API_ENDPOINT_LOCK = "/tracker/{trackerId}/lock"
GEORIDE_API_ENDPOINT_TRACKER_BEACON = "/tracker/{trackerId}/beacon"
GEORIDE_API_ENDPOINT_UNLOCK = "/tracker/{trackerId}/unlock"
GEORIDE_API_ENDPOINT_TOGGLE_LOCK = "/tracker/{trackerId}/toggleLock"
GEORIDE_API_ENDPOINT_POSITIONS = "/tracker/{trackerId}/trips/positions"
GEORIDE_API_ENDPOINT_TRIP_SHARE = "/tracker/{trackerId}/share/trip"
GEORIDE_API_ENDPOINT_SHUTDOWN_TRACKER = "/tracker/{trackerId}/shutdown"
GEORIDE_API_ENDPOINT_TRACKER_ALARM_OFF = "/tracker/{trackerId}/sonor-alarm/off"
GEORIDE_API_ENDPOINT_TRACKER_ALARM_ON = "/tracker/{trackerId}/sonor-alarm/on"
GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_OFF = "/tracker/{trackerId}/eco-mode/off"
GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_ON = "/tracker/{trackerId}/eco-mode/on"
_SESSION = requests.Session()
_LOGGER = logging.getLogger(__name__)
@ -97,7 +96,7 @@ def revoke_token(token):
if response.status_code == 401:
_LOGGER.warnning("Token allready revoked")
raise UnauthorizedException(revoke_token, "Token allready revoked")
if response.status_code == 401:
if response.status_code == 403:
_LOGGER.warnning("Token allready revoked")
return False
return True
@ -134,7 +133,7 @@ def get_tracker_beacons(token, tracker_id):
headers = {"Authorization": "Bearer " + token}
response = _SESSION.get(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_BEACON.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_BEACON.format(trackerId=str(tracker_id)),
headers=headers)
response_data = response.json()
@ -150,28 +149,30 @@ def get_trips(token, tracker_id, from_date, to_date):
""" return all trips between two dates """
headers = {"Authorization": "Bearer " + token}
response = _SESSION.get(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIPS.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIPS.format(trackerId=str(tracker_id)),
params={'from': from_date, 'to': to_date},
headers=headers)
response_data = response.json()
trips = []
for json_trip in response_data:
trips.append(GeoRideTrackerTrip.from_json(json_trip))
if response.status_code == 200:
for json_trip in response_data:
trips.append(GeoRideTrackerTrip.from_json(json_trip))
return trips
def get_positions(token, tracker_id, from_date, to_date):
""" return all trips between two dates """
headers = {"Authorization": "Bearer " + token}
response = _SESSION.get(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_POSITIONS.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_POSITIONS.format(trackerId=str(tracker_id)),
params={'from': from_date, 'to': to_date},
headers=headers)
response_data = response.json()
positions = []
for json_position in response_data:
positions.append(GeoRideTrackerPosition.from_json(json_position))
if response.status_code == 200:
for json_position in response_data:
positions.append(GeoRideTrackerPosition.from_json(json_position))
return positions
def share_a_trip_by_trip_id(token, tracker_id, trip_id):
@ -204,18 +205,20 @@ def _share_a_trip(token, tracker_id, trip_id=None, from_date=None, # pylint: dis
'Content-Type': 'application/json'
}
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIP_SHARE.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIP_SHARE.format(trackerId=str(tracker_id)),
data=encoded_data,
headers=headers)
response_data = response.json()
return GeoRideSharedTrip.from_json(response_data)
if response.status_code == 200:
return GeoRideSharedTrip.from_json(response_data)
return None
def lock_tracker(token, tracker_id):
""" used to lock a tracker """
headers = {"Authorization": "Bearer " + token}
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOCK.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOCK.format(trackerId=str(tracker_id)),
headers=headers)
if response.status_code != 204:
return False
@ -225,7 +228,7 @@ def unlock_tracker(token, tracker_id):
""" used to unlock a tracker """
headers = {"Authorization": "Bearer " + token}
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_UNLOCK.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_UNLOCK.format(trackerId=str(tracker_id)),
headers=headers)
if response.status_code != 204:
return False
@ -235,7 +238,7 @@ def toogle_lock_tracker(token, tracker_id):
""" used to toggle lock a tracker """
headers = {"Authorization": "Bearer " + token}
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TOGGLE_LOCK.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TOGGLE_LOCK.format(trackerId=str(tracker_id)),
headers=headers)
response_data = response.json()
return response_data['locked']
@ -246,11 +249,11 @@ def change_tracker_siren_state(token, tracker_id, state: bool):
response = None
if state == True:
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ALARM_ON.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ALARM_ON.format(trackerId=str(tracker_id)),
headers=headers)
else:
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ALARM_OFF.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ALARM_OFF.format(trackerId=str(tracker_id)),
headers=headers)
if response.status_code != 204:
return False
@ -262,11 +265,11 @@ def change_tracker_eco_mode_state(token, tracker_id, state: bool):
response = None
if state == True:
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_ON.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_ON.format(trackerId=str(tracker_id)),
headers=headers)
else:
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_OFF.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_OFF.format(trackerId=str(tracker_id)),
headers=headers)
if response.status_code != 204:
return False
@ -276,10 +279,12 @@ def shutdown_tracker(token, tracker_id):
""" used to toggle lock a tracker """
headers = {"Authorization": "Bearer " + token}
response = _SESSION.post(
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_SHUTDOWN_TRACKER.replace(':trackerId', str(tracker_id)),
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_SHUTDOWN_TRACKER.format(trackerId=str(tracker_id)),
headers=headers)
response_data = response.json()
return response_data['locked']
if response.status_code == 200:
return response_data['locked']
return None
if __name__ == '__main__':
print("Not a main module")

@ -0,0 +1,51 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
_LOGGER = logging.getLogger(__name__)
class GeoRideAccount:
""" Account object representation """
def __init__(self, account_id, email, is_admin, auth_token):
self._account_id = account_id
self._email = emailgit
self._is_admin = is_admin
self._auth_token = auth_token
@property
def account_id(self):
""" account_id """
return self._account_id
@property
def email(self):
""" email """
return self._email
@property
def is_admin(self):
""" is_admin """
return self._is_admin
@property
def auth_token(self):
""" auth_token """
return self._auth_token
@auth_token.setter
def auth_token(self, new_token):
""" change auth_token """
self._auth_token = new_token
@staticmethod
def from_json(json):
"""return new object from_json"""
return GeoRideAccount(
json['id'],
json['email'],
json['isAdmin'],
json['authToken']
)

@ -0,0 +1,33 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
_LOGGER = logging.getLogger(__name__)
class GeoRideSharedTrip:
""" Shared trip object representation """
def __init__(self, url, shareId):
self._url = url
self._share_id = shareId
@property
def url(self):
""" shared trip url """
return self._url
@property
def share_id(self):
""" shared trip id """
return self._share_id
@staticmethod
def from_json(json):
"""return new object fromjson"""
return GeoRideSharedTrip(
json['url'],
json['shareId']
)

@ -0,0 +1,98 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
from . import JsonMgtMetaClass, GeoRideSubscription_CardInfo
_LOGGER = logging.getLogger(__name__)
class GeoRideSubscription(metaclass=JsonMgtMetaClass):
""" Account object representation """
def __init__(self, subscription_id, subscription_type, initial_date, next_payment_date,
status, paused_since, cancel_requested, price, first_name, last_name, card_information):
self._subscription_id = subscription_id
self._subscription_type = subscription_type
self._initial_date = initial_date
self._next_payment_date = next_payment_date
self._status = status
self._paused_since = paused_since
self._cancel_requested = cancel_requested
self._price = price
self._first_name = first_name
self._last_name = last_name
self._card_information = card_information
@property
def subscription_id(self):
"""subscription_id property"""
return self._subscription_id
@property
def subscription_type(self):
"""subscription_type property"""
return self._subscription_type
@property
def initial_date(self):
"""initial_date property"""
return self._initial_date
@property
def next_payment_date(self):
"""next_payment_date property"""
return self._next_payment_date
@property
def status(self):
"""status property"""
return self._status
@property
def paused_since(self):
"""paused_since property"""
return self._paused_since
@property
def cancel_requested(self):
"""cancel_requested property"""
return self._cancel_requested
@property
def price(self):
"""price property"""
return self._price
@property
def first_name(self):
"""first_name property"""
return self._first_name
@property
def last_name(self):
"""last_name property"""
return self._last_name
@property
def card_information(self):
"""card_information property"""
return self._card_information
@classmethod
def from_json(cls, json):
"""return new object from_json"""
card_info = GeoRideSubscription_CardInfo.from_json(json['cardInformation']) if cls.json_field_protect(json, 'cardInformation', None) is not None else {}
return GeoRideSubscription(
cls.json_field_protect(json, 'id', -1),
json['type'],
cls.json_field_protect(json, 'initialDate'),
cls.json_field_protect(json, 'nextPaymentDate'),
cls.json_field_protect(json, 'status'),
cls.json_field_protect(json, 'pausedSince'),
cls.json_field_protect(json, 'cancelRequested'),
cls.json_field_protect(json, 'price'),
cls.json_field_protect(json, 'firstName'),
cls.json_field_protect(json, 'lastName'),
card_info
)

@ -0,0 +1,41 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
from . import JsonMgtMetaClass
_LOGGER = logging.getLogger(__name__)
class GeoRideSubscription_CardInfo(metaclass=JsonMgtMetaClass):
""" Account object representation """
def __init__(self, last_digits, expiry, brand):
self._last_digits = last_digits
self._expiry = expiry
self._brand = brand
@property
def last_digits(self):
"""last_digits property"""
return self._last_digits
@property
def expiry(self):
"""expiry property"""
return self._expiry
@property
def brand(self):
"""brand property"""
return self._brand
@classmethod
def from_json(cls, json):
"""return new object from_json"""
return GeoRideSubscription_CardInfo(
cls.json_field_protect(json, 'lastDigits'),
cls.json_field_protect(json, 'expiry'),
cls.json_field_protect(json, 'brand')
)

@ -0,0 +1,115 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
from . import JsonMgtMetaClass
_LOGGER = logging.getLogger(__name__)
class GeoRideTrackerBeacon:
""" GeoRideTrackerBeacon representation """
def __init__(self, beacon_id, linked_tracker_id, name, created_at, updated_at,
mac_address, battery_level, last_battery_level_update, sleep_delay,
is_updated, power):
self._beacon_id = beacon_id
self._linked_tracker_id = linked_tracker_id
self._name = name
self._created_at = created_at
self._updated_at = updated_at
self._mac_address = mac_address
self._battery_level = battery_level
self._last_battery_level_update = last_battery_level_update
self._sleep_delay = sleep_delay
self._is_updated = is_updated
self._power = power
@property
def linked_tracker_id(self):
""" linked_tracker_id property """
return self._linked_tracker_id
@linked_tracker_id.setter
def linked_tracker_id(self, linked_tracker_id):
""" linked_tracker_id setter """
self._linked_tracker_id = linked_tracker_id
@property
def beacon_id(self):
"""beacon_id property"""
return self._beacon_id
@property
def name(self):
"""name property"""
return self._name
@property
def created_at(self):
"""created_at property"""
return self._created_at
@property
def updated_at(self):
"""updated_at property"""
return self._updated_at
@property
def mac_address(self):
"""mac_address property"""
return self._mac_address
@property
def battery_level(self):
"""battery_level property"""
return self._battery_level
@property
def last_battery_level_update(self):
"""last_battery_level_update property"""
return self._last_battery_level_update
@property
def sleep_delay(self):
"""sleep_delay property"""
return self._sleep_delay
@property
def is_updated(self):
"""is_updated property"""
return self._is_updated
@property
def power(self):
"""power property"""
return self._power
@classmethod
def from_json(cls, json):
"""return new object from_json"""
return GeoRideTrackerBeacon(
json['id'],
json['linked_tracker_id'],
json['name'],
json['createdAt'],
json['updatedAt'],
json['macAddress'],
json['batteryLevel'],
json['lastBatteryLevelUpdate'],
json['sleepDelay'],
json['isUpdated'],
json['power'])
def update_all_data(self, tracker_beacon):
"""update all data of the tracker beacon from a new object"""
self._name = tracker_beacon.name
self._created_at = tracker_beacon.created_at
self._updated_at = tracker_beacon.updated_at
self._mac_address = tracker_beacon.mac_address
self._battery_level = tracker_beacon.battery_level
self._last_battery_level_update = tracker_beacon.last_battery_level_update
self._sleep_delay = tracker_beacon.sleep_delay
self._is_updated = tracker_beacon.is_updated
self._power = tracker_beacon.power

@ -0,0 +1,60 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
_LOGGER = logging.getLogger(__name__)
class GeoRideTrackerPosition:
""" Tracker position object representation """
def __init__(self, fixtime, latitude, longitude, altitude, speed, address): # pylint: disable= R0913
self._fixtime = fixtime
self._latitude = latitude
self._longitude = longitude
self._altitude = altitude
self._speed = speed
self._address = address
@property
def fixtime(self):
""" fixtime """
return self._fixtime
@property
def latitude(self):
""" latitude """
return self._latitude
@property
def longitude(self):
""" longitude """
return self._longitude
@property
def altitude(self):
""" altitude """
return self._altitude
@property
def speed(self):
""" speed (m/s) """
return self._speed
@property
def address(self):
""" address """
return self._address
@staticmethod
def from_json(json):
"""return new object fromjson"""
return GeoRideTrackerPosition(
json['fixtime'],
json['latitude'],
json['longitude'],
json['altitude'],
json['speed'],
json['address']
)

@ -0,0 +1,134 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
_LOGGER = logging.getLogger(__name__)
class GeoRideTrackerTrip: # pylint: disable=too-many-instance-attributes
""" Trip object representation """
def __init__(self, trip_id, tracker_id, average_speed, max_speed, distance, duration, # pylint: disable=R0914, R0913
start_address, nice_start_address, start_lat, start_lon, end_address,
nice_end_address, end_lat, end_lon, start_time, end_time):
self._trip_id = trip_id
self._tracker_id = tracker_id
self._average_speed = average_speed
self._max_speed = max_speed
self._distance = distance
self._duration = duration
self._start_address = start_address
self._nice_start_address = nice_start_address
self._start_lat = start_lat
self._start_lon = start_lon
self._end_address = end_address
self._nice_end_address = nice_end_address
self._end_lat = end_lat
self._end_lon = end_lon
self._start_time = start_time
self._end_time = end_time
@property
def trip_id(self):
"""trip_id """
return self._trip_id
@property
def tracker_id(self):
""" tracker_id """
return self._tracker_id
@property
def average_speed(self):
""" average_speed """
return self._average_speed
@property
def max_speed(self):
""" max_speed """
return self._max_speed
@property
def distance(self):
""" distance """
return self._distance
@property
def duration(self):
""" duration """
return self._duration
@property
def start_address(self):
""" start_address """
return self._start_address
@property
def nice_start_address(self):
""" nice_start_address """
return self._nice_start_address
@property
def start_lat(self):
""" start_lat """
return self._start_lat
@property
def start_lon(self):
""" start_lon """
return self._start_lon
@property
def end_address(self):
""" end_address """
return self._end_address
@property
def nice_end_address(self):
""" nice_end_address """
return self._nice_end_address
@property
def end_lat(self):
"""end_lat """
return self._end_lat
@property
def end_lon(self):
"""end_lon """
return self._end_lon
@property
def start_time(self):
""" start_time """
return self._start_time
@property
def end_time(self):
""" end_time """
return self._end_time
@staticmethod
def from_json(json):
"""return new object from json"""
return GeoRideTrackerTrip(
json['id'],
json['trackerId'],
json['averageSpeed'],
json['maxSpeed'],
json['distance'],
json['duration'],
json['startAddress'],
json['niceStartAddress'],
json['startLat'],
json['startLon'],
json['endAddress'],
json['niceEndAddress'],
json['endLat'],
json['endLon'],
json['startTime'],
json['endTime']
)

@ -0,0 +1,75 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
_LOGGER = logging.getLogger(__name__)
class GeoRideUser: # pylint: disable= R0902
""" User object representation """
def __init__(self, user_id, email, first_name, created_at, phone_number, # pylint: disable= R0913
push_user_token, legal, date_of_birth):
self._user_id = user_id
self._email = email
self._first_name = first_name
self._created_at = created_at
self._phone_number = phone_number
self._push_user_token = push_user_token
self._legal = legal
self._date_of_birth = date_of_birth
@property
def user_id(self):
""" user_id """
return self._user_id
@property
def email(self):
""" email """
return self._email
@property
def first_name(self):
""" first_name """
return self._first_name
@property
def created_at(self):
""" created_at """
return self._created_at
@property
def phone_number(self):
""" phone_number """
return self._phone_number
@property
def push_user_token(self):
""" push_user_token """
return self._push_user_token
@property
def legal(self):
""" legal """
return self._legal
@property
def date_of_birth(self):
""" date_ofo_birth """
return self._date_of_birth
@staticmethod
def from_json(json):
"""return new object fromjson"""
return GeoRideUser(
json['id'],
json['email'],
json['firstName'],
json['createdAt'],
json['phoneNumber'],
json['pushUserToken'],
json['legal'],
json['dateOfBirth']
)

@ -0,0 +1,13 @@
"""
Georide objects implementation
@author Matthieu DUVAL <matthieu@duval-dev.fr>
"""
import time
import logging
_LOGGER = logging.getLogger(__name__)
class JsonMgtMetaClass(type):
@staticmethod
def json_field_protect(json, field_name, default_value = None):
return json[field_name] if field_name in json.keys() else default_value

@ -0,0 +1,11 @@
from .JsonMgtMetaClass import *
from .GeoRideAccount import *
from .GeoRideSharedTrip import *
from .GeoRideSubscription_CardInfo import *
from .GeoRideSubscription import *
from .GeoRideTracker import *
from .GeoRideTrackerBeacon import *
from .GeoRideTrackerPosition import *
from .GeoRideTrackerTrip import *
from .GeoRideUser import *

@ -18,8 +18,8 @@ CURRENT_DIR = os.path.dirname(__file__)
# "python setup.py register sdist upload -r pypitest"
setup(
name='georideapilib',
packages=['georideapilib'], # this must be the same as the name above
version='0.8.4',
packages=['georideapilib', 'georideapilib.objects'], # this must be the same as the name above
version='0.9.0',
description='Lib to control GeoRide tracker devices with theire rest api',
author='Matthieu DUVAL',
author_email='georideapilib@duval-dev.fr',

Loading…
Cancel
Save