def create_client(self, client_name, client_secret):
if not self.admin_token:
raise Exception("Must authenticate as admin")
else:
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/json',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + self.admin_token
}
data = {
"client_id":
client_name,
"client_secret":
client_secret,
"scope": ["uaa.none", "openid"],
"authorized_grant_types": [
"authorization_code", "client_credentials",
"refresh_token", "password"
],
"authorities": ["openid", "uaa.none", "uaa.resource"],
"autoapprove": ["openid"]
}
r = requests.post(self.url + '/oauth/clients',
proxies=get_proxy(),
headers=headers,
data=data)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def text_query(self, name, text):
temp_url = self.url + '/collections/' + name + '/text-query/free/' + text
r = requests.delete(temp_url,
proxies=get_proxy(),
headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def search_location(self, location_type=None, bbox=None, page=None, size=None):
params = {}
if location_type is not None:
if type(location_type).__name__ == 'str':
if location_type not in ['PARKING_SPOT','PARKING_ZONE','CROSSWALK','TRAFFIC_LANE',
'RETAIL_STORE', 'PARKING_SPOT,PARKING_ZONE']:
raise Exception('Invalid location type for parking')
else:
params['q'] = 'location_-type:' + location_type
elif type(location_type).__name__ in ['list', 'tuple']:
if any(location_type) not in ['PARKING_SPOT','PARKING_ZONE','CROSSWALK','TRAFFIC_LANE',
'RETAIL_STORE', 'PARKING_SPOT,PARKING_ZONE']:
raise Exception('Invalid location type for parking')
else:
params['q'] = 'location_-type:' + ';'.join(location_type)
if bbox is not None and type(bbox).__name__ in ['tuple', 'list'] and len(bbox) == 4:
params['bbox'] = str(bbox[0])+':'+str(bbox[1])+','+str(bbox[2])+':'+str(bbox[3])
if page is not None and type(page).__name__ in ['int', 'float', 'long', 'complex']:
params['page'] = int(page)
if size is not None and type(size).__name__ in ['int', 'float', 'long', 'complex']:
params['size'] = int(size)
r = requests.get(self.url + '/locations/search', proxies=get_proxy(), headers=self.headers,
params=params)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def search_assets(self, q_type=None, q_value=None, bbox=None, page=None, size=None):
params = {}
if q_type is not None and q_value is not None:
if q_type not in ['device-type', 'media-type', 'event-type']:
raise Exception('invalid q type')
elif q_type == 'device-type':
if type(q_value) in ['list', 'tuple']:
if any(q_value) not in ['NODE', 'CAMERA', 'MIC', 'ENV']:
raise Exception('Invalid q value for device_type')
else:
params['q'] = 'device-type:' + ';'.join(q_value)
elif type(q_value).__name__ != 'str':
raise Exception('Invalid type for q value')
elif q_value not in ['NODE', 'CAMERA', 'MIC', 'ENV']:
raise Exception('Invalid q value for device-type')
else:
params['q'] = 'device-type:' + q_value
elif q_type == 'media-type':
if type(q_value) in ['list', 'tuple']:
if any(q_value) not in ['IMAGE', 'VIDEO', 'AUDIO']:
raise Exception('Invalid q value for media_type')
else:
params['q'] = 'media-type:' + ';'.join(q_value)
elif type(q_value).__name__ != 'str':
raise Exception('Invalid type for q value')
elif q_value not in ['IMAGE', 'VIDEO', 'AUDIO']:
raise Exception('Invalid q value for media-type')
else:
params['q'] = 'media-type:' + q_value
elif q_type == 'event-type':
if type(q_value) in ['list', 'tuple']:
if any(q_value) not in ['PKIN', 'PKOUT', 'SFIN', 'SFOUT', 'TFEVT', 'ENCGH'
'TEMP', 'OCCUPANCY', 'LIGHT_LEVEL']:
raise Exception('Invalid q value for event_type')
else:
params['q'] = 'event-type:' + ';'.join(q_value)
elif type(q_value).__name__ != 'str':
raise Exception('Invalid type for q value')
elif q_value not in ['PKIN', 'PKOUT', 'SFIN', 'SFOUT', 'TFEVT', 'ENCGH'
'TEMP', 'OCCUPANCY', 'LIGHT_LEVEL']:
raise Exception('Invalid q value for event-type')
else:
params['q'] = 'event-type:' + q_value
if bbox is not None and type(bbox).__name__ in ['tuple', 'list'] and len(bbox) == 4:
params['bbox'] = str(bbox[0])+':'+str(bbox[1])+','+str(bbox[2])+':'+str(bbox[3])
if page is not None and type(page).__name__ in ['int', 'float', 'long', 'complex']:
params['page'] = int(page)
if size is not None and type(size).__name__ in ['int', 'float', 'long', 'complex']:
params['size'] = int(size)
r = requests.get(self.url + '/assets/search', proxies=get_proxy(), headers=self.headers, params=params)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def reverse_get_all(self, request_data):
url = 'https://api.pitneybowes.com/location-intelligence/geocode-service/v1/transient/premium/reverseGeocode'
r = requests.post(url,
proxies=get_proxy(),
headers=self.headers,
data=request_data)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def spatial_query(self, name, x1, y1, x2, y2):
temp_url = self.url + '/collections/' + name + '/spatial-query/bbox-interacts/{0},{1},{2},{3}'.format(
x1, y1, x2, y2)
r = requests.delete(temp_url,
proxies=get_proxy(),
headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def authenticate_user(self, short_token, username, password):
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/x-www-form-urlencoded',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + short_token
}
data = 'username='******'&password='******'&grant_type=password'
r = requests.post(self.url + '/oauth/token',
proxies=get_proxy(),
headers=headers,
data=data)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))['access_token']
def authenticate_client(self, short_token, client):
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/x-www-form-urlencoded',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + short_token
}
data = 'client_id=' + client + '&grant_type=client_credentials'
r = requests.post(self.url + '/oauth/token',
proxies=get_proxy(),
headers=headers,
data=data)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))['access_token']
def add_to_group(self, username, group_name):
if not self.admin_token:
raise Exception("Must authenticate as admin")
else:
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/json',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + self.admin_token
}
data = {'displayName': group_name, 'userName': username}
r = requests.put(self.url + '/Groups',
proxies=get_proxy(),
headers=headers)
r.raise_for_status()
def get_group(self, group_name):
if not self.admin_token:
raise Exception("Must authenticate as admin")
else:
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/json',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + self.admin_token
}
r = requests.get(self.url + '/Groups?filter=displayName+eq+%22' +
group_name + '%22&startIndex=1',
proxies=get_proxy(),
headers=headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def __init__(self, api_key, secret):
base64_key = base64.b64encode(api_key + ":" + secret)
temp_headers = {
'Authorization': 'Basic ' + base64_key,
'Content-Type': 'application/x-www-form-urlencoded'
}
data = 'grant_type=client_credentials'
r = requests.get('https://api.pitneybowes.com/oauth/token',
proxies=get_proxy(),
headers=temp_headers)
r.raise_for_status()
access_token = yaml.safe_load(json.dumps(r.json()))['access_token']
self.headers = {
'Accept': 'application/json',
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + access_token
}
def get_live_events(self, asset_id, event_types, size):
params = {}
if type(event_types) in ['list', 'tuple']:
for event_type in event_types:
if event_type not in ['PKIN', 'PKOUT', 'SFIN', 'SFOUT', 'TFEVT', 'ENCGH',
'TEMP', 'OCCUPANCY', 'LIGHT_LEVEL']:
raise Exception('Invalid Event Type')
params['event-types'] = ','.join(event_types)
if size is not None and type(size).__name__ in ['int', 'float', 'long', 'complex']:
params['size'] = int(size)
r = requests.get(self.url + '/assets/' + asset_id + '/live-events', proxies=get_proxy(),
headers=self.headers, params=params)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def authenticate_admin(self, short_token):
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/x-www-form-urlencoded',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + short_token,
'Connection': 'keep-alive'
}
data = "grant_type=client_credentials"
r = requests.post(self.url + '/oauth/token',
proxies=get_proxy(),
headers=headers,
data=data)
r.raise_for_status()
self.admin_token = r.json()['access_token']
return self.admin_token
def create_group(self, group_name):
if not self.admin_token:
raise Exception("Must authenticate as admin")
else:
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/json',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + self.admin_token
}
data = {"displayName": group_name}
r = requests.post(self.url + '/Groups',
proxies=get_proxy(),
headers=headers,
data=data)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def get_media(self, asset_id, media_types, start, end, location_id=None, page=None, size=None):
params = {}
if type(media_types) in ['list', 'tuple']:
for media_type in media_types:
if media_type not in ['IMAGE', 'VIDEO', 'AUDIO']:
raise Exception('Invalid media Type')
params['media-types'] = ','.join(media_types)
params['start-ts'] = start
params['end-ts'] = end
if location_id is not None and type(location_id).__name__ == 'str':
params['locationId'] = location_id
if page is not None and type(page).__name__ in ['int', 'float', 'long', 'complex']:
params['page'] = int(page)
if size is not None and type(size).__name__ in ['int', 'float', 'long', 'complex']:
params['size'] = int(size)
r = requests.get(self.url + '/assets/' + asset_id + '/media', proxies=get_proxy(),
headers=self.headers, params=params)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def get(self,
place_name=None,
main_address=None,
last_line=None,
area_name_1=None,
area_name_2=None,
area_name_3=None,
area_name_4=None,
postal_code=None,
country=None):
if self.premium:
url = 'https://api.pitneybowes.com/location-intelligence/geocode-service/v1/transient/premium/geocode'
else:
url = 'https://api.pitneybowes.com/location-intelligence/geocode-service/v1/transient/basic/geocode'
params = []
if place_name:
params.append('placeName=' + place_name)
if main_address:
params.append('mainAddress=' + main_address)
if last_line:
params.append('lastLine=' + last_line)
if area_name_1:
params.append('areaName1=' + area_name_1)
if area_name_2:
params.append('areaName1=' + area_name_2)
if area_name_3:
params.append('areaName1=' + area_name_3)
if area_name_4:
params.append('areaName1=' + area_name_4)
if postal_code:
params.append('postalCode=' + postal_code)
if country:
params.append('country=' + country)
url += '&'.join(params)
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def create_user(self, username, password, email):
if not self.admin_token:
raise Exception("Must authenticate as admin")
else:
headers = {
'Pragma': 'no-cache',
'Content-Type': 'application/json',
'Accept': 'application/json',
'Cache-Control': 'no-cache',
'Authorization': 'Basic ' + self.admin_token
}
data = {
"userName": username,
"password": password,
"emails": [{
"value": email
}]
}
r = requests.post(self.url + '/Users',
proxies=get_proxy(),
headers=headers,
data=data)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def update_policy_set(self, policy_set_id, policy_set):
r = requests.put(self.url + '/policy-set/' + policy_set_id,
proxies=get_proxy(),
headers=self.headers,
data=policy_set)
r.raise_for_status()
def demographics_by_location(self, lat, lon):
url = 'http://api.pitneybowes.com/location-intelligence/geolife/v1/demographics/bylocation?' + \
'latitude=' + lat + '&longitude=' + lon
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def demographics_by_address(self, address):
url = 'https://api.pitneybowes.com/location-intelligence/geolife/v1/demographics/byaddress?address=1 ' + address
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def psap_by_address(self, address):
url = 'https://api.pitneybowes.com/location-intelligence/geo911/v1/psap/byaddress?address=1 ' + address
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def geo_search(self, lat, lon, search_text='Global'):
url = 'https://api.pitneybowes.com/location-intelligence/geosearch/v1/locations?searchText=1%20' + \
search_text + '%20V&longitude=' + lon + '&latitude=' + lat
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def timezone_by_location(self, lat, lon):
url = self.base_url + '/timezone/bylocation?' + 'latitude=' + lat + '&longitude=' + lon
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def taxrate_by_address(self, address, tax_rate_type='Auto'):
url = 'http://api.pitneybowes.com/location-intelligence/geotax/v1/taxrate/' + tax_rate_type + \
'/byaddress?address=' + address
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def taxrate_by_location(self, lat, lon, tax_rate_type='Auto'):
url = 'http://api.pitneybowes.com/location-intelligence/geotax/v1/taxrate/' + tax_rate_type + \
'/bylocation?latitude=' + lat + '&longitude=' + lon
r = requests.get(url, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def get_location(self, location_id):
r = requests.get(self.url + '/locations/' + location_id, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def get_location_analytics(self, location_id, analytic_names, analytic_categories, start, end):
params = {}
if type(analytic_names).__name__ in ['list', 'tuple']:
params['analytic-names'] = ';'.join(analytic_names)
elif type(analytic_names).__name__ =='str':
params['analytic-names'] = analytic_names
if type(analytic_categories).__name__ in ['list', 'tuple']:
params['analytic-categories'] = ';'.join(analytic_categories)
elif type(analytic_categories).__name__ =='str':
params['analytic-categories'] = analytic_categories
params['start-ts'] = start
params['end-ts'] = end
r = requests.get(self.url + '/locations/' + location_id + '/analytics', proxies=get_proxy(),
headers=self.headers, params=params)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def get_collections(self):
r = requests.get(self.url + '/collections',
proxies=get_proxy(),
headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def get_asset(self, asset_id):
r = requests.get(self.url + '/assets/' + asset_id, proxies=get_proxy(), headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
def delete(self, name):
r = requests.delete(self.url + '/collections/' + name,
proxies=get_proxy(),
headers=self.headers)
r.raise_for_status()
return yaml.safe_load(json.dumps(r.json()))
