hypertrack 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9716d695f09e507853ca9745f765191d5efeabda
+  data.tar.gz: 8a2c4b15c4770a2f9cc2952efe8b1c2cec933972
+SHA512:
+  metadata.gz: 465a675a0ce5a9e5c70110c7b1c79243b094dcdf58f9d545243ce40ea97661dfa5d7db810ac108e42910c9f42968995473edcce51e8b582b2b608036f427f34c
+  data.tar.gz: eb695184c6af67acd6e5c592660586744606d95926424acb4c3aef76c866cec9da60ede42917479a8838e5ac5047270f4605ad18356fb4bbf021fdb31e407fc2

data/lib/hypertrack.rb

@@ -0,0 +1,44 @@
+require "json"
+require 'net/https'
+
+require_relative "util"
+require_relative "hypertrack/params_validator"
+
+# Errors
+require_relative "hypertrack/errors/hypertrack_errors"
+
+# API Operations
+require_relative "hypertrack/api_operations/common/create"
+require_relative "hypertrack/api_operations/common/retrieve"
+require_relative "hypertrack/api_operations/common/list"
+require_relative "hypertrack/api_operations/common/update"
+require_relative "hypertrack/api_operations/driver_api"
+require_relative "hypertrack/api_operations/task_api"
+require_relative "hypertrack/api_operations/trip_api"
+require_relative "hypertrack/api_operations/shift_api"
+
+# All HTTP calls made here
+require_relative "hypertrack/api_client"
+
+# HyperTrack Resouce Wrapper
+require_relative "hypertrack/shared_resource"
+
+# Resources
+require_relative "hypertrack/resources/driver"
+require_relative "hypertrack/resources/customer"
+require_relative "hypertrack/resources/destination"
+require_relative "hypertrack/resources/task"
+require_relative "hypertrack/resources/trip"
+require_relative "hypertrack/resources/neighbourhood"
+require_relative "hypertrack/resources/fleet"
+require_relative "hypertrack/resources/hub"
+require_relative "hypertrack/resources/shift"
+require_relative "hypertrack/resources/event"
+
+module HyperTrack
+
+  class << self
+    attr_accessor :secret_key
+  end
+
+end

data/lib/hypertrack/api_client.rb

@@ -0,0 +1,94 @@
+module HyperTrack
+  class ApiClient
+
+    BASE_URL = "https://app.hypertrack.io/api"
+    API_VERSION = "v1"
+
+    VERB_MAP = {
+      :get  => Net::HTTP::Get,
+      :post => Net::HTTP::Post
+    }
+
+    ACCEPTED_RESPONSE_CODES = [200, 201]
+
+    class << self
+
+      def create(api_path, data={})
+        api_uri = get_uri(api_path)
+        request_object = create_request_object(api_uri, :post)
+        request_object.body = data.to_json
+        make_request(api_uri, request_object)
+      end
+      alias_method :update, :create
+
+      def fetch(api_path, query_params={})
+        api_path = path_with_params(api_path, query_params) if query_params.is_a?(Hash) && query_params.keys.length > 0
+        api_uri = get_uri(api_path)
+        request_object = create_request_object(api_uri, :get)
+        make_request(api_uri, request_object)
+      end
+
+      private
+
+      def path_with_params(path, params)
+        encoded_params = URI.encode_www_form(params)
+        [path, encoded_params].join("?")
+      end
+
+      def get_auth_header
+        if Util.blank?(HyperTrack.secret_key)
+          raise HyperTrack::InvalidAPIKey.new("HyperTrack.secret_key is invalid.")
+        end
+
+        { "Authorization" => "token #{HyperTrack.secret_key}" }
+      end
+
+      def get_uri(path)
+        url = "#{BASE_URL}/#{API_VERSION}/#{path}"
+        URI.parse(url)
+      end
+
+      def create_request_object(api_uri, http_method)
+        if VERB_MAP[http_method].nil?
+          raise HyperTrack::MethodNotAllowed.new("Unsupported HTTP verb used - Only #{VERB_MAP.keys.map{ |x| x.to_s.upcase }} allowed")
+        end
+
+        header = get_auth_header
+        request_object = VERB_MAP[http_method].new(api_uri.path, header)
+        request_object['Content-Type'] = 'application/json'
+        request_object
+      end
+
+      # To-Do: Add a timeout
+      def make_request(api_uri, request_object)
+        conn = Net::HTTP.new api_uri.host, api_uri.port
+        conn.use_ssl = api_uri.scheme == 'https'
+        conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        conn.cert_store = OpenSSL::X509::Store.new
+        conn.cert_store.set_default_paths
+        parse_response(conn.request(request_object))
+      end
+
+      def parse_response(response)
+        response_code = response.code.to_i
+
+        if valid_response_code?(response_code)
+          begin
+            JSON.parse(response.body)
+          rescue JSON::ParserError => e
+            raise HyperTrack::InvalidJSONResponse(response.body)
+          end
+        else
+          error_klass = HyperTrack::Error.defined_codes[response_code] || HyperTrack::UnknownError
+          raise error_klass.new(response.body, response_code)
+        end
+      end
+
+      def valid_response_code?(code)
+        ACCEPTED_RESPONSE_CODES.include?(code)
+      end
+
+    end
+
+  end
+end

data/lib/hypertrack/api_operations/common/create.rb

@@ -0,0 +1,16 @@
+module HyperTrack
+  module ApiOperations
+    module Common
+      module Create
+
+        def create(params={})
+          if HyperTrack::ParamsValidator.valid_args?(params, get_class_name::REQUIRED_FIELDS, get_class_name::VALID_ATTRIBUTE_VALUES)
+            result = HyperTrack::ApiClient.create(get_class_name::API_BASE_PATH, params)
+            get_class_name.new(result['id'], result)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/hypertrack/api_operations/common/list.rb

@@ -0,0 +1,19 @@
+module HyperTrack
+  module ApiOperations
+    module Common
+      module List
+
+        def list(filter_params={})
+          api_result = HyperTrack::ApiClient.fetch(get_class_name::API_BASE_PATH, filter_params)
+
+          api_result['results'].each_with_index do |opts, idx|
+            api_result['results'][idx] = get_class_name.new(opts['id'], opts)
+          end
+
+          api_result
+        end
+
+      end
+    end
+  end
+end

data/lib/hypertrack/api_operations/common/retrieve.rb

@@ -0,0 +1,24 @@
+module HyperTrack
+  module ApiOperations
+    module Common
+      module Retrieve
+
+        def retrieve(id)
+          raise HyperTrack::InvalidParameters.new("ID is required to retrieve a #{self.name}") unless valid_retrieve_id?(id)
+
+          retrieve_customer_path = "#{get_class_name::API_BASE_PATH}#{id}/"
+          result = HyperTrack::ApiClient.fetch(retrieve_customer_path)
+
+          get_class_name.new(id, result)
+        end
+
+        private
+
+        def valid_retrieve_id?(id)
+          !Util.blank?(id)
+        end
+
+      end
+    end
+  end
+end

data/lib/hypertrack/api_operations/common/update.rb

@@ -0,0 +1,33 @@
+module HyperTrack
+  module ApiOperations
+    module Common
+      module Update
+
+        def update(path, params, required_params=[])
+          if HyperTrack::ParamsValidator.valid_args?(params, required_params, self.class::VALID_ATTRIBUTE_VALUES)
+            api_path = "#{self.class::API_BASE_PATH}#{self.id}/" + path
+            result = HyperTrack::ApiClient.update(api_path, params)
+            update_attributes_in_object(result)
+          end
+        end
+
+        private
+
+        def update_attributes_in_object(result)
+          result = Util.symbolize_keys(result)
+
+          self_keys = self.keys
+
+          result.each do |key, value|
+            if self_keys.include?(key) && self[key] != value
+              self[key] = value
+            end
+          end
+
+          self
+        end
+
+      end
+    end
+  end
+end

data/lib/hypertrack/api_operations/driver_api.rb

@@ -0,0 +1,25 @@
+module HyperTrack
+  module ApiOperations
+    module DriverAPI
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def map_list(filter_params={})
+          map_list_path = "#{HyperTrack::Driver::API_BASE_PATH}map_list/"
+          result = HyperTrack::ApiClient.fetch(map_list_path, filter_params)
+        end
+
+      end
+
+      def overview(filter_params={})
+        driver_overview_path = "#{HyperTrack::Driver::API_BASE_PATH}#{self.id}/overview/"
+        result = HyperTrack::ApiClient.fetch(driver_overview_path, filter_params)
+      end
+
+    end
+  end
+end

data/lib/hypertrack/api_operations/shift_api.rb

@@ -0,0 +1,13 @@
+module HyperTrack
+  module ApiOperations
+    module ShiftAPI
+
+      # Don't want to name this method as 'end'. Its a reserved keyword in Ruby.
+      def end_shift(params)
+        path = "end/"
+        self.update(path, params, [:end_location])
+      end
+
+    end
+  end
+end

data/lib/hypertrack/api_operations/task_api.rb

@@ -0,0 +1,32 @@
+module HyperTrack
+  module ApiOperations
+    module TaskAPI
+
+      def editable_url(params)
+        path = "editable_url/"
+        self.update(path, params, [:editable])
+      end
+
+      def start(params)
+        path = "start/"
+        self.update(path, params, [:start_location, :start_time])
+      end
+
+      def complete(params)
+        path = "completed/"
+        self.update(path, params, [:completion_location])
+      end
+
+      def cancel(params={})
+        path = "canceled/"
+        self.update(path, params)
+      end
+
+      def update_destination(params)
+        path = "update_destination/"
+        self.update(path, params, [:location])
+      end
+
+    end
+  end
+end

data/lib/hypertrack/api_operations/trip_api.rb

@@ -0,0 +1,43 @@
+module HyperTrack
+  module ApiOperations
+    module TripAPI
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def sending_eta(params)
+          if HyperTrack::ParamsValidator.valid_args?(params, [:driver, :destination], HyperTrack::Trip::VALID_ATTRIBUTE_VALUES)
+            eta_path = "#{HyperTrack::Trip::API_BASE_PATH}lite/"
+            result = HyperTrack::ApiClient.update(eta_path, params)
+          end
+        end
+
+      end
+
+      # Don't want to name this method as 'end'. Its a reserved keyword in Ruby.
+      def end_trip(params)
+        path = "end/"
+        self.update(path, params, [:end_location])
+      end
+
+      def add_task(params)
+        path = 'add_task/'
+        self.update(path, params, [:task_id])
+      end
+
+      def remove_task(params)
+        path = 'remove_task/'
+        self.update(path, params, [:task_id])
+      end
+
+      def change_task_order(params)
+        path = 'change_task_order/'
+        self.update(path, params, [:task_order])
+      end
+
+    end
+  end
+end

data/lib/hypertrack/errors/hypertrack_errors.rb

@@ -0,0 +1,67 @@
+module HyperTrack
+  class Error < StandardError
+
+    attr_reader :code
+
+    def self.defined_codes
+      {
+        400 => HyperTrack::InvalidParameters,
+        401 => HyperTrack::InvalidAPIKey,
+        402 => HyperTrack::NoFreeCreditsLeft,
+        403 => HyperTrack::AccessForbidden,
+        404 => HyperTrack::ResourceNotFound,
+        405 => HyperTrack::MethodNotAllowed,
+        406 => HyperTrack::FormatNotAcceptable,
+        410 => HyperTrack::ResourceRemovedFromServer,
+        429 => HyperTrack::RateLimitExceeded,
+        500 => HyperTrack::InternalServerError,
+        503 => HyperTrack::ServiceTemporarilyUnavailable
+      }
+    end
+
+    def initialize(message, code=nil)
+      @code = code
+      super(message)
+    end
+
+  end
+
+  # Raised when - Missing or invalid parameters in API call
+  class InvalidParameters < Error; end
+
+  # Raised when - Missing or invalid API key
+  class InvalidAPIKey < Error; end
+
+  # Raised when - You don't have any free credits left
+  class NoFreeCreditsLeft < Error; end
+
+  # Raised when - You don’t have permission to access the resource
+  class AccessForbidden < Error; end
+
+  # Raised when - The resource does not exist
+  class ResourceNotFound < Error; end
+
+  # Raised when - You tried to access a resource with an invalid method
+  class MethodNotAllowed < Error; end
+
+  # Raised when - You requested a format that isn’t json
+  class FormatNotAcceptable < Error; end
+
+  # Raised when - The requested resource has been removed from our servers
+  class ResourceRemovedFromServer < Error; end
+
+  # Raised when - You have hit the rate limit for your account
+  class RateLimitExceeded < Error; end
+
+  # Raised when - There was an error on the server and we have been notified. Try again later.
+  class InternalServerError < Error; end
+
+  # Raised when - We are temporarily offline for maintenance. Please try again later.
+  class ServiceTemporarilyUnavailable < Error; end
+
+  # Raised when - We get an unknown response code from the API
+  class UnknownError < Error; end
+
+  # Raised when - We get an invalid JSON in response from API
+  class InvalidJSONResponse < Error; end
+end

data/lib/hypertrack/params_validator.rb

@@ -0,0 +1,46 @@
+module HyperTrack
+  module ParamsValidator
+
+    class << self
+
+      def valid_args?(params, required_fields, valid_attr_values)
+        unless valid_params_object?(params)
+          raise HyperTrack::InvalidParameters.new("Error: Expected a Hash. Got: #{params}")
+        end
+
+        params = Util.symbolize_keys(params)
+
+        if missing_required_fields?(params, required_fields)
+          raise HyperTrack::InvalidParameters.new("Request is missing required params - #{required_fields - params.keys}")
+        end
+
+        params.each do |name, value|
+          next if Util.blank?(value) && valid_attr_values[name][:allow_nil]
+          next if valid_attr_values[name].nil? || valid_attr_values[name][:allowed].nil?
+
+          valid_values = valid_attr_values[name][:allowed]
+          if !valid_values.include?(value) && !valid_values.include?(value.to_sym)
+            raise HyperTrack::InvalidParameters.new("Error: Invalid #{name}: #{value}. Allowed: #{valid_values.join(', ')}")
+          end
+        end
+
+        true
+      end
+
+      private
+
+      def valid_params_object?(params)
+        params.is_a?(Hash)
+      end
+
+      def missing_required_fields?(params, required_fields)
+        required_fields.each do |field|
+          return true if Util.blank?(params[field])
+        end
+
+        false
+      end
+
+    end
+  end
+end

data/lib/hypertrack/resources/customer.rb

@@ -0,0 +1,10 @@
+module HyperTrack
+  class Customer < HyperTrack::SharedResource
+
+    API_BASE_PATH = "customers/"
+    REQUIRED_FIELDS = [:name]
+
+    VALID_ATTRIBUTE_VALUES = {}
+
+  end
+end

data/lib/hypertrack/resources/destination.rb

@@ -0,0 +1,10 @@
+module HyperTrack
+  class Destination < HyperTrack::SharedResource
+
+    API_BASE_PATH = "destinations/"
+    REQUIRED_FIELDS = [:customer_id]
+
+    VALID_ATTRIBUTE_VALUES = {}
+
+  end
+end

data/lib/hypertrack/resources/driver.rb

@@ -0,0 +1,15 @@
+module HyperTrack
+  class Driver < HyperTrack::SharedResource
+    include HyperTrack::ApiOperations::DriverAPI
+
+    API_BASE_PATH = "drivers/"
+    REQUIRED_FIELDS = [:name, :vehicle_type]
+
+    VALID_ATTRIBUTE_VALUES = {
+      vehicle_type: {
+        allowed: HyperTrack::SharedResource::VALID_VEHICLE_TYPES
+      }
+    }
+
+  end
+end

data/lib/hypertrack/resources/event.rb

@@ -0,0 +1,14 @@
+module HyperTrack
+  class Event < HyperTrack::SharedResource
+
+    API_BASE_PATH = "events/"
+    REQUIRED_FIELDS = []
+
+    VALID_ATTRIBUTE_VALUES = {}
+
+    def self.create(params={})
+      raise HyperTrack::MethodNotAllowed.new("Create not allowed on HyperTrack::Event class")
+    end
+
+  end
+end

data/lib/hypertrack/resources/fleet.rb

@@ -0,0 +1,10 @@
+module HyperTrack
+  class Fleet < HyperTrack::SharedResource
+
+    API_BASE_PATH = "fleets/"
+    REQUIRED_FIELDS = [:name]
+
+    VALID_ATTRIBUTE_VALUES = {}
+
+  end
+end

data/lib/hypertrack/resources/hub.rb

@@ -0,0 +1,10 @@
+module HyperTrack
+  class Hub < HyperTrack::SharedResource
+
+    API_BASE_PATH = "hubs/"
+    REQUIRED_FIELDS = [:name]
+
+    VALID_ATTRIBUTE_VALUES = {}
+
+  end
+end

data/lib/hypertrack/resources/neighbourhood.rb

@@ -0,0 +1,14 @@
+module HyperTrack
+  class Neighbourhood < HyperTrack::SharedResource
+
+    API_BASE_PATH = "neighborhoods/"
+    REQUIRED_FIELDS = []
+
+    VALID_ATTRIBUTE_VALUES = {}
+
+    def self.create(params={})
+      raise HyperTrack::MethodNotAllowed.new("Create not allowed on HyperTrack::Neighbourhood class")
+    end
+
+  end
+end

data/lib/hypertrack/resources/shift.rb

@@ -0,0 +1,11 @@
+module HyperTrack
+  class Shift < HyperTrack::SharedResource
+    include HyperTrack::ApiOperations::ShiftAPI
+
+    API_BASE_PATH = "shifts/"
+    REQUIRED_FIELDS = [:driver_id, :start_location]
+
+    VALID_ATTRIBUTE_VALUES = {}
+
+  end
+end

data/lib/hypertrack/resources/task.rb

@@ -0,0 +1,22 @@
+module HyperTrack
+  class Task < HyperTrack::SharedResource
+    include HyperTrack::ApiOperations::TaskAPI
+
+    API_BASE_PATH = "tasks/"
+    REQUIRED_FIELDS = []
+
+    VALID_ATTRIBUTE_VALUES = {
+      action: {
+        allowed: [:pickup, :delivery, :visit, :task],
+        allow_nil: true
+      },
+      editable: {
+        allowed: [:'not editable', :once, :multiple]
+      },
+      vehicle_type: {
+        allowed: HyperTrack::SharedResource::VALID_VEHICLE_TYPES
+      }
+    }
+
+  end
+end

data/lib/hypertrack/resources/trip.rb

@@ -0,0 +1,15 @@
+module HyperTrack
+  class Trip < HyperTrack::SharedResource
+    include HyperTrack::ApiOperations::TripAPI
+
+    API_BASE_PATH = "trips/"
+    REQUIRED_FIELDS = [:driver_id, :start_location, :tasks]
+
+    VALID_ATTRIBUTE_VALUES = {
+      vehicle_type: {
+        allowed: HyperTrack::SharedResource::VALID_VEHICLE_TYPES
+      }
+    }
+
+  end
+end

data/lib/hypertrack/shared_resource.rb

@@ -0,0 +1,63 @@
+module HyperTrack
+  class SharedResource
+    extend HyperTrack::ApiOperations::Common::Create
+    extend HyperTrack::ApiOperations::Common::Retrieve
+    extend HyperTrack::ApiOperations::Common::List
+    include HyperTrack::ApiOperations::Common::Update
+
+    VALID_VEHICLE_TYPES = [:walking, :bicycle, :motorcycle, :car, :'3-wheeler', :van] #[:flight, :train, :ship]
+
+    attr_accessor :id
+
+    def initialize(id, opts)
+      @id = id
+      @values = Util.symbolize_keys(opts)
+    end
+
+    def [](k)
+      @values[k.to_sym]
+    end
+
+    def []=(k, v)
+      @values[k.to_sym] = v
+    end
+
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*a)
+      JSON.generate(@values)
+    end
+
+    protected
+
+    def method_missing(name, *args)
+      if name[-1] == "="
+        name = name[0..-2]
+
+        if @values.has_key?(name.to_sym)
+          self[name.to_sym] = args[0]
+          return
+        end
+
+      elsif @values.has_key?(name.to_sym)
+        return @values[name.to_sym]
+      end
+
+      super
+    end
+
+    private
+
+    def self.get_class_name
+      # To-Do: Umm.. Find some better approach
+      Object.const_get(self.name)
+    end
+
+  end
+end

data/lib/util.rb

@@ -0,0 +1,15 @@
+class Util
+
+  class << self
+
+    def symbolize_keys(hash)
+      hash.inject({}){ |memo, (k, v)| memo[k.to_sym] = v; memo }
+    end
+
+    def blank?(value)
+      value.nil? || value.to_s.length.zero?
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: hypertrack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Utsav Kesharwani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Ruby wrapper around HyperTrack's API. Refer http://docs.hypertrack.io/
+  for more information.
+email: utsav.kesharwani@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hypertrack.rb
+- lib/hypertrack/api_client.rb
+- lib/hypertrack/api_operations/common/create.rb
+- lib/hypertrack/api_operations/common/list.rb
+- lib/hypertrack/api_operations/common/retrieve.rb
+- lib/hypertrack/api_operations/common/update.rb
+- lib/hypertrack/api_operations/driver_api.rb
+- lib/hypertrack/api_operations/shift_api.rb
+- lib/hypertrack/api_operations/task_api.rb
+- lib/hypertrack/api_operations/trip_api.rb
+- lib/hypertrack/errors/hypertrack_errors.rb
+- lib/hypertrack/params_validator.rb
+- lib/hypertrack/resources/customer.rb
+- lib/hypertrack/resources/destination.rb
+- lib/hypertrack/resources/driver.rb
+- lib/hypertrack/resources/event.rb
+- lib/hypertrack/resources/fleet.rb
+- lib/hypertrack/resources/hub.rb
+- lib/hypertrack/resources/neighbourhood.rb
+- lib/hypertrack/resources/shift.rb
+- lib/hypertrack/resources/task.rb
+- lib/hypertrack/resources/trip.rb
+- lib/hypertrack/shared_resource.rb
+- lib/util.rb
+homepage: http://rubygems.org/gems/hypertrack
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for the HyperTrack API!
+test_files: []