Route.export_route() - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/route4..." - route4me/route4me-python-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( e3a209...bb2a36 )

by Juan Jose

created 2017-03-02 05:37 UTC

Route.export_route() A

↳ Parent: Route

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0

# codebeat:disable[TOO_MANY_FUNCTIONS]
import json

from route4me.base import Base
from route4me.exceptions import ParamValueException
from route4me.utils import json2obj
from route4me.api_endpoints import ROUTE_HOST, EXPORTER, \
    ADDRESS_HOST, GET_ACTIVITIES_HOST, DUPLICATE_ROUTE, SHARE_ROUTE_HOST, \
    MERGE_ROUTES_HOST, RESEQUENCE_ROUTE


class Route(Base):
    """
    A Route is a multi-sequence of addresses that need to be
    visited by a single vehicle and a single driver in a fixed time period.
    """
    requirements = [
        'api_key',
        'route_id',
    ]

    def __init__(self, api):
        """
        Routes
        :param api: route4me instance
        :return: route instance
        """
        self.response = None
        self.params = {'api_key': api.key, }
        Base.__init__(self, api)

    def get_route(self, **kwargs):
        """
        Get route using GET request
        :return: API response
        :raise: ParamValueException if required params are not present.
        """
        if self.validate_params(**kwargs):
            self.params.update(kwargs)
        if self.check_required_params(self.params, self.requirements):
            self.response = self.api._request_get(ROUTE_HOST,
                                                  self.params)
            response = self.response.json()
            return response

        else:
            raise ParamValueException('params', 'Params are not complete')

    def get_route_tracking(self, **kwargs):
        """
        Get route using GET request
        :return: API response
        :raise: ParamValueException if required params are not present.
        """
        if self.validate_params(**kwargs):
            self.params.update(kwargs)
        self.params.update({'device_tracking_history': 1})
        if self.check_required_params(self.params, self.requirements):
            self.response = self.api._request_get(ROUTE_HOST,
                                                  self.params)
            response = self.response.json()
            return response

        else:
            raise ParamValueException('params', 'Params are not complete')

    def get_routes(self, **kwargs):
        """
        Get routes using GET request
        :return: API response
        :raise: ParamValueException if required params are not present.

        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['limit', 'Offset', ]):
            self.response = self.api._request_get(ROUTE_HOST,
                                                  kwargs)
            response = self.response.json()
            return response
        else:
            raise ParamValueException('params', 'Params are not complete')

    def get_activities(self, **kwargs):
        """
        Get routes activities using GET request
        :return: API response
        :raise: ParamValueException if required params are not present.

        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['route_id', 'limit', 'Offset', ]):
            self.response = self.api._request_get(GET_ACTIVITIES_HOST,
                                                  kwargs)
            response = json2obj(self.response.content)
            return response
        else:
            raise ParamValueException('params', 'Params are not complete')

    def duplicate_route(self, **kwargs):
        """
        Duplicate route using GET request
        :return: API response
        :raise: ParamValueException if required params are not present.
        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['route_id', ]):
            self.response = self.api._request_get(DUPLICATE_ROUTE,
                                                  kwargs)
            response = self.response.json()
            return response
        else:
            raise ParamValueException('params', 'Params are not complete')

    def delete_routes(self, **kwargs):
        """
        Delete routes using DELETE request
        :return: API response
        :raise: ParamValueException if required params are not present.
        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['route_id', ]):
            kwargs['route_id'] = ','.join(kwargs['route_id'])
            self.response = self.api._request_delete(ROUTE_HOST,
                                                     kwargs)
            response = self.response.json()
            return response
        else:
            raise ParamValueException('params', 'Params are not complete')

    def delete_route(self, **kwargs):
        """
        Delete given route
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['route_id', ]):
            self.response = self.api._request_delete(ROUTE_HOST, kwargs)
            response = self.response.json()
            try:
                response = response.get('deleted')
                return response
            except AttributeError:
                return response.errors
        else:
            raise ParamValueException('params', 'Params are not complete')

    def insert_address_into_route(self, addresses, route_id):
        params = {'route_id': route_id}
        response = self.api.update_route(params, addresses)
        return response.json()

    def move_addresses_from_route(self, addresses, route_id):
        params = {'route_id': route_id}
        response = self.api.update_route(params, addresses)
        return response.json()

    def update_route_parameters(self, data, route_id):
        params = {'route_id': route_id}
        response = self.api.update_route(params, data)
        return response.json()

    def update_route(self, data, route_id):
        params = {'route_id': route_id}
        response = self.api.update_route(params, data)
        return response.json()

    def insert_address_into_route_optimal_position(self, **kwargs):
        """
        Insert an address into a route in an optimal position using PUT
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        if self.check_required_params(kwargs, ['addresses', 'route_id', 'optimal_position']):
            params = {'api_key': self.params['api_key'],
                      'route_id': kwargs.pop('route_id')}

            response = self.api._request_put(ROUTE_HOST,
                                             params, data=json.dumps(kwargs, ensure_ascii=False))
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def get_route_path_points(self, **kwargs):
        """
        Get path point from a route using GET
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['route_path_output', 'route_id', ]):
            response = self.api._request_get(ROUTE_HOST,
                                             kwargs)
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def get_route_directions(self, **kwargs):
        """
        Get route directions using GET
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['directions', 'route_id', ]):
            response = self.api._request_get(ROUTE_HOST,
                                             kwargs)
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def update_route(self, params, data):
        params.update({'api_key': self.key})
        data = json.dumps(data)
        return self._make_request(ROUTE_HOST, params, data, self._request_put)

    def share_route(self, **kwargs):
        """
        Share a route using POST
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        if self.check_required_params(kwargs, ['recipient_email', 'route_id', 'response_format']):
            params = {'api_key': self.params['api_key'],
                      'route_id': kwargs.pop('route_id'),
                      'response_format': kwargs.pop('response_format')}
            response = self.api._request_post(SHARE_ROUTE_HOST,
                                              params,
                                              data=json.dumps(kwargs, ensure_ascii=False))
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def resequence_route(self, **kwargs):
        """
        Resequence a route using PUT
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        if self.check_required_params(kwargs, ['addresses', 'route_id', 'route_destination_id']):
            params = {'api_key': self.params['api_key'],
                      'route_id': kwargs.pop('route_id'),
                      'route_destination_id': kwargs.pop('route_destination_id'), }

            response = self.api._request_put(ROUTE_HOST,
                                             params, data=json.dumps(kwargs, ensure_ascii=False))
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def merge_routes(self, **kwargs):
        """
        Merge routes using POST
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        if self.check_required_params(kwargs, ['route_ids']):
            response = self.api._request_post(MERGE_ROUTES_HOST,
                                              self.params,
                                              data=json.dumps(kwargs, ensure_ascii=False))
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def resequence_route_all(self, **kwargs):
        """
        Resequence Route using GET
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['disable_optimization', 'route_id', 'optimize', ]):
            response = self.api._request_get(RESEQUENCE_ROUTE,
                                             kwargs)
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def update_route_destination_custom_data(self, **kwargs):
        """
        Update route destination custom data using PUT
        :return: API response
        :raises: ParamValueException if required params are not present.
        AttributeError if there is an error deleting a route
        """
        if self.check_required_params(kwargs, ['route_id', 'route_destination_id']):
            params = {'api_key': self.params['api_key'],
                      'route_id': kwargs.pop('route_id'),
                      'route_destination_id': kwargs.pop('route_destination_id'), }

            response = self.api._request_put(ADDRESS_HOST,
                                             params, data=json.dumps(kwargs, ensure_ascii=False))
            return response.json()

        else:
            raise ParamValueException('params', 'Params are not complete')

    def export_route(self, route_id, output_format='csv'):
        """
        Get Route from given post data
        :param route_id:
        :param output_format:
        :return: response as a object
        """
        data = {'route_id': route_id, 'strExportFormat': output_format}
        self.response = self.api._make_request(EXPORTER, {}, data,
                                               self.api._request_post)
        return self.response.content

# codebeat:enable[TOO_MANY_FUNCTIONS]


1			# codebeat:disable[TOO_MANY_FUNCTIONS]
2			import json
3
4			from route4me.base import Base
5			from route4me.exceptions import ParamValueException
6			from route4me.utils import json2obj
7			from route4me.api_endpoints import ROUTE_HOST, EXPORTER, \
8			ADDRESS_HOST, GET_ACTIVITIES_HOST, DUPLICATE_ROUTE, SHARE_ROUTE_HOST, \
9			MERGE_ROUTES_HOST, RESEQUENCE_ROUTE
10
11
12			class Route(Base):
13			"""
14			A Route is a multi-sequence of addresses that need to be
15			visited by a single vehicle and a single driver in a fixed time period.
16			"""
17			requirements = [
18			'api_key',
19			'route_id',
20			]
21
22			def __init__(self, api):
23			"""
24			Routes
25			:param api: route4me instance
26			:return: route instance
27			"""
28			self.response = None
29			self.params = {'api_key': api.key, }
30			Base.__init__(self, api)
31
32			def get_route(self, **kwargs):
33			"""
34			Get route using GET request
35			:return: API response
36			:raise: ParamValueException if required params are not present.
37			"""
38			if self.validate_params(**kwargs):
39			self.params.update(kwargs)
40			if self.check_required_params(self.params, self.requirements):
41			self.response = self.api._request_get(ROUTE_HOST,
42			self.params)
43			response = self.response.json()
44			return response
45
46			else:
47			raise ParamValueException('params', 'Params are not complete')
48
49			def get_route_tracking(self, **kwargs):
50			"""
51			Get route using GET request
52			:return: API response
53			:raise: ParamValueException if required params are not present.
54			"""
55			if self.validate_params(**kwargs):
56			self.params.update(kwargs)
57			self.params.update({'device_tracking_history': 1})
58			if self.check_required_params(self.params, self.requirements):
59			self.response = self.api._request_get(ROUTE_HOST,
60			self.params)
61			response = self.response.json()
62			return response
63
64			else:
65			raise ParamValueException('params', 'Params are not complete')
66
67			def get_routes(self, **kwargs):
68			"""
69			Get routes using GET request
70			:return: API response
71			:raise: ParamValueException if required params are not present.
72
73			"""
74			kwargs.update({'api_key': self.params['api_key'], })
75			if self.check_required_params(kwargs, ['limit', 'Offset', ]):
76			self.response = self.api._request_get(ROUTE_HOST,
77			kwargs)
78			response = self.response.json()
79			return response
80			else:
81			raise ParamValueException('params', 'Params are not complete')
82
83			def get_activities(self, **kwargs):
84			"""
85			Get routes activities using GET request
86			:return: API response
87			:raise: ParamValueException if required params are not present.
88
89			"""
90			kwargs.update({'api_key': self.params['api_key'], })
91			if self.check_required_params(kwargs, ['route_id', 'limit', 'Offset', ]):
92			self.response = self.api._request_get(GET_ACTIVITIES_HOST,
93			kwargs)
94			response = json2obj(self.response.content)
95			return response
96			else:
97			raise ParamValueException('params', 'Params are not complete')
98
99			def duplicate_route(self, **kwargs):
100			"""
101			Duplicate route using GET request
102			:return: API response
103			:raise: ParamValueException if required params are not present.
104			"""
105			kwargs.update({'api_key': self.params['api_key'], })
106			if self.check_required_params(kwargs, ['route_id', ]):
107			self.response = self.api._request_get(DUPLICATE_ROUTE,
108			kwargs)
109			response = self.response.json()
110			return response
111			else:
112			raise ParamValueException('params', 'Params are not complete')
113
114			def delete_routes(self, **kwargs):
115			"""
116			Delete routes using DELETE request
117			:return: API response
118			:raise: ParamValueException if required params are not present.
119			"""
120			kwargs.update({'api_key': self.params['api_key'], })
121			if self.check_required_params(kwargs, ['route_id', ]):
122			kwargs['route_id'] = ','.join(kwargs['route_id'])
123			self.response = self.api._request_delete(ROUTE_HOST,
124			kwargs)
125			response = self.response.json()
126			return response
127			else:
128			raise ParamValueException('params', 'Params are not complete')
129
130			def delete_route(self, **kwargs):
131			"""
132			Delete given route
133			:return: API response
134			:raises: ParamValueException if required params are not present.
135			AttributeError if there is an error deleting a route
136			"""
137			kwargs.update({'api_key': self.params['api_key'], })
138			if self.check_required_params(kwargs, ['route_id', ]):
139			self.response = self.api._request_delete(ROUTE_HOST, kwargs)
140			response = self.response.json()
141			try:
142			response = response.get('deleted')
143			return response
144			except AttributeError:
145			return response.errors
146			else:
147			raise ParamValueException('params', 'Params are not complete')
148
149			def insert_address_into_route(self, addresses, route_id):
150			params = {'route_id': route_id}
151			response = self.api.update_route(params, addresses)
152			return response.json()
153
154			def move_addresses_from_route(self, addresses, route_id):
155			params = {'route_id': route_id}
156			response = self.api.update_route(params, addresses)
157			return response.json()
158
159			def update_route_parameters(self, data, route_id):
160			params = {'route_id': route_id}
161			response = self.api.update_route(params, data)
162			return response.json()
163
164			def update_route(self, data, route_id):
165			params = {'route_id': route_id}
166			response = self.api.update_route(params, data)
167			return response.json()
168
169			def insert_address_into_route_optimal_position(self, **kwargs):
170			"""
171			Insert an address into a route in an optimal position using PUT
172			:return: API response
173			:raises: ParamValueException if required params are not present.
174			AttributeError if there is an error deleting a route
175			"""
176			if self.check_required_params(kwargs, ['addresses', 'route_id', 'optimal_position']):
177			params = {'api_key': self.params['api_key'],
178			'route_id': kwargs.pop('route_id')}
179
180			response = self.api._request_put(ROUTE_HOST,
181			params, data=json.dumps(kwargs, ensure_ascii=False))
182			return response.json()
183
184			else:
185			raise ParamValueException('params', 'Params are not complete')
186
187			def get_route_path_points(self, **kwargs):
188			"""
189			Get path point from a route using GET
190			:return: API response
191			:raises: ParamValueException if required params are not present.
192			AttributeError if there is an error deleting a route
193			"""
194			kwargs.update({'api_key': self.params['api_key'], })
195			if self.check_required_params(kwargs, ['route_path_output', 'route_id', ]):
196			response = self.api._request_get(ROUTE_HOST,
197			kwargs)
198			return response.json()
199
200			else:
201			raise ParamValueException('params', 'Params are not complete')
202
203			def get_route_directions(self, **kwargs):
204			"""
205			Get route directions using GET
206			:return: API response
207			:raises: ParamValueException if required params are not present.
208			AttributeError if there is an error deleting a route
209			"""
210			kwargs.update({'api_key': self.params['api_key'], })
211			if self.check_required_params(kwargs, ['directions', 'route_id', ]):
212			response = self.api._request_get(ROUTE_HOST,
213			kwargs)
214			return response.json()
215
216			else:
217			raise ParamValueException('params', 'Params are not complete')
218
219			def update_route(self, params, data):
220			params.update({'api_key': self.key})
221			data = json.dumps(data)
222			return self._make_request(ROUTE_HOST, params, data, self._request_put)
223
224			def share_route(self, **kwargs):
225			"""
226			Share a route using POST
227			:return: API response
228			:raises: ParamValueException if required params are not present.
229			AttributeError if there is an error deleting a route
230			"""
231			if self.check_required_params(kwargs, ['recipient_email', 'route_id', 'response_format']):
232			params = {'api_key': self.params['api_key'],
233			'route_id': kwargs.pop('route_id'),
234			'response_format': kwargs.pop('response_format')}
235			response = self.api._request_post(SHARE_ROUTE_HOST,
236			params,
237			data=json.dumps(kwargs, ensure_ascii=False))
238			return response.json()
239
240			else:
241			raise ParamValueException('params', 'Params are not complete')
242
243			def resequence_route(self, **kwargs):
244			"""
245			Resequence a route using PUT
246			:return: API response
247			:raises: ParamValueException if required params are not present.
248			AttributeError if there is an error deleting a route
249			"""
250			if self.check_required_params(kwargs, ['addresses', 'route_id', 'route_destination_id']):
251			params = {'api_key': self.params['api_key'],
252			'route_id': kwargs.pop('route_id'),
253			'route_destination_id': kwargs.pop('route_destination_id'), }
254
255			response = self.api._request_put(ROUTE_HOST,
256			params, data=json.dumps(kwargs, ensure_ascii=False))
257			return response.json()
258
259			else:
260			raise ParamValueException('params', 'Params are not complete')
261
262			def merge_routes(self, **kwargs):
263			"""
264			Merge routes using POST
265			:return: API response
266			:raises: ParamValueException if required params are not present.
267			AttributeError if there is an error deleting a route
268			"""
269			if self.check_required_params(kwargs, ['route_ids']):
270			response = self.api._request_post(MERGE_ROUTES_HOST,
271			self.params,
272			data=json.dumps(kwargs, ensure_ascii=False))
273			return response.json()
274
275			else:
276			raise ParamValueException('params', 'Params are not complete')
277
278			def resequence_route_all(self, **kwargs):
279			"""
280			Resequence Route using GET
281			:return: API response
282			:raises: ParamValueException if required params are not present.
283			AttributeError if there is an error deleting a route
284			"""
285			kwargs.update({'api_key': self.params['api_key'], })
286			if self.check_required_params(kwargs, ['disable_optimization', 'route_id', 'optimize', ]):
287			response = self.api._request_get(RESEQUENCE_ROUTE,
288			kwargs)
289			return response.json()
290
291			else:
292			raise ParamValueException('params', 'Params are not complete')
293
294			def update_route_destination_custom_data(self, **kwargs):
295			"""
296			Update route destination custom data using PUT
297			:return: API response
298			:raises: ParamValueException if required params are not present.
299			AttributeError if there is an error deleting a route
300			"""
301			if self.check_required_params(kwargs, ['route_id', 'route_destination_id']):
302			params = {'api_key': self.params['api_key'],
303			'route_id': kwargs.pop('route_id'),
304			'route_destination_id': kwargs.pop('route_destination_id'), }
305
306			response = self.api._request_put(ADDRESS_HOST,
307			params, data=json.dumps(kwargs, ensure_ascii=False))
308			return response.json()
309
310			else:
311			raise ParamValueException('params', 'Params are not complete')
312
313			def export_route(self, route_id, output_format='csv'):
314			"""
315			Get Route from given post data
316			:param route_id:
317			:param output_format:
318			:return: response as a object
319			"""
320			data = {'route_id': route_id, 'strExportFormat': output_format}
321			self.response = self.api._make_request(EXPORTER, {}, data,
322			self.api._request_post)
323			return self.response.content
324
325			# codebeat:enable[TOO_MANY_FUNCTIONS]
326

route4me / route4me-python-sdk

GitHub Access Token became invalid

Push — master ( e3a209...bb2a36 )

Route.export_route() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like