def register(self, **kwargs):
"""
Register Action
:param kwargs:
:return: API response content
"""
if self.check_required_params(kwargs, [
"industry", "first_name", "last_name", "email_address",
"check_terms", "device_type", "plan", "password_1",
"password_2", "format"
]):
params = {'plan': kwargs.pop('plan')}
kwargs['strIndustry'] = kwargs.pop('industry')
kwargs['strFirstName'] = kwargs.pop('first_name')
kwargs['strLastName'] = kwargs.pop('last_name')
kwargs['strEmail'] = kwargs.pop('email_address')
kwargs['chkTerms'] = kwargs.pop('check_terms')
kwargs['device_type'] = kwargs.pop('device_type')
kwargs['strPassword_1'] = kwargs.pop('password_1')
kwargs['strPassword_2'] = kwargs.pop('password_2')
response = self.api._request_post(REGISTER_ACTION,
params,
data=kwargs)
try:
return response.json()
except ValueError:
return response.content
else:
raise ParamValueException('order', 'Missing required params')
def algorithm_type(self, algorithm_type):
"""
Set algorithm_type. Choices are:
TSP, VRP, CVRP_TW_SD
CVRP_TW_MD, TSP_TW,
TSP_TW_CR and BBCVRP
:param: algorithm_type:
:return:
"""
VALID = [
1,
2,
3,
4,
5,
6,
7,
100,
101,
]
if algorithm_type in VALID:
self._copy_data({'algorithm_type': algorithm_type})
else:
raise ParamValueException(
'algorithm_type', 'Must be ALGORITHM_TYPE: '
'TSP(1), VRP(2), CVRP_TW_SD(3), '
'CVRP_TW_MD(4), TSP_TW(5), '
'TSP_TW_CR(6), BBCVRP(7), '
'NO OPTIMIZATION(100) or '
'LEGACY_DISTRIBUTED(101)')
def app_purchase_user_license(self, **kwargs):
"""
Application purchase user License
:param kwargs:
:return: API response content
"""
if self.check_required_params(kwargs, [
'member_id',
'session_guid',
'device_id',
'device_type',
'subscription_name',
'token',
'payload',
'format',
]):
data = json.dumps(kwargs, ensure_ascii=False)
response = self.api._request_post(USER_LICENSE_HOST,
self.params,
data=data)
try:
return json.loads(response.content)
except ValueError:
return response.content
else:
raise ParamValueException('order', 'Missing required params')
def get_street_data_service(self, **kwargs):
"""
Get Street Data Given Zipcode and House Number
:param kwargs:
:return: API response content
"""
kwargs.update({'api_key': self.params['api_key'], })
url = RAPID_ADDRESS_SERVICE
if self.check_required_params(kwargs, ['zipcode',
'api_key',
'housenumber', ]):
url = '{0}{1}/{2}/'.format(url,
kwargs.pop('zipcode'),
kwargs.pop('housenumber'))
if 'offset' in kwargs.keys() and 'limit' in kwargs.keys():
url = '{0}{1}/{2}/'.format(url,
kwargs.pop('offset'),
kwargs.pop('limit'))
response = self.api._request_get(url, kwargs)
try:
return json.loads(response.content)
except ValueError:
return response.content
else:
raise ParamValueException('params', 'Params are not complete')
def tx_id(self, tx_id):
"""
Set tx_id param
:param tx_id:
:return:
"""
if check_string_type(tx_id):
self._copy_param({'tx_id': tx_id})
else:
raise ParamValueException('tx_id', 'Must be String')
def has_trailer(self, has_trailer):
"""
Set has_trailer param.
:param has_trailer:
:return:
"""
if 0 <= has_trailer <= 1:
self._copy_data({'has_trailer': has_trailer})
else:
raise ParamValueException('has_trailer', 'Must be 0 or 1')
def share_route(self, share_route):
"""
Set share_route param
:param share_route:
:return:
"""
if 0 <= share_route <= 1:
self._copy_data({'share_route': share_route})
else:
raise ParamValueException('share_route', 'Must be 0 or 1')
def shared_publicly(self, shared_publicly):
"""
Set shared_publicly param
:param shared_publicly:
:return:
"""
if 0 <= shared_publicly <= 1:
self._copy_data({'shared_publicly': shared_publicly})
else:
raise ParamValueException('shared_publicly', 'Must be 0 or 1')
def lock_last(self, lock_last):
"""
Set lock_last param
:param lock_last:
:return:
"""
if 0 <= lock_last <= 1:
self._copy_data({'lock_last': lock_last})
else:
raise ParamValueException('lock_last', 'Must be 0 or 1')
def max_tour_size(self, max_tour_size):
"""
Set max_tour_size
:param max_tour_size:
:return:
"""
if isinstance(max_tour_size, int):
self._copy_data({'max_tour_size': max_tour_size})
else:
raise ParamValueException('max_tour_size', 'Must be integer')
def route_name(self, route_name):
"""
Set route_name param
:param route_name:
:return:
"""
if check_string_type(route_name):
self._copy_data({'route_name': route_name})
else:
raise ParamValueException('route_name', 'Must be String')
def app_version(self, app_version):
"""
Set app_version param
:param app_version:
:return:
"""
if check_string_type(app_version):
self._copy_param({'app_version': app_version})
else:
raise ParamValueException('app_version', 'Must be String')
def device_guid(self, device_guid):
"""
Set device_guid param
:param device_guid:
:return:
"""
if check_string_type(device_guid):
self._copy_param({'device_guid': device_guid})
else:
raise ParamValueException('device_guid', 'Must be String')
def altitude(self, altitude):
"""
Set altitude param
:param altitude:
:return:
"""
if isinstance(altitude, float):
self._copy_param({'altitude': altitude})
else:
raise ParamValueException('altitude', 'Must be Float')
def cached_lng(self, lng):
"""
Set lng param
:param lng:
:return:
"""
if isinstance(lng, float):
self._copy_param({'lng': lng})
else:
raise ParamValueException('lng', 'Must be Float')
def limit(self, limit):
"""
Set limit param
:param limit:
:return:
"""
if isinstance(limit, int):
self._copy_param({'limit': limit})
else:
raise ParamValueException('limit', 'Must be integer')
def offset(self, offset):
"""
Set offset param
:param offset:
:return:
"""
if isinstance(offset, int):
self._copy_param({'offset': offset})
else:
raise ParamValueException('offset', 'Must be integer')
def remote_ip(self, remote_ip):
"""
Set remote_ip param
:param remote_ip:
:return:
"""
if isinstance(remote_ip, int):
self._copy_data({'remote_ip': remote_ip})
else:
raise ParamValueException('remote_ip', 'Must be integer')
def route_email(self, route_email):
"""
Set route_email param
:param route_email:
:return:
"""
if check_string_type(route_email):
self._copy_data({'route_email': route_email})
else:
raise ParamValueException('route_email', 'Must be String')
def distance_unit(self, distance_unit):
"""
Set distance_unit param
:param distance_unit:
:return:
"""
if distance_unit in DISTANCE_UNIT.reverse_mapping.keys():
self._copy_data({'distance_unit': distance_unit})
else:
raise ParamValueException('distance_unit', 'Must be MI or KM')
def disable_optimization(self, disable_optimization):
"""
Set disable_optimization param
:param disable_optimization:
:return:
"""
if 0 <= disable_optimization <= 1:
self._copy_data({'disable_optimization': disable_optimization})
else:
raise ParamValueException('disable_optimization', 'Must be 0 or 1')
def trailer_weight_t(self, trailer_weight_t):
"""
Set trailer_weight_t param
:param trailer_weight_t:
:return:
"""
if isinstance(trailer_weight_t, int):
self._copy_data({'trailer_weight_t': trailer_weight_t})
else:
raise ParamValueException('trailer_weight_t', 'Must be integer')
def reoptimize(self, reoptimize):
"""
Set reoptimize param
:param reoptimize:
:return:
"""
if 0 <= reoptimize <= 1:
self._copy_param({'reoptimize': reoptimize})
else:
raise ParamValueException('reoptimize', 'Must be 0 or 1')
def route_date(self, route_date):
"""
Set route_date param
:param route_date:
:return:
"""
if isinstance(route_date, int):
self._copy_data({'route_date': route_date})
else:
raise ParamValueException('route_date', 'Must be integer')
def rt(self, rt):
"""
Set rt param.
:param rt:
:return:
"""
if 0 <= rt <= 1:
self._copy_data({'rt': rt})
else:
raise ParamValueException('rt', 'Must be 0 or 1')
def route_max_duration(self, route_max_duration):
"""
Set route_max_duration param
:param route_max_duration:
:return:
"""
if isinstance(route_max_duration, int):
self._copy_data({'route_max_duration': route_max_duration})
else:
raise ParamValueException('route_max_duration', 'Must be integer')
def directions(self, directions):
"""
Set directions param.
:param directions:
:return:
"""
if 0 <= directions <= 1:
self._copy_param({'directions': directions})
else:
raise ParamValueException('directions', 'Must be 0 or 1')
def vehicle_capacity(self, vehicle_capacity):
"""
Set vehicle_capacity param
:param vehicle_capacity:
:return:
"""
if isinstance(vehicle_capacity, int):
self._copy_data({'vehicle_capacity': vehicle_capacity})
else:
raise ParamValueException('vehicle_capacity', 'Must be integer')
def vehicle_id(self, vehicle_id):
"""
Set vehicle_id param
:param vehicle_id:
:return:
"""
if isinstance(vehicle_id, int):
self._copy_data({'vehicle_id': vehicle_id})
else:
raise ParamValueException('vehicle_id', 'Must be integer')
def parts(self, parts):
"""
Set parts param
:param parts:
:return:
"""
if isinstance(parts, int):
self._copy_data({'parts': parts})
else:
raise ParamValueException('parts', 'Must be integer')
