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")

1012
georideapilib/objects.py
View File

File diff suppressed because it is too large Load Diff