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

Refactor after enabling pylint

Browse Source
master
Matthieu DUVAL 5 years ago
parent cd5adffbd0
commit c30180221f
4 changed files with 712 additions and 584 deletions
Show Stats Download Patch File Download Diff File

7
README.md
Unescape 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
Unescape 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
def example():
""" simple example function """
token = "<your_token>"# pylint: disable=C0301
account = GeorideAccount(0, "<your_email>", False, token)
""" If ypu out to reuse account """ """
""" GeorideApi.getAuthorisationToken("<your_email>", "<your_password>")
account = GeorideAccount(<your_id>, <yout_email>, <is_admin>, <your_token>) print("token 1: ", account.auth_token)
""" """ # pylint: disable=W0105
""" Get an acces token """
account = GeorideApi.getAuthorisationToken("<your_email>", "<your_passord>")
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 """ user = GeorideApi.get_user(account.auth_token)
""" print("User: ", user.first_name)
account.authToken = GeorideApi.renewToken(account.authToken)
print("token 2: ", account.authToken)
"""
user = GeorideApi.getUser(account.authToken) trackers = GeorideApi.get_trackers(account.auth_token)
print("User: ", user.firstName) tracker = trackers[0]
print("Tracker name: ", tracker.tracker_name)
trackers = GeorideApi.getTrackers(account.authToken) trips = GeorideApi.get_trips(account.auth_token, tracker.tracker_id, "2019-10-10", "2019-10-24")
tracker = trackers[0] trip = trips[0]
print("Tracker name: ", tracker.trackerName) 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") positions = GeorideApi.get_positions(account.auth_token, tracker.tracker_id,
trip = trips[0]; "2019-10-10", "2019-10-24")
trip_date = datetime.datetime.strptime("2019-10-10T06:45:34.000Z", '%Y-%m-%dT%H:%M:%S.%fZ') position = positions[0]
print("Trip date: {}, from: {}, to: {}".format(trip_date, trip.niceStartAddress, trip.niceEndAddress)) 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") time.sleep(10)
print("tripShared url: {}, id: {}".format(tripShared.url, tripShared.shareId)) have_been_locked = GeorideApi.lock_tracker(account.auth_token, tracker.tracker_id)
print("Tracker have been locked: ", have_been_locked)
time.sleep(30) time.sleep(10)
haveBeenLocked = GeorideApi.lockTracker(account.authToken, tracker.trackerId) have_been_unlocked = GeorideApi.unlock_tracker(account.auth_token, tracker.tracker_id)
print("Tracker have been locked: ", haveBeenLocked) print("Tracker have been unlocked: ", have_been_unlocked)
time.sleep(30) time.sleep(10)
haveBeenUnlocked = GeorideApi.lockTracker(account.authToken, tracker.trackerId) is_locked = GeorideApi.toogle_lock_tracker(account.auth_token, tracker.tracker_id)
print("Tracker have been unlocked: ", haveBeenUnlocked) print("Tracker is locked: ", is_locked)
time.sleep(30) time.sleep(10)
isLocked = GeorideApi.toogleLockTracker(account.authToken, tracker.trackerId) trackers = GeorideApi.get_trackers(account.auth_token)
print("Tracker is locked: ", haveBeenUnlocked) tracker = trackers[0]
print("Tracker name: ", tracker.tracker_name, " is locked: ", tracker.is_locked)
time.sleep(30) """
trackers = GeorideApi.getTrackers(account.authToken) GeorideApi.revokeToken(account.auth_token)
tracker = trackers[0] """ # pylint: disable=W0105
print("Tracker name: ", tracker.trackerName, " is locked: ", tracker.isLocked)
""" example()
GeorideApi.revokeToken(account.authToken)
"""

122
georideapilib/api.py
Unescape 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")

1068
georideapilib/objects.py
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save