diff --git a/README.md b/README.md index 6e667ea..dc2deac 100644 --- a/README.md +++ b/README.md @@ -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. + +## Todo +- [ ] Add support of SocketIO connection +- [ ] Add support of "Get a shared trip" endpoint + + + diff --git a/examples/example.py b/examples/example.py index 7f45701..d5186f3 100644 --- a/examples/example.py +++ b/examples/example.py @@ -1,63 +1,72 @@ -import api as GeorideApi -from objects import GeorideAccount +""" Example georideapilib code """ + -import datetime import time +import datetime + +from georideapilib.objects import GeorideAccount +import georideapilib.api as GeorideApi + +def example(): + """ simple example function """ + token = ""# pylint: disable=C0301 + account = GeorideAccount(0, "", False, token) -""" If ypu out to reuse account """ -""" -account = GeorideAccount(, , , ) -""" + """ + GeorideApi.getAuthorisationToken("", "") + print("token 1: ", account.auth_token) + """ # pylint: disable=W0105 -""" Get an acces token """ -account = GeorideApi.getAuthorisationToken("", "") -print("token 1: ", account.authToken) + """ + account.auth_token = GeorideApi.renewToken(account.auth_token) + print("token 2: ", account.auth_token) + """ # pylint: disable=W0105 -""" do not abuse, renew when previous token have almost reached time """ -""" -account.authToken = GeorideApi.renewToken(account.authToken) -print("token 2: ", account.authToken) -""" + user = GeorideApi.get_user(account.auth_token) + print("User: ", user.first_name) -user = GeorideApi.getUser(account.authToken) -print("User: ", user.firstName) + trackers = GeorideApi.get_trackers(account.auth_token) + tracker = trackers[0] + print("Tracker name: ", tracker.tracker_name) -trackers = GeorideApi.getTrackers(account.authToken) -tracker = trackers[0] -print("Tracker name: ", tracker.trackerName) + 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') + print("Trip date: {}, from: {}, to: {}".format(trip_date, trip.nice_start_address, + trip.nice_end_address)) -trips = GeorideApi.getTrips(account.authToken, tracker.trackerId, "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') -print("Trip date: {}, from: {}, to: {}".format(trip_date, trip.niceStartAddress, trip.niceEndAddress)) + positions = GeorideApi.get_positions(account.auth_token, tracker.tracker_id, + "2019-10-10", "2019-10-24") + position = positions[0] + print("Position speed: {}, lon: {}, lat: {}".format(position.speed, position.longitude, + position.latitude)) -positions = GeorideApi.getPositions(account.authToken, tracker.trackerId, "2019-10-10", "2019-10-24") -position = positions[0]; -print("Position speed: {}, lon: {}, lat: {}".format(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") + print("tripShared url: {}, id: {}".format(trip_shared.url, trip_shared.share_id)) -tripShared = GeorideApi.shareATripByDate(account.authToken, tracker.trackerId, fromDate="2019-10-10", toDate="2019-10-24") -print("tripShared url: {}, id: {}".format(tripShared.url, tripShared.shareId)) + time.sleep(10) + have_been_locked = GeorideApi.lock_tracker(account.auth_token, tracker.tracker_id) + print("Tracker have been locked: ", have_been_locked) -time.sleep(30) -haveBeenLocked = GeorideApi.lockTracker(account.authToken, tracker.trackerId) -print("Tracker have been locked: ", haveBeenLocked) + time.sleep(10) + have_been_unlocked = GeorideApi.unlock_tracker(account.auth_token, tracker.tracker_id) + print("Tracker have been unlocked: ", have_been_unlocked) -time.sleep(30) -haveBeenUnlocked = GeorideApi.lockTracker(account.authToken, tracker.trackerId) -print("Tracker have been unlocked: ", haveBeenUnlocked) + time.sleep(10) + is_locked = GeorideApi.toogle_lock_tracker(account.auth_token, tracker.tracker_id) + print("Tracker is locked: ", is_locked) -time.sleep(30) -isLocked = GeorideApi.toogleLockTracker(account.authToken, tracker.trackerId) -print("Tracker is locked: ", haveBeenUnlocked) + time.sleep(10) + trackers = GeorideApi.get_trackers(account.auth_token) + tracker = trackers[0] + print("Tracker name: ", tracker.tracker_name, " is locked: ", tracker.is_locked) -time.sleep(30) -trackers = GeorideApi.getTrackers(account.authToken) -tracker = trackers[0] -print("Tracker name: ", tracker.trackerName, " is locked: ", tracker.isLocked) + """ + GeorideApi.revokeToken(account.auth_token) + """ # pylint: disable=W0105 -""" -GeorideApi.revokeToken(account.authToken) -""" \ No newline at end of file +example() \ No newline at end of file diff --git a/georideapilib/api.py b/georideapilib/api.py index cf04ebc..a72cad8 100644 --- a/georideapilib/api.py +++ b/georideapilib/api.py @@ -3,10 +3,17 @@ Georide api lib @author Matthieu DUVAL """ -import urllib3 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_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" -def getAuthorisationToken(email, password): +def get_authorisation_token(email, password): + """ return an authorization token """ http = urllib3.PoolManager() - data = {"email": email,"password": password} + data = {"email": email, "password": password} encoded_data = json.dumps(data).encode('utf-8') response = http.request( 'POST', @@ -32,11 +40,12 @@ def getAuthorisationToken(email, password): body=encoded_data, headers={'Content-Type': 'application/json'}) response_data = json.loads(response.data.decode('utf-8')) - account = GeorideAccount.fromJson(response_data) + account = GeorideAccount.from_json(response_data) return account -def renewToken(token): +def renew_token(token): + """ renew the authorization token """ http = urllib3.PoolManager() headers = {"Authorization": "Bearer " + token} response = http.request( @@ -44,24 +53,25 @@ def renewToken(token): GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_NEW_TOKEN, headers=headers) response_data = json.loads(response.data.decode('utf-8')) - newToken = response_data['authToken'] - return newToken + new_token = response_data['authToken'] + return new_token -def revokeToken(token): +def revoke_token(token): + """ invalidate the authorization token """ http = urllib3.PoolManager() headers = {"Authorization": "Bearer " + token} response = http.request( 'POST', GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOGOUT, headers=headers) - if response.status == 204: - return True - else: + if response.status != 204: return False + return True -def getUser(token): +def get_user(token): + """ get the georide user info """ http = urllib3.PoolManager() headers = {"Authorization": "Bearer " + token} response = http.request( @@ -69,10 +79,11 @@ def getUser(token): GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_USER, headers=headers) response_data = json.loads(response.data.decode('utf-8')) - account = GeorideUser.fromJson(response_data) + account = GeorideUser.from_json(response_data) return account -def getTrackers(token): +def get_trackers(token): + """ get user trackers """ http = urllib3.PoolManager() headers = {"Authorization": "Bearer " + token} response = http.request( @@ -83,57 +94,64 @@ def getTrackers(token): response_data = json.loads(response.data.decode('utf-8')) trackers = [] for json_tracker in response_data: - trackers.append(GeorideTracker.fromJson(json_tracker)) + trackers.append(GeorideTracker.from_json(json_tracker)) 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() headers = {"Authorization": "Bearer " + token} response = http.request( 'GET', - GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIPS.replace(':trackerId', str(trackerId)), - fields={'from': fromDate, 'to': toDate}, + GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIPS.replace(':trackerId', str(tracker_id)), + fields={'from': from_date, 'to': to_date}, headers=headers) response_data = json.loads(response.data.decode('utf-8')) trips = [] for json_trip in response_data: - trips.append(GeorideTrackerTrip.fromJson(json_trip)) + trips.append(GeorideTrackerTrip.from_json(json_trip)) 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() headers = {"Authorization": "Bearer " + token} response = http.request( 'GET', - GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_POSITIONS.replace(':trackerId', str(trackerId)), - fields={'from': fromDate, 'to': toDate}, + GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_POSITIONS.replace(':trackerId', str(tracker_id)), + fields={'from': from_date, 'to': to_date}, headers=headers) response_data = json.loads(response.data.decode('utf-8')) positions = [] for json_position in response_data: - positions.append(GeorideTrackerPosition.fromJson(json_position)) + positions.append(GeorideTrackerPosition.from_json(json_position)) return positions -def shareATripByTripId(token, trackerId, tripId): - return _shareATrip(token, trackerId, tripId=tripId) +def share_a_trip_by_trip_id(token, tracker_id, trip_id): + """ share trip by trip id """ + return _share_a_trip(token, tracker_id, trip_id=trip_id) -def shareATripByDate(token, trackerId, fromDate, toDate): - return _shareATrip(token, trackerId, fromDate=fromDate, toDate=toDate) +def share_a_trip_by_date(token, tracker_id, from_date, to_date): + """ 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): - return _shareATrip(token, trackerId, tripMergedId=tripMergedId) +def share_a_trip_by_trip_merge_id(token, tracker_id, trip_merged_id): + """ 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 - if tripId != None: - data = {"tripId": tripId} - elif fromDate != None and toDate != None: - data = {"from": fromDate, "to": toDate} - elif tripMergedId != None: - data = {"tripMergedId": tripMergedId} + if trip_id is not None: + data = {"tripId": trip_id} + elif from_date is not None and to_date is not None: + data = {"from": from_date, "to": to_date} + elif trip_merged_id is not None: + data = {"tripMergedId": trip_merged_id} encoded_data = json.dumps(data).encode('utf-8') print("Trip data: ", encoded_data) @@ -145,48 +163,48 @@ def _shareATrip(token, trackerId, tripId=None, fromDate=None, toDate=None, tripM } response = http.request( '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, headers=headers) response_data = json.loads(response.data.decode('utf-8')) 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() headers = {"Authorization": "Bearer " + token} response = http.request( '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) - if response.status == 204: - return True - else: + if response.status != 204: return False + return True -def unlockTracker(token, trackerId): +def unlock_tracker(token, tracker_id): + """ used to unlock a tracker """ http = urllib3.PoolManager() headers = {"Authorization": "Bearer " + token} response = http.request( '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) - if response.status == 204: - return True - else: + if response.status != 204: return False + return True -def toogleLockTracker(token, trackerId): +def toogle_lock_tracker(token, tracker_id): + """ used to toggle lock a tracker """ http = urllib3.PoolManager() headers = {"Authorization": "Bearer " + token} response = http.request( '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) response_data = json.loads(response.data.decode('utf-8')) return response_data['locked'] if __name__ == '__main__': print("Not a main module") - diff --git a/georideapilib/objects.py b/georideapilib/objects.py index 6b32f04..f4a26ec 100644 --- a/georideapilib/objects.py +++ b/georideapilib/objects.py @@ -4,501 +4,595 @@ Georide objects implementation """ class GeorideSharedTrip: - def __init__(self, url, shareId): - self._url = url - self._shareId = shareId - - @property - def url(self): - return self._url - - @property - def shareId(self): - return self._shareId - - def fromJson(json): - return GeorideSharedTrip( - json['url'], - json['shareId'] - ) - -class GeorideTrackerTrip: - def __init__(self, tripId, trackerId, averageSpeed, maxSpeed, distance, duration, startAddress, niceStartAddress, startLat, - startLon, endAddress, niceEndAddress, endLat, endLon, startTime, endTime): - self._tripId = tripId - self._trackerId = trackerId - self._averageSpeed = averageSpeed - self._maxSpeed = maxSpeed - self._distance = distance - self._duration = duration - self._startAddress = startAddress - self._niceStartAddress = niceStartAddress - self._startLat = startLat - self._startLon = startLon - self._endAddress = endAddress - self._niceEndAddress = niceEndAddress - self._endLat = endLat - self._endLon = endLon - self._startTime = startTime - self._endTime = endTime - - @property - def tripId(self): - return self._tripId - - @property - def trackerId(self): - return self._trackerId - - @property - def averageSpeed(self): - return self._averageSpeed - - @property - def maxSpeed(self): - return self._maxSpeed - - @property - def distance(self): - return self._distance - - @property - def duration(self): - return self._duration - - @property - def startAddress(self): - return self._startAddress - - @property - def niceStartAddress(self): - return self._niceStartAddress - - @property - def startLat(self): - return self._startLat - - @property - def startLon(self): - return self._startLon - - @property - def endAddress(self): - return self._endAddress - - @property - def niceEndAddress(self): - return self._niceEndAddress - - @property - def endLat(self): - return self._endLat - - @property - def endLon(self): - return self._endLon - - @property - def startTime(self): - return self._startTime - - @property - def endTime(self): - return self._endTime - - def fromJson(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'] - ) + """ 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'] + ) + +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'] + ) class GeorideTrackerPosition: - def __init__(self, fixtime, latitude, longitude, altitude, speed, address): - self._fixtime = fixtime - self._latitude = latitude - self._longitude = longitude - self._altitude = altitude - self._speed = speed - self._address = address - - @property - def fixtime(self): - return self._fixtime - - @property - def latitude(self): - return self._latitude - - @property - def longitude(self): - return self._longitude - - @property - def altitude(self): - return self._altitude - - @property - def speed(self): - return self._speed - - @property - def address(self): - return self._address - - def fromJson(json): - return GeorideTrackerPosition( - json['fixtime'], - json['latitude'], - json['longitude'], - json['altitude'], - json['speed'], - json['address'] - ) - - - - -class GeorideTracker: - def __init__(self, trackerId, trackerName, deviceButtonAction, deviceButtonDelay, vibrationLevel, isOldTracker, autoLockFreezedTo, - fixtime, role, lastPaymentDate, giftCardId, expires, activationDate, odometer, isStolen, isCrashed, crashDetectionDisabled, - speed, moving, positionId, latitude, longitude, altitude, lockedPositionId, lockedLatitude, lockedLongitude, isLocked, - canSeePosition, canLock, canUnlock, canShare, canUnshare, canCheckSpeed, canSeeStatistics, canSendBrokenDownSignal, - canSendStolenSignal, status): - self._trackerId = trackerId - self._trackerName = trackerName - self._deviceButtonAction = deviceButtonAction - self._deviceButtonDelay = deviceButtonDelay - self._vibrationLevel = vibrationLevel - self._isOldTracker = isOldTracker - self._autoLockFreezedTo = autoLockFreezedTo - self._fixtime = fixtime - self._role = role - self._lastPaymentDate = lastPaymentDate - self._giftCardId = giftCardId - self._expires = expires - self._activationDate = activationDate - self._odometer = odometer - self._isStolen = isStolen - self._isCrashed = isCrashed - self._crashDetectionDisabled = crashDetectionDisabled - self._speed = speed - self._moving = moving - self._positionId = positionId - self._latitude = latitude - self._longitude = longitude - self._altitude = altitude - self._lockedPositionId = lockedPositionId - self._lockedLatitude = lockedLatitude - self._lockedLongitude = lockedLongitude - self._isLocked = isLocked - self._canSeePosition = canSeePosition - self._canLock = canLock - self._canUnlock = canUnlock - self._canShare = canShare - self._canUnshare = canUnshare - self._canCheckSpeed = canCheckSpeed - self._canSeeStatistics = canSeeStatistics - self._canSendBrokenDownSignal = canSendBrokenDownSignal - self._canSendStolenSignal = canSendStolenSignal - self._status = status - - @property - def trackerId(self): - return self._trackerId - - @property - def trackerName(self): - return self._trackerName - - @property - def deviceButtonAction(self): - return self._deviceButtonAction - - @property - def deviceButtonDelay(self): - return self._deviceButtonDelay - - @property - def vibrationLevel(self): - return self._vibrationLevel - - @property - def isOldTracker(self): - return self._isOldTracker - - @property - def autoLockFreesedTo(self): - return self._autoLockFreesedTo - - @property - def fixtime(self): - return self._fixtime - - @property - def role(self): - return self._role - - @property - def lastPayementDate(self): - return self._lastPayementDate - - @property - def giftCardId(self): - return self._giftCardId - - @property - def expires(self): - return self._expires - - @property - def activationDate(self): - return self._activationDate - - @property - def odometer(self): - return self._odometer - - @property - def isStolen(self): - return self._isStolen - - @property - def isCrashed(self): - return self._isCrashed - - @property - def crashDetectionDisabled(self): - return self._crashDetectionDisabled - - @property - def speed(self): - return self._speed - - @property - def moving(self): - return self._moving - - @property - def positionId(self): - return self._positionId - - @property - def latitude(self): - return self._latitude - - @property - def longitude(self): - return self._longitude - - @property - def altitude(self): - return self._altitude - - @property - def lockedPositionId(self): - return self._lockedPositionId - - @property - def lockedLatitude(self): - return self._lockedLatitude - - @property - def lockedLongitude(self): - return self._lockedLongitude - - @property - def isLocked(self): - return self._isLocked - - @property - def canSeePosition(self): - return self._canSeePosition - - @property - def canLock(self): - return self._canLock - - @property - def canUnlock(self): - return self._canUnlock - - @property - def canShare(self): - return self._canShare - - @property - def canUnshare(self): - return self._canUnshare - - @property - def canCheckSpeed(self): - return self._canCheckSpeed - - @property - def canSeeStatistics(self): - return self._canSeeStatistics - - @property - def canSendBrokenDownSignal(self): - return self._canSendBrokenDownSignal - - @property - def canSendStolenSignal(self): - return self._canSendStolenSignal - - @property - def status(self): - return self._status - - def fromJson(json): - return GeorideTracker( - json['trackerId'], - json['trackerName'], - json['deviceButtonAction'], - json['deviceButtonDelay'], - json['vibrationLevel'], - json['isOldTracker'], - json['autoLockFreezedTo'], - json['fixtime'], - json['role'], - json['lastPaymentDate'], - json['giftCardId'], - json['expires'], - json['activationDate'], - json['odometer'], - json['isStolen'], - json['isCrashed'], - json['crashDetectionDisabled'], - json['speed'], - json['moving'], - json['positionId'], - json['latitude'], - json['longitude'], - json['altitude'], - json['lockedPositionId'], - json['lockedLatitude'], - json['lockedLongitude'], - json['isLocked'], - json['canSeePosition'], - json['canLock'], - json['canUnlock'], - json['canShare'], - json['canUnshare'], - json['canCheckSpeed'], - json['canSeeStatistics'], - json['canSendBrokenDownSignal'], - json['canSendStolenSignal'], - json['status'] - ) + """ 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'] + ) -class GeorideAccount: - def __init__(self, account_id, email, isAdmin, authToken): - self._account_id = account_id - self._email = email - self._isAdmin = isAdmin - self._authToken = authToken - - @property - def account_id(self): - return self._account_id - - @property - def email(self): - return self._email - - @property - def isAdmin(self): - return self._isAdmin - - @property - def authToken(self): - return self._authToken - - @authToken.setter - def authToken(self, newToken): - self._authToken = newToken - - def fromJson(json): - return GeorideAccount( - json['id'], - json['email'], - json['isAdmin'], - json['authToken'] - ) -class GeorideUser: - def __init__(self, account_id, email, firstName, createdAt, phoneNumberp, pushUserToken, legal, dateOfBirth): - self._account_id = account_id - self._email = email - self._firstName = firstName - self._createdAt = createdAt - self._phoneNumberp = phoneNumberp - self._pushUserToken = pushUserToken - self._legal = legal - self._dateOfBirth = dateOfBirth - - @property - def user_id(self): - return self._user_id - - @property - def email(self): - return self._email - - @property - def firstName(self): - return self._firstName - - @property - def createdAt(self): - return self._createdAt - - @property - def phoneNumber(self): - return self._phoneNumber - - @property - def pushUserToken(self): - return self._pushUserToken - - @property - def legal(self): - return self._legal - - @property - def dateOfBirth(self): - return self._dateOfBirth - - def fromJson(json): - return GeorideUser( - json['id'], - json['email'], - json['firstName'], - json['createdAt'], - json['phoneNumber'], - json['pushUserToken'], - json['legal'], - json['dateOfBirth'] +class GeorideTracker: # pylint: disable=R0904,R0902 + """ Tracker position object representation """ + def __init__(self, tracker_id, tracker_name, device_button_action, device_button_delay, # pylint: disable= R0913, R0914, R0915 + vibration_level, is_old_tracker, auto_lock_freezed_to, fixtime, role, + last_payment_date, gift_card_id, expires, activation_date, odometer, is_stolen, + is_crashed, crash_detection_disabled, speed, moving, position_id, latitude, + longitude, altitude, locked_position_id, locked_latitude, locked_longitude, + is_locked, can_see_position, can_lock, can_unlock, can_share, can_unshare, + can_check_speed, can_see_statistics, can_send_broken_down_signal, + can_send_stolen_signal, status): + self._tracker_id = tracker_id + self._tracker_name = tracker_name + self._device_button_action = device_button_action + self._device_button_delay = device_button_delay + self._vibration_level = vibration_level + self._is_old_tracker = is_old_tracker + self._auto_lock_freezed_to = auto_lock_freezed_to + self._fixtime = fixtime + self._role = role + self._last_payment_date = last_payment_date + self._gift_card_id = gift_card_id + self._expires = expires + self._activation_date = activation_date + self._odometer = odometer + self._is_stolen = is_stolen + self._is_crashed = is_crashed + self._crash_detection_disabled = crash_detection_disabled + self._speed = speed + self._moving = moving + self._position_id = position_id + self._latitude = latitude + self._longitude = longitude + self._altitude = altitude + self._locked_position_id = locked_position_id + self._locked_latitude = locked_latitude + self._locked_longitude = locked_longitude + self._is_locked = is_locked + self._can_see_position = can_see_position + self._can_lock = can_lock + self._can_unlock = can_unlock + self._can_share = can_share + self._can_unshare = can_unshare + 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 + def tracker_id(self): + """ tracker_id """ + return self._tracker_id + + @property + def tracker_name(self): + """ tracker_name """ + return self._tracker_name + + @property + def device_button_action(self): + """ device_button_action """ + return self._device_button_action + + @property + def device_button_delay(self): + """ device_button_delay """ + return self._device_button_delay + + @property + def vibration_level(self): + """ vibration_level """ + return self._vibration_level + + @property + def is_old_tracker(self): + """ is_old_tracker """ + return self._is_old_tracker + + @property + def auto_lock_freezed_to(self): + """ auto_lock_freezed_to """ + return self._auto_lock_freezed_to + + @property + def fixtime(self): + """ fixtime """ + return self._fixtime + + @property + def role(self): + """ role """ + return self._role + + @property + def last_payment_date(self): + """ last_payment_date """ + return self._last_payment_date + + @property + def gift_card_id(self): + """ gift_card_id """ + return self._gift_card_id + + @property + def expires(self): + """ expires """ + return self._expires + + @property + def activation_date(self): + """ activation_date """ + return self._activation_date + + @property + def odometer(self): + """ odometer """ + return self._odometer + + @property + def is_stolen(self): + """ is_stolen """ + return self._is_stolen + + @property + def is_crashed(self): + """ is_crashed """ + return self._is_crashed + + @property + def crash_detection_disabled(self): + """ crash_detection_disabled """ + return self._crash_detection_disabled + + @property + def speed(self): + """ speed """ + return self._speed + + @property + def moving(self): + """ moving """ + return self._moving + + @property + def position_id(self): + """ position_id """ + return self._position_id + + @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 locked_position_id(self): + """ locked_position_id """ + return self._locked_position_id + + @property + def locked_latitude(self): + """ locked_latitude """ + return self._locked_latitude + + @property + def locked_longitude(self): + """ locked_longitude """ + return self._locked_longitude + + @property + def is_locked(self): + """ is_locked """ + return self._is_locked + + @property + def can_see_position(self): + """ can_see_position """ + return self._can_see_position + + @property + def can_lock(self): + """ can_lock """ + return self._can_lock + + @property + def can_unlock(self): + """ can_unlock """ + return self._can_unlock + + @property + def can_share(self): + """ can_share """ + return self._can_share + + @property + def can_unshare(self): + """ can_unshare """ + return self._can_unshare + + @property + def can_check_speed(self): + """ can_check_speed """ + return self._can_check_speed + + @property + def can_see_statistics(self): + """ can_see_statistics """ + return self._can_see_statistics + + @property + def can_send_broken_down_signal(self): + """ can_send_broken_down_signal """ + return self._can_send_broken_down_signal + + @property + def can_send_stolen_signal(self): + """ can_send_stolen_signal """ + return self._can_send_stolen_signal + + @property + def status(self): + """ status """ + return self._status + + @staticmethod + def from_json(json): + """return new object fromjson""" + return GeorideTracker( + json['trackerId'], + json['trackerName'], + json['deviceButtonAction'], + json['deviceButtonDelay'], + json['vibrationLevel'], + json['isOldTracker'], + json['autoLockFreezedTo'], + json['fixtime'], + json['role'], + json['lastPaymentDate'], + json['giftCardId'], + json['expires'], + json['activationDate'], + json['odometer'], + json['isStolen'], + json['isCrashed'], + json['crashDetectionDisabled'], + json['speed'], + json['moving'], + json['positionId'], + json['latitude'], + json['longitude'], + json['altitude'], + json['lockedPositionId'], + json['lockedLatitude'], + json['lockedLongitude'], + json['isLocked'], + json['canSeePosition'], + json['canLock'], + json['canUnlock'], + json['canShare'], + json['canUnshare'], + json['canCheckSpeed'], + json['canSeeStatistics'], + json['canSendBrokenDownSignal'], + json['canSendStolenSignal'], + json['status'] ) +class GeorideAccount: + """ Account object representation """ + def __init__(self, account_id, email, is_admin, auth_token): + self._account_id = account_id + self._email = email + 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'] + ) -if __name__ == '__main__': - print("Not a main module") \ No newline at end of file + +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'] + )