route4me 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,3 @@
1
+ module Route4me
2
+ VERSION = '1.1.0'
3
+ end
@@ -0,0 +1,24 @@
1
+ $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
2
+
3
+ require 'route4me/version'
4
+
5
+ spec = Gem::Specification.new do |s|
6
+ s.name = 'route4me'
7
+ s.version = Route4me::VERSION
8
+ s.summary = 'Ruby bindings for the Route4me API'
9
+ s.description = 'Routing Software, Route Planning Software, Delivery Route Planner'
10
+ s.author = 'Igor Skrynkovskyy'
11
+ s.email = 'igor@route4me.com'
12
+ s.homepage = 'http://route4me.com'
13
+
14
+ s.add_dependency 'rest-client', '~> 1.4'
15
+ s.add_dependency 'mime-types', '~> 1.25'
16
+ s.add_dependency 'json', '~> 1.8.1'
17
+
18
+ s.add_development_dependency 'rspec'
19
+
20
+ s.files = `git ls-files`.split("\n")
21
+ s.test_files = `git ls-files -- test/*`.split("\n")
22
+ s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
23
+ s.require_paths = ['lib']
24
+ end
@@ -0,0 +1,217 @@
1
+ require File.expand_path('../../spec_helper', __FILE__)
2
+
3
+ describe Route4me::OptimizationProblem do
4
+ it "Should create simple driver optimization" do
5
+ problem = Route4me::OptimizationProblem.optimize(
6
+ :addresses => addresses,
7
+ :parameters => {
8
+ :algorithm_type => 1,
9
+ :device_type => 'web',
10
+ :distance_unit => 'mi',
11
+ :optimize => 'Distance',
12
+ :travel_mode => 'Driving',
13
+ :route_max_duration => 86400,
14
+ :vehicle_capacity => 1,
15
+ :vehicle_max_distance_mi => 10000
16
+ }
17
+ )
18
+
19
+ expect(problem).not_to be_nil
20
+ expect(problem[:optimization_problem_id]).to_not be_empty
21
+ expect(problem[:parameters]).to_not be_empty
22
+ expect(problem[:addresses].length).to eq(5)
23
+ expect(problem[:state]).to eq(4)
24
+
25
+ parameters = problem[:parameters]
26
+ expect(parameters[:algorithm_type]).to eq('1')
27
+ expect(parameters[:rt]).to eq(false)
28
+ expect(parameters[:device_type]).to eq('web')
29
+ expect(parameters[:distance_unit]).to eq('mi')
30
+ expect(parameters[:optimize]).to eq('Distance')
31
+ expect(parameters[:travel_mode]).to eq('Driving')
32
+ expect(parameters[:route_max_duration]).to eq(86400)
33
+ expect(parameters[:vehicle_capacity]).to eq('1')
34
+ expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
35
+ end
36
+
37
+ it "Should create simple driver optimization with round trip" do
38
+ problem = Route4me::OptimizationProblem.optimize(
39
+ :addresses => addresses,
40
+ :parameters => {
41
+ :algorithm_type => 1,
42
+ :rt => true,
43
+ :device_type => 'web',
44
+ :distance_unit => 'mi',
45
+ :optimize => 'Distance',
46
+ :travel_mode => 'Driving',
47
+ :route_max_duration => 86400,
48
+ :vehicle_capacity => 1,
49
+ :vehicle_max_distance_mi => 10000
50
+ }
51
+ )
52
+
53
+ expect(problem).not_to be_nil
54
+ expect(problem[:optimization_problem_id]).to_not be_empty
55
+ expect(problem[:parameters]).to_not be_empty
56
+ expect(problem[:addresses].length).to eq(5)
57
+ expect(problem[:state]).to eq(4)
58
+
59
+ parameters = problem[:parameters]
60
+ expect(parameters[:algorithm_type]).to eq('1')
61
+ expect(parameters[:rt]).to eq(true)
62
+ expect(parameters[:device_type]).to eq('web')
63
+ expect(parameters[:distance_unit]).to eq('mi')
64
+ expect(parameters[:optimize]).to eq('Distance')
65
+ expect(parameters[:travel_mode]).to eq('Driving')
66
+ expect(parameters[:route_max_duration]).to eq(86400)
67
+ expect(parameters[:vehicle_capacity]).to eq('1')
68
+ expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
69
+ end
70
+
71
+ it "Should create multiple driver optimization" do
72
+ problem = Route4me::OptimizationProblem.optimize(
73
+ :addresses => addresses,
74
+ :parameters => {
75
+ :algorithm_type => 3,
76
+ :metric => 3,
77
+ :device_type => 'web',
78
+ :distance_unit => 'mi',
79
+ :optimize => 'Distance',
80
+ :travel_mode => 'Driving',
81
+ :route_max_duration => 86400,
82
+ :vehicle_capacity => 99,
83
+ :vehicle_max_distance_mi => 10000,
84
+ :preferred_matrix_method => 2
85
+ }
86
+ )
87
+
88
+ expect(problem).not_to be_nil
89
+ expect(problem[:optimization_problem_id]).to_not be_empty
90
+ expect(problem[:parameters]).to_not be_empty
91
+ expect(problem[:addresses].length).to eq(5)
92
+ expect(problem[:state]).to eq(4)
93
+
94
+ parameters = problem[:parameters]
95
+ expect(parameters[:algorithm_type]).to eq('3')
96
+ expect(parameters[:device_type]).to eq('web')
97
+ expect(parameters[:distance_unit]).to eq('mi')
98
+ expect(parameters[:optimize]).to eq('Distance')
99
+ expect(parameters[:travel_mode]).to eq('Driving')
100
+ expect(parameters[:route_max_duration]).to eq(86400)
101
+ expect(parameters[:vehicle_capacity]).to eq('99')
102
+ expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
103
+ end
104
+
105
+ it "Should create single driver optimization with time window" do
106
+ problem = Route4me::OptimizationProblem.optimize(
107
+ :addresses => addresses,
108
+ :parameters => {
109
+ :algorithm_type => 4,
110
+ :rt => true,
111
+ :device_type => 'web',
112
+ :distance_unit => 'mi',
113
+ :optimize => 'Distance',
114
+ :travel_mode => 'Driving',
115
+ :route_max_duration => 86400,
116
+ :vehicle_capacity => 99,
117
+ :vehicle_max_distance_mi => 10000
118
+ }
119
+ )
120
+
121
+ expect(problem).not_to be_nil
122
+ expect(problem[:optimization_problem_id]).to_not be_empty
123
+ expect(problem[:parameters]).to_not be_empty
124
+ expect(problem[:addresses].length).to eq(5)
125
+ expect(problem[:state]).to eq(4)
126
+
127
+ parameters = problem[:parameters]
128
+ expect(parameters[:algorithm_type]).to eq("4")
129
+ expect(parameters[:device_type]).to eq('web')
130
+ expect(parameters[:distance_unit]).to eq('mi')
131
+ expect(parameters[:optimize]).to eq('Distance')
132
+ expect(parameters[:travel_mode]).to eq('Driving')
133
+ expect(parameters[:route_max_duration]).to eq(86400)
134
+ expect(parameters[:vehicle_capacity]).to eq('99')
135
+ expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
136
+ end
137
+
138
+ it 'Should create route without optimization' do
139
+ problem = Route4me::OptimizationProblem.optimize(
140
+ :addresses => addresses,
141
+ :parameters => {
142
+ :algorithm_type => 1,
143
+ :disable_optimization => true
144
+ }
145
+ )
146
+
147
+ expect(problem).not_to be_nil
148
+ expect(problem[:optimization_problem_id]).to_not be_empty
149
+ expect(problem[:addresses].length).to eq(5)
150
+ expect(problem[:parameters]).to_not be_empty
151
+ expect(problem[:parameters][:disable_optimization]).to eq(true)
152
+ end
153
+
154
+ it 'Should return data about optimization' do
155
+ problem = Route4me::OptimizationProblem.optimize(
156
+ :addresses => addresses,
157
+ :parameters => {
158
+ :algorithm_type => 1,
159
+ :disable_optimization => true
160
+ }
161
+ )
162
+
163
+ problem_id = problem[:optimization_problem_id]
164
+ problem = Route4me::OptimizationProblem.get(
165
+ :optimization_problem_id => problem_id
166
+ )
167
+
168
+ expect(problem).not_to be_nil
169
+ expect(problem[:addresses].length).to eq(5)
170
+ expect(problem[:parameters]).to_not be_empty
171
+ expect(problem[:optimization_problem_id]).to eq(problem_id)
172
+ end
173
+
174
+ it 'Should return data about several optimization object' do
175
+ problem = Route4me::OptimizationProblem.get(
176
+ :state => [4, 5],
177
+ :limit => 5
178
+ )
179
+
180
+ expect(problem).not_to be_nil
181
+ expect(problem.length).to eq(5)
182
+ expect(problem).to be_kind_of(Array)
183
+ end
184
+
185
+ # should 'update optimization' do
186
+ # problem = Route4me::OptimizationProblem.optimize(
187
+ # :parameters => { :disable_optimization => true },
188
+ # :addresses => addresses
189
+ # )
190
+ #
191
+ # assert problem
192
+ # assert problem['optimization_problem_id']
193
+ #
194
+ # problem_id = problem['optimization_problem_id']
195
+ # problem = Route4me::OptimizationProblem.update(
196
+ # :optimization_problem_id => problem_id,
197
+ # :parameters => {
198
+ # :algorithm_type => 1,
199
+ # :device_type => 'iphone',
200
+ # :distance_unit => 'mi',
201
+ # :optimize => 'Distance',
202
+ # :travel_mode => 'Driving',
203
+ # :route_max_duration => 86400,
204
+ # :vehicle_capacity => 99,
205
+ # :vehicle_max_distance_mi => 10000
206
+ # }
207
+ # )
208
+ #
209
+ # assert problem
210
+ # assert_equal problem_id, problem['optimization_problem_id']
211
+ # assert problem['parameters']
212
+ # parameters = problem['parameters']
213
+ # assert_equal parameters['device_type'], 'web'
214
+ # assert_equal parameters['optimize'], 'Distance'
215
+ # assert_equal parameters['travel_mode'], 'Driving'
216
+ # end
217
+ end
@@ -0,0 +1,60 @@
1
+ require File.expand_path('../../spec_helper', __FILE__)
2
+
3
+ describe Route4me::Route do
4
+ before(:all) do
5
+ problem = Route4me::OptimizationProblem.optimize(
6
+ :parameters => { :disable_optimization => true },
7
+ :addresses => addresses
8
+ )
9
+
10
+ @route_id = problem[:routes][0][:route_id]
11
+ end
12
+
13
+ it 'should return route by id' do
14
+ route = Route4me::Route.get(:route_id => @route_id)
15
+
16
+ expect(route).not_to be_nil
17
+ expect(route[:route_id]).to eq(@route_id)
18
+ expect(route[:tracking_history]).to be_nil
19
+ expect(route[:optimization_problem_id]).to_not be_empty
20
+ end
21
+
22
+ it 'should return route by id with tracking' do
23
+ 2.times do
24
+ Route4me::Track.set(
25
+ :format => 'json',
26
+ :member_id => 1,
27
+ :route_id => @route_id,
28
+ :course => 1,
29
+ :speed => 120,
30
+ :lat => 41.8927521,
31
+ :lng => -109.0803888,
32
+ :device_type => 'iphone',
33
+ :device_guid => 'qweqweqwe'
34
+ )
35
+ end
36
+
37
+ route = Route4me::Route.get(
38
+ :route_id => @route_id,
39
+ :device_tracking_history => true
40
+ )
41
+
42
+ expect(route).not_to be_nil
43
+ expect(route[:route_id]).to eq(@route_id)
44
+ expect(route[:optimization_problem_id]).to_not be_empty
45
+ expect(route[:tracking_history]).to_not be_nil
46
+ expect(route[:tracking_history]).to be_kind_of(Array)
47
+ expect(route[:tracking_history].length).to eq(2)
48
+ end
49
+
50
+ it 'should returns 5 routes' do
51
+ routes = Route4me::Route.get(:limit => 5)
52
+
53
+ expect(routes).not_to be_nil
54
+ expect(routes.length).to eq(5)
55
+ end
56
+
57
+ it 'should remove route by route_id' do
58
+ Route4me::Route.delete(:route_id => @route_id) == true
59
+ end
60
+ end
@@ -0,0 +1,35 @@
1
+ require File.expand_path('../../spec_helper', __FILE__)
2
+
3
+ describe Route4me::Track do
4
+ it "Should track device" do
5
+ status = Route4me::Track.set(
6
+ 'format' => 'json',
7
+ 'member_id' => 1,
8
+ 'route_id' => '0CDA1358186D616AFD39FEB579A64974',
9
+ 'course' => 1,
10
+ 'speed' => 120,
11
+ 'lat' => 41.8927521,
12
+ 'lng' => -109.0803888,
13
+ 'device_type' => 'iphone',
14
+ 'device_guid' => 'qweqweqwe'
15
+ )
16
+
17
+ status == true
18
+ end
19
+
20
+ it "Should track device with sym" do
21
+ status = Route4me::Track.set(
22
+ format: 'json',
23
+ member_id: 1,
24
+ route_id: '0CDA1358186D616AFD39FEB579A64974',
25
+ course: 1,
26
+ speed: 120,
27
+ lat: 41.8927521,
28
+ lng: -109.0803888,
29
+ device_type: 'iphone',
30
+ device_guid: 'qweqweqwe'
31
+ )
32
+
33
+ status == true
34
+ end
35
+ end
@@ -0,0 +1,49 @@
1
+ require 'route4me'
2
+
3
+ Route4me.api_base='http://staging.route4me.com:8080'
4
+ Route4me.api_key="11111111111111111111111111111111"
5
+
6
+ def addresses
7
+ [
8
+ {
9
+ :address => "6107 Prospect St, Fredericksburg, VA 22407",
10
+ :is_depot => true,
11
+ :lat => 38.2229881287,
12
+ :lng => -77.5451965332,
13
+ :time_window_start => 39600,
14
+ :time_window_end => 61200
15
+ },
16
+ {
17
+ :address => "6202 Blackstone Blvd, Fredericksburg, VA 22407",
18
+ :is_depot => false,
19
+ :lat => 38.2240219116,
20
+ :lng => -77.5488815308,
21
+ :time_window_start => 32400,
22
+ :time_window_end => 64800
23
+ },
24
+ {
25
+ :address => "10700 Heatherwood Dr, Spotsylvania, VA 22553",
26
+ :is_depot => false,
27
+ :lat => 38.2465057373,
28
+ :lng => -77.5649108887,
29
+ :time_window_start => 14400,
30
+ :time_window_end => 68400
31
+ },
32
+ {
33
+ :address => "10416 Rolling Ridge Dr, Spotsylvania, VA 22553",
34
+ :is_depot => false,
35
+ :lat => 38.2465667725,
36
+ :lng => -77.5721282959,
37
+ :time_window_start => 57600,
38
+ :time_window_end => 68400
39
+ },
40
+ {
41
+ :address => "10609 Mystic Pointe Dr, Fredericksburg, VA 22407",
42
+ :is_depot => false,
43
+ :lat => 38.2513427734,
44
+ :lng => -77.5993652344,
45
+ :time_window_start => 28800,
46
+ :time_window_end => 75600
47
+ }
48
+ ]
49
+ end
metadata ADDED
@@ -0,0 +1,134 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: route4me
3
+ version: !ruby/object:Gem::Version
4
+ version: 1.1.0
5
+ platform: ruby
6
+ authors:
7
+ - Igor Skrynkovskyy
8
+ autorequire:
9
+ bindir: bin
10
+ cert_chain: []
11
+ date: 2014-08-04 00:00:00.000000000 Z
12
+ dependencies:
13
+ - !ruby/object:Gem::Dependency
14
+ name: rest-client
15
+ requirement: !ruby/object:Gem::Requirement
16
+ requirements:
17
+ - - "~>"
18
+ - !ruby/object:Gem::Version
19
+ version: '1.4'
20
+ type: :runtime
21
+ prerelease: false
22
+ version_requirements: !ruby/object:Gem::Requirement
23
+ requirements:
24
+ - - "~>"
25
+ - !ruby/object:Gem::Version
26
+ version: '1.4'
27
+ - !ruby/object:Gem::Dependency
28
+ name: mime-types
29
+ requirement: !ruby/object:Gem::Requirement
30
+ requirements:
31
+ - - "~>"
32
+ - !ruby/object:Gem::Version
33
+ version: '1.25'
34
+ type: :runtime
35
+ prerelease: false
36
+ version_requirements: !ruby/object:Gem::Requirement
37
+ requirements:
38
+ - - "~>"
39
+ - !ruby/object:Gem::Version
40
+ version: '1.25'
41
+ - !ruby/object:Gem::Dependency
42
+ name: json
43
+ requirement: !ruby/object:Gem::Requirement
44
+ requirements:
45
+ - - "~>"
46
+ - !ruby/object:Gem::Version
47
+ version: 1.8.1
48
+ type: :runtime
49
+ prerelease: false
50
+ version_requirements: !ruby/object:Gem::Requirement
51
+ requirements:
52
+ - - "~>"
53
+ - !ruby/object:Gem::Version
54
+ version: 1.8.1
55
+ - !ruby/object:Gem::Dependency
56
+ name: rspec
57
+ requirement: !ruby/object:Gem::Requirement
58
+ requirements:
59
+ - - ">="
60
+ - !ruby/object:Gem::Version
61
+ version: '0'
62
+ type: :development
63
+ prerelease: false
64
+ version_requirements: !ruby/object:Gem::Requirement
65
+ requirements:
66
+ - - ">="
67
+ - !ruby/object:Gem::Version
68
+ version: '0'
69
+ description: Routing Software, Route Planning Software, Delivery Route Planner
70
+ email: igor@route4me.com
71
+ executables: []
72
+ extensions: []
73
+ extra_rdoc_files: []
74
+ files:
75
+ - ".gitignore"
76
+ - ".travis.yml"
77
+ - Gemfile
78
+ - README.md
79
+ - VERSION
80
+ - examples/addresses.json
81
+ - examples/get_route_manifest.rb
82
+ - examples/get_route_tracking.rb
83
+ - examples/helper.rb
84
+ - examples/multiple_depot_multiple_driver.rb
85
+ - examples/multiple_depot_with_time_window.rb
86
+ - examples/reoptimization.rb
87
+ - examples/single_driver_round_trip.rb
88
+ - examples/single_driver_route_ten_stops.rb
89
+ - examples/track.rb
90
+ - lib/route4me.rb
91
+ - lib/route4me/enum/algorithm_type.rb
92
+ - lib/route4me/enum/avoid.rb
93
+ - lib/route4me/enum/device_type.rb
94
+ - lib/route4me/enum/direction_method.rb
95
+ - lib/route4me/enum/distance_unit.rb
96
+ - lib/route4me/enum/metric.rb
97
+ - lib/route4me/enum/optimization_type.rb
98
+ - lib/route4me/enum/travel_mode.rb
99
+ - lib/route4me/errors/api_error.rb
100
+ - lib/route4me/errors/route4me_error.rb
101
+ - lib/route4me/optimization_problem.rb
102
+ - lib/route4me/route.rb
103
+ - lib/route4me/track.rb
104
+ - lib/route4me/util.rb
105
+ - lib/route4me/version.rb
106
+ - route4me.gemspec
107
+ - spec/route4me/optimization_problem_spec.rb
108
+ - spec/route4me/route_spec.rb
109
+ - spec/route4me/track_spec.rb
110
+ - spec/spec_helper.rb
111
+ homepage: http://route4me.com
112
+ licenses: []
113
+ metadata: {}
114
+ post_install_message:
115
+ rdoc_options: []
116
+ require_paths:
117
+ - lib
118
+ required_ruby_version: !ruby/object:Gem::Requirement
119
+ requirements:
120
+ - - ">="
121
+ - !ruby/object:Gem::Version
122
+ version: '0'
123
+ required_rubygems_version: !ruby/object:Gem::Requirement
124
+ requirements:
125
+ - - ">="
126
+ - !ruby/object:Gem::Version
127
+ version: '0'
128
+ requirements: []
129
+ rubyforge_project:
130
+ rubygems_version: 2.2.2
131
+ signing_key:
132
+ specification_version: 4
133
+ summary: Ruby bindings for the Route4me API
134
+ test_files: []