my_john_deere_api 2.4.1

data/lib/my_john_deere_api/helpers/case_conversion.rb

@@ -0,0 +1,37 @@
+require 'uri'
+
+module MyJohnDeereApi::Helpers::CaseConversion
+  private
+
+  ##
+  # convert a text or camelcase string to underscore
+
+  def underscore(something)
+    something = something.to_s if something.is_a?(Symbol)
+
+    if something.is_a?(String)
+      something.gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/\s+/, '_').gsub(/_+/, '_').downcase
+    elsif something.is_a?(Hash)
+      something.transform_keys{ |key| underscore(key) }
+    end
+  end
+
+  ##
+  # convert text or underscored string to camelcase
+
+  def camelize(something)
+    something = something.to_s if something.is_a?(Symbol)
+
+    if something.is_a?(String)
+      list = something.strip.split(/[_\s]+/)
+
+      # preserve case of the first element
+      new_list = [list.shift]
+      new_list += list.map(&:capitalize)
+
+      new_list.join('')
+    elsif something.is_a?(Hash)
+      something.transform_keys{ |key| camelize(key) }
+    end
+  end
+end

data/lib/my_john_deere_api/helpers/environment_helper.rb

@@ -0,0 +1,25 @@
+require 'uri'
+
+module MyJohnDeereApi
+  module Helpers::EnvironmentHelper
+    attr_reader :environment
+
+    private
+
+    ##
+    # Intelligently set the environment
+
+    def environment=(value)
+      value = (value || :live).to_sym
+
+      @environment = case value
+      when :sandbox, :live
+        value
+      when :production
+        :live
+      else
+        raise UnsupportedEnvironmentError, value
+      end
+    end
+  end
+end

data/lib/my_john_deere_api/helpers/uri_helpers.rb

@@ -0,0 +1,19 @@
+require 'uri'
+
+module MyJohnDeereApi::Helpers::UriHelpers
+  private
+
+  ##
+  # extract just the path from the uri, excluding the platform prefix
+  def uri_path(uri)
+    URI.parse(uri).path.gsub(/^\/platform/, '')
+  end
+
+  ##
+  # infer id from uri
+
+  def id_from_uri(uri, label)
+    parts = uri.split('/')
+    parts[parts.index(label.to_s) + 1]
+  end
+end

data/lib/my_john_deere_api/helpers/validate_contribution_definition.rb

@@ -0,0 +1,18 @@
+require 'uri'
+
+module MyJohnDeereApi
+  module Helpers::ValidateContributionDefinition
+    private
+
+    ##
+    # Raise an error if contribution_definition_id is missing
+
+    def validate_contribution_definition
+      if client.contribution_definition_id.nil?
+        raise MissingContributionDefinitionIdError
+      end
+
+      true
+    end
+  end
+end

data/lib/my_john_deere_api/model.rb

@@ -0,0 +1,10 @@
+module MyJohnDeereApi::Model
+  autoload :Base,                     'my_john_deere_api/model/base'
+  autoload :Asset,                    'my_john_deere_api/model/asset'
+  autoload :AssetLocation,            'my_john_deere_api/model/asset_location'
+  autoload :ContributionProduct,      'my_john_deere_api/model/contribution_product'
+  autoload :ContributionDefinition,   'my_john_deere_api/model/contribution_definition'
+  autoload :Organization,             'my_john_deere_api/model/organization'
+  autoload :Field,                    'my_john_deere_api/model/field'
+  autoload :Flag,                     'my_john_deere_api/model/flag'
+end

data/lib/my_john_deere_api/model/asset.rb

@@ -0,0 +1,69 @@
+module MyJohnDeereApi
+  class Model::Asset < Model::Base
+    include Helpers::CaseConversion
+
+    attr_reader :title, :asset_category, :asset_type, :asset_sub_type, :last_modified_date
+
+    ##
+    # A listing of attributes that can be passed back to John Deere
+
+    def attributes
+      {
+        id: id,
+        title: title,
+        asset_category: asset_category,
+        asset_type: asset_type,
+        asset_sub_type: asset_sub_type,
+        organization_id: 'placeholder'
+      }
+    end
+
+    ##
+    # Change the title, locally
+
+    def title=(value)
+      mark_as_unsaved
+      @title = value
+    end
+
+    ##
+    # Save any attribute changes to John Deere
+
+    def save
+      if unsaved?
+        mark_as_saved
+        Request::Update::Asset.new(client, self, attributes).request
+      end
+    end
+
+    ##
+    # Update the attributes in John Deere
+
+    def update new_attributes
+      map_attributes(camelize(new_attributes))
+      Request::Update::Asset.new(client, self, attributes).request
+    end
+
+    ##
+    # locations associated with this asset
+
+    def locations
+      return @locations if defined?(@locations)
+      @locations = Request::Collection::AssetLocations.new(client, asset: id)
+    end
+
+    private
+
+    def map_attributes(record)
+      @title = record['title'] if record['title']
+      @asset_category = record['assetCategory'] if record['assetCategory']
+      @asset_type = record['assetType'] if record['assetType']
+      @asset_sub_type = record['assetSubType'] if record['assetSubType']
+      @last_modified_date = record['lastModifiedDate'] if record['lastModifiedDate']
+    end
+
+    def expected_record_type
+      'ContributedAsset'
+    end
+  end
+end

data/lib/my_john_deere_api/model/asset_location.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module MyJohnDeereApi
+  class Model::AssetLocation < Model::Base
+    attr_reader :timestamp, :geometry, :measurement_data
+
+    private
+
+    def map_attributes(record)
+      @timestamp = record['timestamp']
+      @geometry = JSON.parse(record['geometry'])
+      @measurement_data = record['measurementData']
+    end
+
+    def expected_record_type
+      'ContributedAssetLocation'
+    end
+  end
+end

data/lib/my_john_deere_api/model/base.rb

@@ -0,0 +1,97 @@
+module MyJohnDeereApi
+  class Model::Base
+    include Helpers::CaseConversion
+    include Helpers::UriHelpers
+
+    attr_reader :id, :record_type, :client, :links
+
+    ##
+    # arguments:
+    #
+    # [client] the client, because it contains all the config info.
+    #          The alternative would be a true Config block, but then
+    #          settings would be app-wide. This allows one app to have
+    #          multiple clients with different settings.
+    #
+    # [record] a JSON object of type 'Field', returned from the API.
+
+    def initialize(client, record)
+      verify_record_type(record['@type'])
+
+      @id = record['id']
+      @record_type = record['@type']
+      @client = client
+      @unsaved = false
+
+      map_attributes(record)
+
+      @links = {}
+
+      record['links'].each do |association|
+        @links[underscore(association['rel'])] = uri_path(association['uri'])
+      end
+    end
+
+    ##
+    # The client accessor
+
+    def accessor
+      return @accessor if defined?(@accessor)
+      @accessor = client&.accessor
+    end
+
+    private
+
+    ##
+    # This method receives the full record hash and extracts whatever extra
+    # attributes are needed for the given base class. This is intended to
+    # be overridden by child classes instead of monkeypatching #initialize.
+
+    def map_attributes(record)
+
+    end
+
+    ##
+    # Expected record type. Override in child classes.
+
+    def expected_record_type
+      'Base'
+    end
+
+    ##
+    # Raise an error if this is not the type of record we expect to receive
+
+    def verify_record_type(type)
+      unless type == expected_record_type
+        raise TypeMismatchError, "Expected record of type '#{expected_record_type}', but received type '#{type}'"
+      end
+    end
+
+    ##
+    # Mark as unsaved, so we know to save it later
+
+    def mark_as_unsaved
+      @unsaved = true
+    end
+
+    ##
+    # Mark as saved, so we don't try to save it later
+
+    def mark_as_saved
+      @unsaved = false
+    end
+
+    ##
+    # Are changes to this model synced with JD?
+    def saved?
+      !@unsaved
+    end
+
+    ##
+    # Are there pending changes to send to JD?
+
+    def unsaved?
+      @unsaved
+    end
+  end
+end

data/lib/my_john_deere_api/model/contribution_definition.rb

@@ -0,0 +1,15 @@
+module MyJohnDeereApi
+  class Model::ContributionDefinition < Model::Base
+    attr_reader :name
+
+    private
+
+    def map_attributes(record)
+      @name     = record['name']
+    end
+
+    def expected_record_type
+      'ContributionDefinition'
+    end
+  end
+end

data/lib/my_john_deere_api/model/contribution_product.rb

@@ -0,0 +1,33 @@
+module MyJohnDeereApi
+  class Model::ContributionProduct < Model::Base
+    attr_reader :market_place_name, :market_place_description, :default_locale,
+                :current_status, :activation_callback, :preview_images,
+                :supported_regions, :supported_operation_centers
+
+
+    ##
+    # contribution definitions associated with this contribution product
+
+    def contribution_definitions
+      return @contribution_definitions if defined?(@contribution_definitions)
+      @contribution_definitions = Request::Collection::ContributionDefinitions.new(client, contribution_product: id)
+    end
+
+    private
+
+    def map_attributes(record)
+      @market_place_name =            record['marketPlaceName']
+      @market_place_description =     record['marketPlaceDescription']
+      @default_locale =               record['defaultLocale']
+      @current_status =               record['currentStatus']
+      @activation_callback =          record['activationCallback']
+      @preview_images =               record['previewImages']
+      @supported_regions =            record['supportedRegions']
+      @supported_operation_centers =  record['supportedOperationCenters']
+    end
+
+    def expected_record_type
+      'ContributionProduct'
+    end
+  end
+end

data/lib/my_john_deere_api/model/field.rb

@@ -0,0 +1,40 @@
+module MyJohnDeereApi
+  class Model::Field < Model::Base
+    attr_reader :name
+
+    ##
+    # Since the archived attribute is boolean, we reflect this in the
+    # method name instead of using a standard attr_reader.
+
+    def archived?
+      @archived
+    end
+
+    ##
+    # flags associated with this organization
+
+    def flags
+      return @flags if defined?(@flags)
+      @flags = Request::Collection::Flags.new(client, organization: organization_id, field: id)
+    end
+
+    private
+
+    def map_attributes(record)
+      @name = record['name']
+      @archived = record['archived']
+    end
+
+    def expected_record_type
+      'Field'
+    end
+
+    ##
+    # Infer the organization_id from the 'self' link
+
+    def organization_id
+      return @organization_id if defined?(@organization_id)
+      @organization_id = id_from_uri(links['self'], :organizations)
+    end
+  end
+end

data/lib/my_john_deere_api/model/flag.rb

@@ -0,0 +1,36 @@
+require 'json'
+
+module MyJohnDeereApi
+  class Model::Flag < Model::Base
+    attr_reader :notes, :geometry
+
+    ##
+    # Since the archived attribute is boolean, we reflect this in the
+    # method name instead of using a standard attr_reader.
+
+    def archived?
+      @archived
+    end
+
+    ##
+    # Since the proximity_alert_enabled attribute is boolean, we reflect this
+    # in the method name instead of using a standard attr_reader.
+
+    def proximity_alert_enabled?
+      @proximity_alert_enabled
+    end
+
+    private
+
+    def map_attributes(record)
+      @notes = record['notes']
+      @geometry =JSON.parse(record['geometry'])
+      @proximity_alert_enabled = record['proximityAlertEnabled']
+      @archived = record['archived']
+    end
+
+    def expected_record_type
+      'Flag'
+    end
+  end
+end

data/lib/my_john_deere_api/model/organization.rb

@@ -0,0 +1,43 @@
+require 'uri'
+
+module MyJohnDeereApi
+  class Model::Organization < Model::Base
+    attr_reader :name, :type
+
+    ##
+    # Since the member attribute is boolean, we reflect this in the
+    # method name instead of using a standard attr_reader.
+
+    def member?
+      @member
+    end
+
+    ##
+    # fields associated with this organization
+
+    def fields
+      return @fields if defined?(@fields)
+      @fields = MyJohnDeereApi::Request::Collection::Fields.new(client, organization: id)
+    end
+
+    ##
+    # assets associated with this organization
+
+    def assets
+      return @assets if defined?(@assets)
+      @assets = MyJohnDeereApi::Request::Collection::Assets.new(client, organization: id)
+    end
+
+    private
+
+    def map_attributes(record)
+      @name = record['name']
+      @type = record['type']
+      @member = record['member']
+    end
+
+    def expected_record_type
+      'Organization'
+    end
+  end
+end