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

Refactor after enabling pylint

Browse Source
This commit is contained in:
Matthieu DUVAL
2019-10-26 00:10:01 +02:00
parent cd5adffbd0
commit c30180221f
4 changed files with 684 additions and 556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
README.md
View File

@@ -22,3 +22,10 @@ pip install georideapilib
This library has been tested with python 3.7 and above, functionality for older python version cannot be guaranteed. This library has been tested with python 3.7 and above, functionality for older python version cannot be guaranteed.
## Todo
- [ ] Add support of SocketIO connection
- [ ] Add support of "Get a shared trip" endpoint

99
examples/example.py
View File

@@ -1,63 +1,72 @@
import api as GeorideApi """ Example georideapilib code """
from objects import GeorideAccount
import datetime
import time import time
import datetime
from georideapilib.objects import GeorideAccount
import georideapilib.api as GeorideApi
""" If ypu out to reuse account """ def example():
""" """ simple example function """
account = GeorideAccount(<your_id>, <yout_email>, <is_admin>, <your_token>) token = "<your_token>"# pylint: disable=C0301
""" account = GeorideAccount(0, "<your_email>", False, token)
""" Get an acces token """ """
account = GeorideApi.getAuthorisationToken("<your_email>", "<your_passord>") GeorideApi.getAuthorisationToken("<your_email>", "<your_password>")
print("token 1: ", account.authToken) print("token 1: ", account.auth_token)
""" # pylint: disable=W0105
""" do not abuse, renew when previous token have almost reached time """ """
""" account.auth_token = GeorideApi.renewToken(account.auth_token)
account.authToken = GeorideApi.renewToken(account.authToken) print("token 2: ", account.auth_token)
print("token 2: ", account.authToken) """ # pylint: disable=W0105
"""
user = GeorideApi.getUser(account.authToken) user = GeorideApi.get_user(account.auth_token)
print("User: ", user.firstName) print("User: ", user.first_name)
trackers = GeorideApi.getTrackers(account.authToken) trackers = GeorideApi.get_trackers(account.auth_token)
tracker = trackers[0] tracker = trackers[0]
print("Tracker name: ", tracker.trackerName) print("Tracker name: ", tracker.tracker_name)
trips = GeorideApi.getTrips(account.authToken, tracker.trackerId, "2019-10-10", "2019-10-24") trips = GeorideApi.get_trips(account.auth_token, tracker.tracker_id, "2019-10-10", "2019-10-24")
trip = trips[0]; trip = trips[0]
trip_date = datetime.datetime.strptime("2019-10-10T06:45:34.000Z", '%Y-%m-%dT%H:%M:%S.%fZ') trip_date = datetime.datetime.strptime("2019-10-10T06:45:34.000Z", '%Y-%m-%dT%H:%M:%S.%fZ')
print("Trip date: {}, from: {}, to: {}".format(trip_date, trip.niceStartAddress, trip.niceEndAddress)) print("Trip date: {}, from: {}, to: {}".format(trip_date, trip.nice_start_address,
trip.nice_end_address))
positions = GeorideApi.getPositions(account.authToken, tracker.trackerId, "2019-10-10", "2019-10-24") positions = GeorideApi.get_positions(account.auth_token, tracker.tracker_id,
position = positions[0]; "2019-10-10", "2019-10-24")
print("Position speed: {}, lon: {}, lat: {}".format(position.speed, position.longitude, position.latitude)) position = positions[0]
print("Position speed: {}, lon: {}, lat: {}".format(position.speed, position.longitude,
position.latitude))
tripShared = GeorideApi.shareATripByDate(account.authToken, tracker.trackerId, fromDate="2019-10-10", toDate="2019-10-24") trip_shared = GeorideApi.share_a_trip_by_date(account.auth_token, tracker.tracker_id,
print("tripShared url: {}, id: {}".format(tripShared.url, tripShared.shareId)) "2019-10-10", "2019-10-24")
print("tripShared url: {}, id: {}".format(trip_shared.url, trip_shared.share_id))
time.sleep(30) time.sleep(10)
haveBeenLocked = GeorideApi.lockTracker(account.authToken, tracker.trackerId) have_been_locked = GeorideApi.lock_tracker(account.auth_token, tracker.tracker_id)
print("Tracker have been locked: ", haveBeenLocked) print("Tracker have been locked: ", have_been_locked)
time.sleep(30) time.sleep(10)
haveBeenUnlocked = GeorideApi.lockTracker(account.authToken, tracker.trackerId) have_been_unlocked = GeorideApi.unlock_tracker(account.auth_token, tracker.tracker_id)
print("Tracker have been unlocked: ", haveBeenUnlocked) print("Tracker have been unlocked: ", have_been_unlocked)
time.sleep(30) time.sleep(10)
isLocked = GeorideApi.toogleLockTracker(account.authToken, tracker.trackerId) is_locked = GeorideApi.toogle_lock_tracker(account.auth_token, tracker.tracker_id)
print("Tracker is locked: ", haveBeenUnlocked) print("Tracker is locked: ", is_locked)
time.sleep(30) time.sleep(10)
trackers = GeorideApi.getTrackers(account.authToken) trackers = GeorideApi.get_trackers(account.auth_token)
tracker = trackers[0] tracker = trackers[0]
print("Tracker name: ", tracker.trackerName, " is locked: ", tracker.isLocked) print("Tracker name: ", tracker.tracker_name, " is locked: ", tracker.is_locked)
""" """
GeorideApi.revokeToken(account.authToken) GeorideApi.revokeToken(account.auth_token)
""" """ # pylint: disable=W0105
example()

122
georideapilib/api.py
View File

@@ -3,10 +3,17 @@ Georide api lib
@author Matthieu DUVAL <matthieu@duval-dev.fr> @author Matthieu DUVAL <matthieu@duval-dev.fr>
""" """
import urllib3
import json import json
import urllib3
from objects import GeorideTracker, GeorideAccount, GeorideUser, GeorideTrackerTrip, GeorideTrackerPosition, GeorideSharedTrip from georideapilib.objects import (
GeorideTracker,
GeorideAccount,
GeorideUser,
GeorideTrackerTrip,
GeorideTrackerPosition,
GeorideSharedTrip
)
GEORIDE_API_HOST = "https://api.georide.fr" GEORIDE_API_HOST = "https://api.georide.fr"
GEORIDE_API_ENDPOINT_LOGIN = "/user/login" GEORIDE_API_ENDPOINT_LOGIN = "/user/login"
@@ -22,9 +29,10 @@ GEORIDE_API_ENDPOINT_POSITIONS = "/tracker/:trackerId/trips/positions"
GEORIDE_API_ENDPOINT_TRIP_SHARE = "/tracker/:trackerId/share/trip" GEORIDE_API_ENDPOINT_TRIP_SHARE = "/tracker/:trackerId/share/trip"
def getAuthorisationToken(email, password): def get_authorisation_token(email, password):
""" return an authorization token """
http = urllib3.PoolManager() http = urllib3.PoolManager()
data = {"email": email,"password": password} data = {"email": email, "password": password}
encoded_data = json.dumps(data).encode('utf-8') encoded_data = json.dumps(data).encode('utf-8')
response = http.request( response = http.request(
'POST', 'POST',
@@ -32,11 +40,12 @@ def getAuthorisationToken(email, password):
body=encoded_data, body=encoded_data,
headers={'Content-Type': 'application/json'}) headers={'Content-Type': 'application/json'})
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
account = GeorideAccount.fromJson(response_data) account = GeorideAccount.from_json(response_data)
return account return account
def renewToken(token): def renew_token(token):
""" renew the authorization token """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
@@ -44,24 +53,25 @@ def renewToken(token):
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_NEW_TOKEN, GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_NEW_TOKEN,
headers=headers) headers=headers)
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
newToken = response_data['authToken'] new_token = response_data['authToken']
return newToken return new_token
def revokeToken(token): def revoke_token(token):
""" invalidate the authorization token """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
'POST', 'POST',
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOGOUT, GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOGOUT,
headers=headers) headers=headers)
if response.status == 204: if response.status != 204:
return True
else:
return False return False
return True
def getUser(token): def get_user(token):
""" get the georide user info """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
@@ -69,10 +79,11 @@ def getUser(token):
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_USER, GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_USER,
headers=headers) headers=headers)
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
account = GeorideUser.fromJson(response_data) account = GeorideUser.from_json(response_data)
return account return account
def getTrackers(token): def get_trackers(token):
""" get user trackers """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
@@ -83,57 +94,64 @@ def getTrackers(token):
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
trackers = [] trackers = []
for json_tracker in response_data: for json_tracker in response_data:
trackers.append(GeorideTracker.fromJson(json_tracker)) trackers.append(GeorideTracker.from_json(json_tracker))
return trackers return trackers
def getTrips(token, trackerId, fromDate, toDate): def get_trips(token, tracker_id, from_date, to_date):
""" return all trips between two dates """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
'GET', 'GET',
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIPS.replace(':trackerId', str(trackerId)), GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIPS.replace(':trackerId', str(tracker_id)),
fields={'from': fromDate, 'to': toDate}, fields={'from': from_date, 'to': to_date},
headers=headers) headers=headers)
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
trips = [] trips = []
for json_trip in response_data: for json_trip in response_data:
trips.append(GeorideTrackerTrip.fromJson(json_trip)) trips.append(GeorideTrackerTrip.from_json(json_trip))
return trips return trips
def getPositions(token, trackerId, fromDate, toDate): def get_positions(token, tracker_id, from_date, to_date):
""" return all trips between two dates """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
'GET', 'GET',
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_POSITIONS.replace(':trackerId', str(trackerId)), GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_POSITIONS.replace(':trackerId', str(tracker_id)),
fields={'from': fromDate, 'to': toDate}, fields={'from': from_date, 'to': to_date},
headers=headers) headers=headers)
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
positions = [] positions = []
for json_position in response_data: for json_position in response_data:
positions.append(GeorideTrackerPosition.fromJson(json_position)) positions.append(GeorideTrackerPosition.from_json(json_position))
return positions return positions
def shareATripByTripId(token, trackerId, tripId): def share_a_trip_by_trip_id(token, tracker_id, trip_id):
return _shareATrip(token, trackerId, tripId=tripId) """ share trip by trip id """
return _share_a_trip(token, tracker_id, trip_id=trip_id)
def shareATripByDate(token, trackerId, fromDate, toDate): def share_a_trip_by_date(token, tracker_id, from_date, to_date):
return _shareATrip(token, trackerId, fromDate=fromDate, toDate=toDate) """ share trips between two dates """
return _share_a_trip(token, tracker_id, from_date=from_date, to_date=to_date)
def shareATripByTripMergeId(token, trackerId, tripMergedId): def share_a_trip_by_trip_merge_id(token, tracker_id, trip_merged_id):
return _shareATrip(token, trackerId, tripMergedId=tripMergedId) """ share trip by trip merged id """
return _share_a_trip(token, tracker_id, trip_merged_id=trip_merged_id)
def _shareATrip(token, trackerId, tripId=None, fromDate=None, toDate=None, tripMergedId=None): def _share_a_trip(token, tracker_id, trip_id=None, from_date=None, # pylint: disable= R0913
to_date=None, trip_merged_id=None):
""" share trip by trib_id or between two dates or trip_merged_id """
data = None data = None
if tripId != None: if trip_id is not None:
data = {"tripId": tripId} data = {"tripId": trip_id}
elif fromDate != None and toDate != None: elif from_date is not None and to_date is not None:
data = {"from": fromDate, "to": toDate} data = {"from": from_date, "to": to_date}
elif tripMergedId != None: elif trip_merged_id is not None:
data = {"tripMergedId": tripMergedId} data = {"tripMergedId": trip_merged_id}
encoded_data = json.dumps(data).encode('utf-8') encoded_data = json.dumps(data).encode('utf-8')
print("Trip data: ", encoded_data) print("Trip data: ", encoded_data)
@@ -145,48 +163,48 @@ def _shareATrip(token, trackerId, tripId=None, fromDate=None, toDate=None, tripM
} }
response = http.request( response = http.request(
'POST', 'POST',
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIP_SHARE.replace(':trackerId', str(trackerId)), GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIP_SHARE.replace(':trackerId', str(tracker_id)),
body=encoded_data, body=encoded_data,
headers=headers) headers=headers)
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
print("Trip data: ", response_data) print("Trip data: ", response_data)
return GeorideSharedTrip.fromJson(response_data) return GeorideSharedTrip.from_json(response_data)
def lockTracker(token, trackerId): def lock_tracker(token, tracker_id):
""" used to lock a tracker """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
'POST', 'POST',
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOCK.replace(':trackerId', str(trackerId)), GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOCK.replace(':trackerId', str(tracker_id)),
headers=headers) headers=headers)
if response.status == 204: if response.status != 204:
return True
else:
return False return False
return True
def unlockTracker(token, trackerId): def unlock_tracker(token, tracker_id):
""" used to unlock a tracker """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
'POST', 'POST',
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_UNCLOCK.replace(':trackerId', str(trackerId)), GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_UNLOCK.replace(':trackerId', str(tracker_id)),
headers=headers) headers=headers)
if response.status == 204: if response.status != 204:
return True
else:
return False return False
return True
def toogleLockTracker(token, trackerId): def toogle_lock_tracker(token, tracker_id):
""" used to toggle lock a tracker """
http = urllib3.PoolManager() http = urllib3.PoolManager()
headers = {"Authorization": "Bearer " + token} headers = {"Authorization": "Bearer " + token}
response = http.request( response = http.request(
'POST', 'POST',
GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TOGGLE_LOCK.replace(':trackerId', str(trackerId)), GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TOGGLE_LOCK.replace(':trackerId', str(tracker_id)),
headers=headers) headers=headers)
response_data = json.loads(response.data.decode('utf-8')) response_data = json.loads(response.data.decode('utf-8'))
return response_data['locked'] return response_data['locked']
if __name__ == '__main__': if __name__ == '__main__':
print("Not a main module") print("Not a main module")

900
georideapilib/objects.py
View File

@@ -4,501 +4,595 @@ Georide objects implementation
""" """
class GeorideSharedTrip: class GeorideSharedTrip:
def __init__(self, url, shareId): """ Shared trip object representation """
self._url = url def __init__(self, url, shareId):
self._shareId = shareId self._url = url
self._share_id = shareId
@property @property
def url(self): def url(self):
return self._url """ shared trip url """
return self._url
@property @property
def shareId(self): def share_id(self):
return self._shareId """ shared trip id """
return self._share_id
def fromJson(json): @staticmethod
return GeorideSharedTrip( def from_json(json):
json['url'], """return new object fromjson"""
json['shareId'] return GeorideSharedTrip(
) json['url'],
json['shareId']
)
class GeorideTrackerTrip: class GeorideTrackerTrip: # pylint: disable=too-many-instance-attributes
def __init__(self, tripId, trackerId, averageSpeed, maxSpeed, distance, duration, startAddress, niceStartAddress, startLat, """ Trip object representation """
startLon, endAddress, niceEndAddress, endLat, endLon, startTime, endTime): def __init__(self, trip_id, tracker_id, average_speed, max_speed, distance, duration, # pylint: disable=R0914, R0913
self._tripId = tripId start_address, nice_start_address, start_lat, start_lon, end_address,
self._trackerId = trackerId nice_end_address, end_lat, end_lon, start_time, end_time):
self._averageSpeed = averageSpeed self._trip_id = trip_id
self._maxSpeed = maxSpeed self._tracker_id = tracker_id
self._distance = distance self._average_speed = average_speed
self._duration = duration self._max_speed = max_speed
self._startAddress = startAddress self._distance = distance
self._niceStartAddress = niceStartAddress self._duration = duration
self._startLat = startLat self._start_address = start_address
self._startLon = startLon self._nice_start_address = nice_start_address
self._endAddress = endAddress self._start_lat = start_lat
self._niceEndAddress = niceEndAddress self._start_lon = start_lon
self._endLat = endLat self._end_address = end_address
self._endLon = endLon self._nice_end_address = nice_end_address
self._startTime = startTime self._end_lat = end_lat
self._endTime = endTime self._end_lon = end_lon
self._start_time = start_time
self._end_time = end_time
@property
def tripId(self):
return self._tripId
@property @property
def trackerId(self): def trip_id(self):
return self._trackerId """trip_id """
return self._trip_id
@property @property
def averageSpeed(self): def tracker_id(self):
return self._averageSpeed """ tracker_id """
return self._tracker_id
@property @property
def maxSpeed(self): def average_speed(self):
return self._maxSpeed """ average_speed """
return self._average_speed
@property @property
def distance(self): def max_speed(self):
return self._distance """ max_speed """
return self._max_speed
@property @property
def duration(self): def distance(self):
return self._duration """ distance """
return self._distance
@property @property
def startAddress(self): def duration(self):
return self._startAddress """ duration """
return self._duration
@property @property
def niceStartAddress(self): def start_address(self):
return self._niceStartAddress """ start_address """
return self._start_address
@property @property
def startLat(self): def nice_start_address(self):
return self._startLat """ nice_start_address """
return self._nice_start_address
@property @property
def startLon(self): def start_lat(self):
return self._startLon """ start_lat """
return self._start_lat
@property @property
def endAddress(self): def start_lon(self):
return self._endAddress """ start_lon """
return self._start_lon
@property @property
def niceEndAddress(self): def end_address(self):
return self._niceEndAddress """ end_address """
return self._end_address
@property @property
def endLat(self): def nice_end_address(self):
return self._endLat """ nice_end_address """
return self._nice_end_address
@property @property
def endLon(self): def end_lat(self):
return self._endLon """end_lat """
return self._end_lat
@property @property
def startTime(self): def end_lon(self):
return self._startTime """end_lon """
return self._end_lon
@property @property
def endTime(self): def start_time(self):
return self._endTime """ start_time """
return self._start_time
def fromJson(json): @property
return GeorideTrackerTrip( def end_time(self):
json['id'], """ end_time """
json['trackerId'], return self._end_time
json['averageSpeed'],
json['maxSpeed'],
json['distance'], @staticmethod
json['duration'], def from_json(json):
json['startAddress'], """return new object from json"""
json['niceStartAddress'], return GeorideTrackerTrip(
json['startLat'], json['id'],
json['startLon'], json['trackerId'],
json['endAddress'], json['averageSpeed'],
json['niceEndAddress'], json['maxSpeed'],
json['endLat'], json['distance'],
json['endLon'], json['duration'],
json['startTime'], json['startAddress'],
json['endTime'] json['niceStartAddress'],
) json['startLat'],
json['startLon'],
json['endAddress'],
json['niceEndAddress'],
json['endLat'],
json['endLon'],
json['startTime'],
json['endTime']
)
class GeorideTrackerPosition: class GeorideTrackerPosition:
def __init__(self, fixtime, latitude, longitude, altitude, speed, address): """ Tracker position object representation """
self._fixtime = fixtime def __init__(self, fixtime, latitude, longitude, altitude, speed, address): # pylint: disable= R0913
self._latitude = latitude self._fixtime = fixtime
self._longitude = longitude self._latitude = latitude
self._altitude = altitude self._longitude = longitude
self._speed = speed self._altitude = altitude
self._address = address self._speed = speed
self._address = address
@property @property
def fixtime(self): def fixtime(self):
return self._fixtime """ fixtime """
return self._fixtime
@property @property
def latitude(self): def latitude(self):
return self._latitude """ latitude """
return self._latitude
@property @property
def longitude(self): def longitude(self):
return self._longitude """ longitude """
return self._longitude
@property @property
def altitude(self): def altitude(self):
return self._altitude """ altitude """
return self._altitude
@property @property
def speed(self): def speed(self):
return self._speed """ speed (m/s) """
return self._speed
@property @property
def address(self): def address(self):
return self._address """ address """
return self._address
def fromJson(json): @staticmethod
return GeorideTrackerPosition( def from_json(json):
json['fixtime'], """return new object fromjson"""
json['latitude'], return GeorideTrackerPosition(
json['longitude'], json['fixtime'],
json['altitude'], json['latitude'],
json['speed'], json['longitude'],
json['address'] json['altitude'],
) json['speed'],
json['address']
)
class GeorideTracker: class GeorideTracker: # pylint: disable=R0904,R0902
def __init__(self, trackerId, trackerName, deviceButtonAction, deviceButtonDelay, vibrationLevel, isOldTracker, autoLockFreezedTo, """ Tracker position object representation """
fixtime, role, lastPaymentDate, giftCardId, expires, activationDate, odometer, isStolen, isCrashed, crashDetectionDisabled, def __init__(self, tracker_id, tracker_name, device_button_action, device_button_delay, # pylint: disable= R0913, R0914, R0915
speed, moving, positionId, latitude, longitude, altitude, lockedPositionId, lockedLatitude, lockedLongitude, isLocked, vibration_level, is_old_tracker, auto_lock_freezed_to, fixtime, role,
canSeePosition, canLock, canUnlock, canShare, canUnshare, canCheckSpeed, canSeeStatistics, canSendBrokenDownSignal, last_payment_date, gift_card_id, expires, activation_date, odometer, is_stolen,
canSendStolenSignal, status): is_crashed, crash_detection_disabled, speed, moving, position_id, latitude,
self._trackerId = trackerId longitude, altitude, locked_position_id, locked_latitude, locked_longitude,
self._trackerName = trackerName is_locked, can_see_position, can_lock, can_unlock, can_share, can_unshare,
self._deviceButtonAction = deviceButtonAction can_check_speed, can_see_statistics, can_send_broken_down_signal,
self._deviceButtonDelay = deviceButtonDelay can_send_stolen_signal, status):
self._vibrationLevel = vibrationLevel self._tracker_id = tracker_id
self._isOldTracker = isOldTracker self._tracker_name = tracker_name
self._autoLockFreezedTo = autoLockFreezedTo self._device_button_action = device_button_action
self._fixtime = fixtime self._device_button_delay = device_button_delay
self._role = role self._vibration_level = vibration_level
self._lastPaymentDate = lastPaymentDate self._is_old_tracker = is_old_tracker
self._giftCardId = giftCardId self._auto_lock_freezed_to = auto_lock_freezed_to
self._expires = expires self._fixtime = fixtime
self._activationDate = activationDate self._role = role
self._odometer = odometer self._last_payment_date = last_payment_date
self._isStolen = isStolen self._gift_card_id = gift_card_id
self._isCrashed = isCrashed self._expires = expires
self._crashDetectionDisabled = crashDetectionDisabled self._activation_date = activation_date
self._speed = speed self._odometer = odometer
self._moving = moving self._is_stolen = is_stolen
self._positionId = positionId self._is_crashed = is_crashed
self._latitude = latitude self._crash_detection_disabled = crash_detection_disabled
self._longitude = longitude self._speed = speed
self._altitude = altitude self._moving = moving
self._lockedPositionId = lockedPositionId self._position_id = position_id
self._lockedLatitude = lockedLatitude self._latitude = latitude
self._lockedLongitude = lockedLongitude self._longitude = longitude
self._isLocked = isLocked self._altitude = altitude
self._canSeePosition = canSeePosition self._locked_position_id = locked_position_id
self._canLock = canLock self._locked_latitude = locked_latitude
self._canUnlock = canUnlock self._locked_longitude = locked_longitude
self._canShare = canShare self._is_locked = is_locked
self._canUnshare = canUnshare self._can_see_position = can_see_position
self._canCheckSpeed = canCheckSpeed self._can_lock = can_lock
self._canSeeStatistics = canSeeStatistics self._can_unlock = can_unlock
self._canSendBrokenDownSignal = canSendBrokenDownSignal self._can_share = can_share
self._canSendStolenSignal = canSendStolenSignal self._can_unshare = can_unshare
self._status = status self._can_check_speed = can_check_speed
self._can_see_statistics = can_see_statistics
self._can_send_broken_down_signal = can_send_broken_down_signal
self._can_send_stolen_signal = can_send_stolen_signal
self._status = status
@property @property
def trackerId(self): def tracker_id(self):
return self._trackerId """ tracker_id """
return self._tracker_id
@property @property
def trackerName(self): def tracker_name(self):
return self._trackerName """ tracker_name """
return self._tracker_name
@property @property
def deviceButtonAction(self): def device_button_action(self):
return self._deviceButtonAction """ device_button_action """
return self._device_button_action
@property @property
def deviceButtonDelay(self): def device_button_delay(self):
return self._deviceButtonDelay """ device_button_delay """
return self._device_button_delay
@property @property
def vibrationLevel(self): def vibration_level(self):
return self._vibrationLevel """ vibration_level """
return self._vibration_level
@property @property
def isOldTracker(self): def is_old_tracker(self):
return self._isOldTracker """ is_old_tracker """
return self._is_old_tracker
@property @property
def autoLockFreesedTo(self): def auto_lock_freezed_to(self):
return self._autoLockFreesedTo """ auto_lock_freezed_to """
return self._auto_lock_freezed_to
@property @property
def fixtime(self): def fixtime(self):
return self._fixtime """ fixtime """
return self._fixtime
@property @property
def role(self): def role(self):
return self._role """ role """
return self._role
@property @property
def lastPayementDate(self): def last_payment_date(self):
return self._lastPayementDate """ last_payment_date """
return self._last_payment_date
@property @property
def giftCardId(self): def gift_card_id(self):
return self._giftCardId """ gift_card_id """
return self._gift_card_id
@property @property
def expires(self): def expires(self):
return self._expires """ expires """
return self._expires
@property @property
def activationDate(self): def activation_date(self):
return self._activationDate """ activation_date """
return self._activation_date
@property @property
def odometer(self): def odometer(self):
return self._odometer """ odometer """
return self._odometer
@property @property
def isStolen(self): def is_stolen(self):
return self._isStolen """ is_stolen """
return self._is_stolen
@property @property
def isCrashed(self): def is_crashed(self):
return self._isCrashed """ is_crashed """
return self._is_crashed
@property @property
def crashDetectionDisabled(self): def crash_detection_disabled(self):
return self._crashDetectionDisabled """ crash_detection_disabled """
return self._crash_detection_disabled
@property @property
def speed(self): def speed(self):
return self._speed """ speed """
return self._speed
@property @property
def moving(self): def moving(self):
return self._moving """ moving """
return self._moving
@property @property
def positionId(self): def position_id(self):
return self._positionId """ position_id """
return self._position_id
@property @property
def latitude(self): def latitude(self):
return self._latitude """ latitude """
return self._latitude
@property @property
def longitude(self): def longitude(self):
return self._longitude """ longitude """
return self._longitude
@property @property
def altitude(self): def altitude(self):
return self._altitude """ altitude """
return self._altitude
@property @property
def lockedPositionId(self): def locked_position_id(self):
return self._lockedPositionId """ locked_position_id """
return self._locked_position_id
@property @property
def lockedLatitude(self): def locked_latitude(self):
return self._lockedLatitude """ locked_latitude """
return self._locked_latitude
@property @property
def lockedLongitude(self): def locked_longitude(self):
return self._lockedLongitude """ locked_longitude """
return self._locked_longitude
@property @property
def isLocked(self): def is_locked(self):
return self._isLocked """ is_locked """
return self._is_locked
@property @property
def canSeePosition(self): def can_see_position(self):
return self._canSeePosition """ can_see_position """
return self._can_see_position
@property @property
def canLock(self): def can_lock(self):
return self._canLock """ can_lock """
return self._can_lock
@property @property
def canUnlock(self): def can_unlock(self):
return self._canUnlock """ can_unlock """
return self._can_unlock
@property @property
def canShare(self): def can_share(self):
return self._canShare """ can_share """
return self._can_share
@property @property
def canUnshare(self): def can_unshare(self):
return self._canUnshare """ can_unshare """
return self._can_unshare
@property @property
def canCheckSpeed(self): def can_check_speed(self):
return self._canCheckSpeed """ can_check_speed """
return self._can_check_speed
@property @property
def canSeeStatistics(self): def can_see_statistics(self):
return self._canSeeStatistics """ can_see_statistics """
return self._can_see_statistics
@property @property
def canSendBrokenDownSignal(self): def can_send_broken_down_signal(self):
return self._canSendBrokenDownSignal """ can_send_broken_down_signal """
return self._can_send_broken_down_signal
@property @property
def canSendStolenSignal(self): def can_send_stolen_signal(self):
return self._canSendStolenSignal """ can_send_stolen_signal """
return self._can_send_stolen_signal
@property @property
def status(self): def status(self):
return self._status """ status """
return self._status
def fromJson(json): @staticmethod
return GeorideTracker( def from_json(json):
json['trackerId'], """return new object fromjson"""
json['trackerName'], return GeorideTracker(
json['deviceButtonAction'], json['trackerId'],
json['deviceButtonDelay'], json['trackerName'],
json['vibrationLevel'], json['deviceButtonAction'],
json['isOldTracker'], json['deviceButtonDelay'],
json['autoLockFreezedTo'], json['vibrationLevel'],
json['fixtime'], json['isOldTracker'],
json['role'], json['autoLockFreezedTo'],
json['lastPaymentDate'], json['fixtime'],
json['giftCardId'], json['role'],
json['expires'], json['lastPaymentDate'],
json['activationDate'], json['giftCardId'],
json['odometer'], json['expires'],
json['isStolen'], json['activationDate'],
json['isCrashed'], json['odometer'],
json['crashDetectionDisabled'], json['isStolen'],
json['speed'], json['isCrashed'],
json['moving'], json['crashDetectionDisabled'],
json['positionId'], json['speed'],
json['latitude'], json['moving'],
json['longitude'], json['positionId'],
json['altitude'], json['latitude'],
json['lockedPositionId'], json['longitude'],
json['lockedLatitude'], json['altitude'],
json['lockedLongitude'], json['lockedPositionId'],
json['isLocked'], json['lockedLatitude'],
json['canSeePosition'], json['lockedLongitude'],
json['canLock'], json['isLocked'],
json['canUnlock'], json['canSeePosition'],
json['canShare'], json['canLock'],
json['canUnshare'], json['canUnlock'],
json['canCheckSpeed'], json['canShare'],
json['canSeeStatistics'], json['canUnshare'],
json['canSendBrokenDownSignal'], json['canCheckSpeed'],
json['canSendStolenSignal'], json['canSeeStatistics'],
json['status'] json['canSendBrokenDownSignal'],
) json['canSendStolenSignal'],
json['status']
)
class GeorideAccount: class GeorideAccount:
def __init__(self, account_id, email, isAdmin, authToken): """ Account object representation """
self._account_id = account_id def __init__(self, account_id, email, is_admin, auth_token):
self._email = email self._account_id = account_id
self._isAdmin = isAdmin self._email = email
self._authToken = authToken self._is_admin = is_admin
self._auth_token = auth_token
@property @property
def account_id(self): def account_id(self):
return self._account_id """ account_id """
return self._account_id
@property @property
def email(self): def email(self):
return self._email """ email """
return self._email
@property @property
def isAdmin(self): def is_admin(self):
return self._isAdmin """ is_admin """
return self._is_admin
@property @property
def authToken(self): def auth_token(self):
return self._authToken """ auth_token """
return self._auth_token
@authToken.setter @auth_token.setter
def authToken(self, newToken): def auth_token(self, new_token):
self._authToken = newToken """ change auth_token """
self._auth_token = new_token
def fromJson(json): @staticmethod
return GeorideAccount( def from_json(json):
json['id'], """return new object from_json"""
json['email'], return GeorideAccount(
json['isAdmin'], json['id'],
json['authToken'] json['email'],
json['isAdmin'],
json['authToken']
) )
class GeorideUser: class GeorideUser: # pylint: disable= R0902
def __init__(self, account_id, email, firstName, createdAt, phoneNumberp, pushUserToken, legal, dateOfBirth): """ User object representation """
self._account_id = account_id def __init__(self, user_id, email, first_name, created_at, phone_number, # pylint: disable= R0913
self._email = email push_user_token, legal, date_of_birth):
self._firstName = firstName self._user_id = user_id
self._createdAt = createdAt self._email = email
self._phoneNumberp = phoneNumberp self._first_name = first_name
self._pushUserToken = pushUserToken self._created_at = created_at
self._legal = legal self._phone_number = phone_number
self._dateOfBirth = dateOfBirth self._push_user_token = push_user_token
self._legal = legal
self._date_of_birth = date_of_birth
@property @property
def user_id(self): def user_id(self):
return self._user_id """ user_id """
return self._user_id
@property @property
def email(self): def email(self):
return self._email """ email """
return self._email
@property @property
def firstName(self): def first_name(self):
return self._firstName """ first_name """
return self._first_name
@property @property
def createdAt(self): def created_at(self):
return self._createdAt """ created_at """
return self._created_at
@property @property
def phoneNumber(self): def phone_number(self):
return self._phoneNumber """ phone_number """
return self._phone_number
@property @property
def pushUserToken(self): def push_user_token(self):
return self._pushUserToken """ push_user_token """
return self._push_user_token
@property @property
def legal(self): def legal(self):
return self._legal """ legal """
return self._legal
@property @property
def dateOfBirth(self): def date_of_birth(self):
return self._dateOfBirth """ date_ofo_birth """
return self._date_of_birth
def fromJson(json): @staticmethod
return GeorideUser( def from_json(json):
json['id'], """return new object fromjson"""
json['email'], return GeorideUser(
json['firstName'], json['id'],
json['createdAt'], json['email'],
json['phoneNumber'], json['firstName'],
json['pushUserToken'], json['createdAt'],
json['legal'], json['phoneNumber'],
json['dateOfBirth'] json['pushUserToken'],
json['legal'],
json['dateOfBirth']
) )
if __name__ == '__main__':
print("Not a main module")