route4me 1.1.0

data/lib/route4me/version.rb

@@ -0,0 +1,3 @@
+module Route4me
+  VERSION = '1.1.0'
+end

data/route4me.gemspec

@@ -0,0 +1,24 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'route4me/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'route4me'
+  s.version = Route4me::VERSION
+  s.summary = 'Ruby bindings for the Route4me API'
+  s.description = 'Routing Software, Route Planning Software, Delivery Route Planner'
+  s.author = 'Igor Skrynkovskyy'
+  s.email = 'igor@route4me.com'
+  s.homepage = 'http://route4me.com'
+
+  s.add_dependency 'rest-client', '~> 1.4'
+  s.add_dependency 'mime-types', '~> 1.25'
+  s.add_dependency 'json', '~> 1.8.1'
+
+  s.add_development_dependency 'rspec'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/spec/route4me/optimization_problem_spec.rb

@@ -0,0 +1,217 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Route4me::OptimizationProblem do
+  it "Should create simple driver optimization" do
+    problem = Route4me::OptimizationProblem.optimize(
+      :addresses => addresses,
+      :parameters => {
+        :algorithm_type          => 1,
+        :device_type             => 'web',
+        :distance_unit           => 'mi',
+        :optimize                => 'Distance',
+        :travel_mode             => 'Driving',
+        :route_max_duration      => 86400,
+        :vehicle_capacity        => 1,
+        :vehicle_max_distance_mi => 10000
+      }
+    )
+
+    expect(problem).not_to be_nil
+    expect(problem[:optimization_problem_id]).to_not be_empty
+    expect(problem[:parameters]).to_not be_empty
+    expect(problem[:addresses].length).to eq(5)
+    expect(problem[:state]).to eq(4)
+
+    parameters = problem[:parameters]
+    expect(parameters[:algorithm_type]).to eq('1')
+    expect(parameters[:rt]).to eq(false)
+    expect(parameters[:device_type]).to eq('web')
+    expect(parameters[:distance_unit]).to eq('mi')
+    expect(parameters[:optimize]).to eq('Distance')
+    expect(parameters[:travel_mode]).to eq('Driving')
+    expect(parameters[:route_max_duration]).to eq(86400)
+    expect(parameters[:vehicle_capacity]).to eq('1')
+    expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
+  end
+
+  it "Should create simple driver optimization with round trip" do
+    problem = Route4me::OptimizationProblem.optimize(
+      :addresses => addresses,
+      :parameters => {
+        :algorithm_type          => 1,
+        :rt                      => true,
+        :device_type             => 'web',
+        :distance_unit           => 'mi',
+        :optimize                => 'Distance',
+        :travel_mode             => 'Driving',
+        :route_max_duration      => 86400,
+        :vehicle_capacity        => 1,
+        :vehicle_max_distance_mi => 10000
+      }
+    )
+
+    expect(problem).not_to be_nil
+    expect(problem[:optimization_problem_id]).to_not be_empty
+    expect(problem[:parameters]).to_not be_empty
+    expect(problem[:addresses].length).to eq(5)
+    expect(problem[:state]).to eq(4)
+
+    parameters = problem[:parameters]
+    expect(parameters[:algorithm_type]).to eq('1')
+    expect(parameters[:rt]).to eq(true)
+    expect(parameters[:device_type]).to eq('web')
+    expect(parameters[:distance_unit]).to eq('mi')
+    expect(parameters[:optimize]).to eq('Distance')
+    expect(parameters[:travel_mode]).to eq('Driving')
+    expect(parameters[:route_max_duration]).to eq(86400)
+    expect(parameters[:vehicle_capacity]).to eq('1')
+    expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
+  end
+
+  it "Should create multiple driver optimization" do
+    problem = Route4me::OptimizationProblem.optimize(
+      :addresses => addresses,
+      :parameters => {
+        :algorithm_type          => 3,
+        :metric                  => 3,
+        :device_type             => 'web',
+        :distance_unit           => 'mi',
+        :optimize                => 'Distance',
+        :travel_mode             => 'Driving',
+        :route_max_duration      => 86400,
+        :vehicle_capacity        => 99,
+        :vehicle_max_distance_mi => 10000,
+        :preferred_matrix_method => 2
+      }
+    )
+
+    expect(problem).not_to be_nil
+    expect(problem[:optimization_problem_id]).to_not be_empty
+    expect(problem[:parameters]).to_not be_empty
+    expect(problem[:addresses].length).to eq(5)
+    expect(problem[:state]).to eq(4)
+
+    parameters = problem[:parameters]
+    expect(parameters[:algorithm_type]).to eq('3')
+    expect(parameters[:device_type]).to eq('web')
+    expect(parameters[:distance_unit]).to eq('mi')
+    expect(parameters[:optimize]).to eq('Distance')
+    expect(parameters[:travel_mode]).to eq('Driving')
+    expect(parameters[:route_max_duration]).to eq(86400)
+    expect(parameters[:vehicle_capacity]).to eq('99')
+    expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
+  end
+
+  it "Should create single driver optimization with time window" do
+    problem = Route4me::OptimizationProblem.optimize(
+      :addresses => addresses,
+      :parameters => {
+          :algorithm_type          => 4,
+          :rt                      => true,
+          :device_type             => 'web',
+          :distance_unit           => 'mi',
+          :optimize                => 'Distance',
+          :travel_mode             => 'Driving',
+          :route_max_duration      => 86400,
+          :vehicle_capacity        => 99,
+          :vehicle_max_distance_mi => 10000
+      }
+    )
+
+    expect(problem).not_to be_nil
+    expect(problem[:optimization_problem_id]).to_not be_empty
+    expect(problem[:parameters]).to_not be_empty
+    expect(problem[:addresses].length).to eq(5)
+    expect(problem[:state]).to eq(4)
+
+    parameters = problem[:parameters]
+    expect(parameters[:algorithm_type]).to eq("4")
+    expect(parameters[:device_type]).to eq('web')
+    expect(parameters[:distance_unit]).to eq('mi')
+    expect(parameters[:optimize]).to eq('Distance')
+    expect(parameters[:travel_mode]).to eq('Driving')
+    expect(parameters[:route_max_duration]).to eq(86400)
+    expect(parameters[:vehicle_capacity]).to eq('99')
+    expect(parameters[:vehicle_max_distance_mi]).to eq('10000')
+  end
+
+  it 'Should create route without optimization' do
+    problem = Route4me::OptimizationProblem.optimize(
+      :addresses => addresses,
+      :parameters => {
+        :algorithm_type       => 1,
+        :disable_optimization => true
+      }
+    )
+
+    expect(problem).not_to be_nil
+    expect(problem[:optimization_problem_id]).to_not be_empty
+    expect(problem[:addresses].length).to eq(5)
+    expect(problem[:parameters]).to_not be_empty
+    expect(problem[:parameters][:disable_optimization]).to eq(true)
+  end
+
+  it 'Should return data about optimization' do
+    problem = Route4me::OptimizationProblem.optimize(
+      :addresses => addresses,
+      :parameters => {
+        :algorithm_type       => 1,
+        :disable_optimization => true
+      }
+    )
+
+    problem_id = problem[:optimization_problem_id]
+    problem = Route4me::OptimizationProblem.get(
+      :optimization_problem_id => problem_id
+    )
+
+    expect(problem).not_to be_nil
+    expect(problem[:addresses].length).to eq(5)
+    expect(problem[:parameters]).to_not be_empty
+    expect(problem[:optimization_problem_id]).to eq(problem_id)
+  end
+
+  it 'Should return data about several optimization object' do
+    problem = Route4me::OptimizationProblem.get(
+      :state => [4, 5],
+      :limit => 5
+    )
+
+    expect(problem).not_to be_nil
+    expect(problem.length).to eq(5)
+    expect(problem).to be_kind_of(Array)
+  end
+
+  # should 'update optimization' do
+  #   problem = Route4me::OptimizationProblem.optimize(
+  #     :parameters => { :disable_optimization => true },
+  #     :addresses => addresses
+  #   )
+  #
+  #   assert problem
+  #   assert problem['optimization_problem_id']
+  #
+  #   problem_id = problem['optimization_problem_id']
+  #   problem = Route4me::OptimizationProblem.update(
+  #     :optimization_problem_id => problem_id,
+  #     :parameters              => {
+  #       :algorithm_type          => 1,
+  #       :device_type             => 'iphone',
+  #       :distance_unit           => 'mi',
+  #       :optimize                => 'Distance',
+  #       :travel_mode             => 'Driving',
+  #       :route_max_duration      => 86400,
+  #       :vehicle_capacity        => 99,
+  #       :vehicle_max_distance_mi => 10000
+  #     }
+  #   )
+  #
+  #   assert problem
+  #   assert_equal problem_id, problem['optimization_problem_id']
+  #   assert problem['parameters']
+  #   parameters = problem['parameters']
+  #   assert_equal parameters['device_type'], 'web'
+  #   assert_equal parameters['optimize'], 'Distance'
+  #   assert_equal parameters['travel_mode'], 'Driving'
+  # end
+end

data/spec/route4me/route_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Route4me::Route do
+  before(:all) do
+    problem = Route4me::OptimizationProblem.optimize(
+      :parameters => { :disable_optimization => true },
+      :addresses  => addresses
+    )
+
+    @route_id = problem[:routes][0][:route_id]
+  end
+
+  it 'should return route by id' do
+    route = Route4me::Route.get(:route_id => @route_id)
+
+    expect(route).not_to be_nil
+    expect(route[:route_id]).to eq(@route_id)
+    expect(route[:tracking_history]).to be_nil
+    expect(route[:optimization_problem_id]).to_not be_empty
+  end
+
+  it 'should return route by id with tracking' do
+    2.times do 
+      Route4me::Track.set(
+        :format      => 'json',
+        :member_id   => 1,
+        :route_id    => @route_id,
+        :course      => 1,
+        :speed       => 120,
+        :lat         => 41.8927521,
+        :lng         => -109.0803888,
+        :device_type => 'iphone',
+        :device_guid => 'qweqweqwe'
+      )
+    end
+
+    route = Route4me::Route.get(
+      :route_id                => @route_id,
+      :device_tracking_history => true
+    )
+
+    expect(route).not_to be_nil
+    expect(route[:route_id]).to eq(@route_id)
+    expect(route[:optimization_problem_id]).to_not be_empty
+    expect(route[:tracking_history]).to_not be_nil
+    expect(route[:tracking_history]).to be_kind_of(Array)
+    expect(route[:tracking_history].length).to eq(2)
+  end
+
+  it 'should returns 5 routes' do
+    routes = Route4me::Route.get(:limit => 5)
+
+    expect(routes).not_to be_nil
+    expect(routes.length).to eq(5)
+  end
+
+  it 'should remove route by route_id' do
+    Route4me::Route.delete(:route_id => @route_id) == true
+  end
+end

data/spec/route4me/track_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Route4me::Track do
+  it "Should track device" do
+    status = Route4me::Track.set(
+      'format'      => 'json',
+      'member_id'   => 1,
+      'route_id'    => '0CDA1358186D616AFD39FEB579A64974',
+      'course'      => 1,
+      'speed'       => 120,
+      'lat'         => 41.8927521,
+      'lng'         => -109.0803888,
+      'device_type' => 'iphone',
+      'device_guid' => 'qweqweqwe'
+    )
+
+    status == true
+  end
+
+  it "Should track device with sym" do
+    status = Route4me::Track.set(
+      format: 'json',
+      member_id: 1,
+      route_id: '0CDA1358186D616AFD39FEB579A64974',
+      course: 1,
+      speed: 120,
+      lat: 41.8927521,
+      lng: -109.0803888,
+      device_type: 'iphone',
+      device_guid: 'qweqweqwe'
+    ) 
+
+    status == true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require 'route4me'
+
+Route4me.api_base='http://staging.route4me.com:8080'
+Route4me.api_key="11111111111111111111111111111111"
+
+def addresses
+  [
+    {
+      :address => "6107 Prospect St, Fredericksburg, VA 22407",
+      :is_depot => true,
+      :lat => 38.2229881287,
+      :lng => -77.5451965332,
+      :time_window_start => 39600,
+      :time_window_end => 61200
+    },
+    {
+      :address => "6202 Blackstone Blvd, Fredericksburg, VA 22407",
+      :is_depot => false,
+      :lat => 38.2240219116,
+      :lng => -77.5488815308,
+      :time_window_start => 32400,
+      :time_window_end => 64800
+    },
+    {
+      :address => "10700 Heatherwood Dr, Spotsylvania, VA 22553",
+      :is_depot => false,
+      :lat => 38.2465057373,
+      :lng => -77.5649108887,
+      :time_window_start => 14400,
+      :time_window_end => 68400
+    },
+    {
+      :address => "10416 Rolling Ridge Dr, Spotsylvania, VA 22553",
+      :is_depot => false,
+      :lat => 38.2465667725,
+      :lng => -77.5721282959,
+      :time_window_start => 57600,
+      :time_window_end => 68400
+    },
+    {
+      :address => "10609 Mystic Pointe Dr, Fredericksburg, VA 22407",
+      :is_depot => false,
+      :lat => 38.2513427734,
+      :lng => -77.5993652344,
+      :time_window_start => 28800,
+      :time_window_end => 75600
+    }
+  ]
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: route4me
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Igor Skrynkovskyy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Routing Software, Route Planning Software, Delivery Route Planner
+email: igor@route4me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- VERSION
+- examples/addresses.json
+- examples/get_route_manifest.rb
+- examples/get_route_tracking.rb
+- examples/helper.rb
+- examples/multiple_depot_multiple_driver.rb
+- examples/multiple_depot_with_time_window.rb
+- examples/reoptimization.rb
+- examples/single_driver_round_trip.rb
+- examples/single_driver_route_ten_stops.rb
+- examples/track.rb
+- lib/route4me.rb
+- lib/route4me/enum/algorithm_type.rb
+- lib/route4me/enum/avoid.rb
+- lib/route4me/enum/device_type.rb
+- lib/route4me/enum/direction_method.rb
+- lib/route4me/enum/distance_unit.rb
+- lib/route4me/enum/metric.rb
+- lib/route4me/enum/optimization_type.rb
+- lib/route4me/enum/travel_mode.rb
+- lib/route4me/errors/api_error.rb
+- lib/route4me/errors/route4me_error.rb
+- lib/route4me/optimization_problem.rb
+- lib/route4me/route.rb
+- lib/route4me/track.rb
+- lib/route4me/util.rb
+- lib/route4me/version.rb
+- route4me.gemspec
+- spec/route4me/optimization_problem_spec.rb
+- spec/route4me/route_spec.rb
+- spec/route4me/track_spec.rb
+- spec/spec_helper.rb
+homepage: http://route4me.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for the Route4me API
+test_files: []