myjohndeere 0.0.1

data/lib/myjohndeere/api_support_item.rb

@@ -0,0 +1,27 @@
+module MyJohnDeere
+  class APISupportItem
+    include JSONAttributes
+    # see attributes_to_pull_from_json for the order if creating yourself
+    def initialize(args)
+      if args.length == 1 then
+        # assume the json object was passed
+        setup_attributes(args[0])
+      else
+        # otherwise assume normal construction according to the order for the json attributes 
+        self.class.json_attributes.each_with_index do |attribute, i|
+          underscored = attribute.to_s.underscore
+          raise ArgumentError("You must pass #{attribute} as argument #{i+1}") if self.class.json_attributes.length <= i 
+          self.send("#{underscored}=", args[i])
+        end
+      end
+    end
+
+    def to_hash()
+      ret_hash = {}
+      self.class.json_attributes.each do |attrib|
+        ret_hash[attrib] = self.send(attrib.to_s.underscore)
+      end
+      return ret_hash
+    end
+  end
+end

data/lib/myjohndeere/boundary.rb

@@ -0,0 +1,18 @@
+module MyJohnDeere
+  class Boundary < OrganizationOwnedResource
+    self.base_jd_resource = "boundaries"
+    self.list_resource_path = "organizations/%{organization_id}/fields/%{field_id}/#{self.base_jd_resource}"
+    self.retrieve_resource_path = "organizations/%{organization_id}/#{self.base_jd_resource}"
+    attributes_to_pull_from_json(:id, :name, :multipolygons, :active)
+    attr_accessor :field_id
+
+    def initialize(json_object, access_token = nil, field_id = nil)
+      super(json_object, access_token)
+      self.field_id = field_id
+      self.active = self.active.to_s.downcase == "true"
+      self.multipolygons = json_object["multipolygons"]
+      # This doesn't exist currently, not sure why
+      self.field_id ||= extract_link_with_rel_from_list("fields", /\/(\d+)\/(.+?)\/fields\Z/)
+    end
+  end
+end

data/lib/myjohndeere/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/myjohndeere/errors.rb

@@ -0,0 +1,10 @@
+module MyJohnDeere
+  # MyJohnDeereError is the base error from which all other more specific MyJohnError
+  # errors derive.
+  class MyJohnDeereError < StandardError
+  end
+
+  # Configuration error is raised when configuration hasn't been properly done
+  class ConfigurationError < MyJohnDeereError
+  end
+end

data/lib/myjohndeere/field.rb

@@ -0,0 +1,28 @@
+module MyJohnDeere
+  class Field < OrganizationOwnedResource
+    self.base_jd_resource = "fields"
+    self.list_resource_path = "organizations/%{organization_id}/#{self.base_jd_resource}"
+    self.retrieve_resource_path = "organizations/%{organization_id}/#{self.base_jd_resource}"
+    attributes_to_pull_from_json(:id, :name, :boundaries)
+
+    def initialize(json_object, access_token = nil)
+      super(json_object, access_token)
+      boundaries = json_object["boundaries"]
+      if boundaries && boundaries.length > 0 then
+        # If we embed, then we'll need to pass our id
+        self.boundary = Boundary.new(boundaries[0], access_token, self.id)
+      end
+    end
+
+    def boundary
+      if @boundary.nil? then
+        @boundary = Boundary.retrieve(self.access_token, field_id: self.id, organization_id: self.organization_id)
+      end
+      return @boundary
+    end
+
+    def boundary=(val)
+      @boundary = val
+    end
+  end
+end

data/lib/myjohndeere/file_resource.rb

@@ -0,0 +1,61 @@
+module MyJohnDeere
+  class FileResource < OrganizationOwnedResource
+    self.base_jd_resource = "fileResources"
+    self.list_resource_path = "mapLayers/%{map_layer_id}/#{self.base_jd_resource}"
+    self.retrieve_resource_path = self.base_jd_resource
+    attributes_to_pull_from_json(:id, :filename, :mimeType, :metadata, :timestamp)
+
+    def initialize(json_object, access_token = nil)
+      super(json_object, access_token)
+    end
+
+    def self.create(access_token, organization_id, map_layer_id, file_type: nil,
+        metadata: [])
+      raise ArgumentError.new("You must pass a file_type") if file_type.nil?
+
+      case file_type
+      when :png
+        mime_type = 'image/png'
+      when :zip
+        mime_type = 'application/zip'
+      else
+        raise ArgumentError.new("You must specify either a zip or a png")
+      end
+
+      body = {
+        links: [
+            self.owning_organization_link_item(organization_id)
+        ],
+        mimeType: mime_type,
+        metadata: metadata.map { |m| m.to_hash }
+      }
+      
+      response = access_token.execute_request(:post, 
+        build_resouce_base_path!(self.list_resource_path, {map_layer_id: map_layer_id}),
+        body: body
+      )
+      #{"Content-Type"=>"text/plain", "X-Deere-Handling-Server"=>"ldxtc3", "X-Frame-Options"=>"SAMEORIGIN", "Location"=>"https://sandboxapi.deere.com/platform/mapLayers/e2711205-c5df-445e-aad5-81eaf9090e6c", "X-Deere-Elapsed-Ms"=>"162", "Vary"=>"Accept-Encoding", "Expires"=>"Thu, 14 Sep 2017 15:52:24 GMT", "Cache-Control"=>"max-age=0, no-cache", "Pragma"=>"no-cache", "Date"=>"Thu, 14 Sep 2017 15:52:24 GMT", "Transfer-Encoding"=>"chunked", "Connection"=>"close, Transfer-Encoding"}
+      id = get_created_id_from_response_headers(self.base_jd_resource, response)
+      if id.nil? then
+        return nil
+      else
+        return self.new(HashUtils.deep_stringify_keys({"id" => id}.merge(body)))
+      end
+    end
+
+    def self.upload_file(access_token, file_resource_id, file_path)
+      File.open(file_path, "rb:UTF-8") do |f|
+          body = f.read()
+          response = access_token.execute_request(:put,
+            "#{self.base_jd_resource}/#{file_resource_id}",
+            body: body,
+            headers: { 
+              'accept'=> 'application/vnd.deere.axiom.v3+json',
+              "Content-Type"=>'application/octet-stream' ,
+              "Content-Length" => body.bytesize.to_s
+            })
+          return response.code == 204
+      end
+    end
+  end
+end

data/lib/myjohndeere/hash_utils.rb

@@ -0,0 +1,33 @@
+module MyJohnDeere
+  class HashUtils
+    def self.transform_hash(original, options={}, &block)
+      original.inject({}){|result, (key,value)|
+        value = if (options[:deep] && Hash === value) 
+                  transform_hash(value, options, &block)
+                else 
+                  if Array === value
+                    value.map{|v| transform_hash(v, options, &block)}
+                  else
+                    value
+                  end
+                end
+        block.call(result,key,value)
+        result
+      }
+    end
+
+    # Convert keys to strings
+    def self.stringify_keys(in_hash)
+      transform_hash(in_hash) {|hash, key, value|
+        hash[key.to_s] = value
+      }
+    end
+
+    # Convert keys to strings, recursively
+    def self.deep_stringify_keys(in_hash)
+      transform_hash(in_hash, :deep => true) {|hash, key, value|
+        hash[key.to_s] = value
+      }
+    end
+  end
+end

data/lib/myjohndeere/json_attributes.rb

@@ -0,0 +1,39 @@
+module MyJohnDeere 
+  module JSONAttributes
+    module ClassMethods
+      attr_accessor :json_attributes
+      def attributes_to_pull_from_json(*attribs)
+        self.json_attributes = attribs
+        self.json_attributes.each do |attribute|
+          attribute = attribute.to_s.underscore
+          define_method("#{attribute}=") do |val|
+            instance_variable_set("@#{attribute}", val)
+          end
+          define_method(attribute) do
+            return instance_variable_get("@#{attribute}")
+          end    
+        end
+      end
+    end
+    
+    module InstanceMethods
+      def setup_attributes(json_data)
+        return if self.class.json_attributes.nil?
+        self.class.json_attributes.each do |attrib|
+          attrib = attrib.to_s
+          val = json_data[attrib]
+          if /(date)|(timestamp)/i.match(attrib) then
+            # try to parse it
+            val = Time.parse(val) rescue val
+          end
+          instance_variable_set("@#{attrib.underscore}", val)
+        end
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/myjohndeere/list_object.rb

@@ -0,0 +1,94 @@
+module MyJohnDeere
+  class ListObject < Requestable
+    OPTION_ATTRIBUTES = [:count, :start, :etag]
+    attr_reader :data, :listable, :total, :options
+    include Enumerable
+
+    OPTION_ATTRIBUTES.each do |attribute|
+      define_method("#{attribute}=") do |val|
+        options[attribute] = val
+      end
+      define_method(attribute) do
+        return options[attribute]
+      end    
+    end
+
+    def initialize(listable, access_token, json_data,
+      options: {})
+      @options = options
+      # Confirm object is listable? 
+      @listable = listable
+      @data = json_data["values"].collect { |i| listable.new(i, access_token) }
+      if self.using_etag?
+        MyJohnDeere.logger.info("Using etag, ignoring any specification about start/count")
+        self.start = 0
+        self.count = @data.length
+      else
+        MyJohnDeere.logger.info("Etag omitted using start/count")
+        self.start ||= 0
+        self.count ||= 10
+      end
+      # Total is the total record count as specified by the john deere response
+      @total = json_data["total"] || data.length
+      super(json_data, access_token)
+    end
+
+    def each(&blk)
+      self.data.each(&blk)
+    end
+
+    def next_page!()
+      return if !self.has_more?()
+      new_list = @listable.list(self.access_token, 
+        count: self.count, 
+        start: self.start + self.count,
+        etag: self.etag)
+      new_list.instance_variables.each do |iv|
+        self.instance_variable_set(iv, new_list.instance_variable_get(iv))
+      end
+    end
+
+    def has_more?()
+      return !self.using_etag? && self.start + self.data.length < self.total
+    end
+
+    def using_etag?
+      # will be equal "" or some other string
+      return !self.etag.nil?
+    end
+  end
+end
+  # def iterate_through_john_deere_resource(john_deere_resource_path, options={})
+  #   options = {
+  #     headers: nil,
+  #     body: ""
+  #     }.merge(options)
+  #   loop do
+  #     response = self.request_against_access_token(:get, john_deere_resource_path, options)
+
+  #     case response.code.to_s
+  #     when "304" # Not modified, the headers won't change either
+  #       logger.info("JohnDeere iteration not modified: #{john_deere_resource_path}")
+  #       break
+  #     when "200" # Success
+  #       # now make the json and yield it to the block
+  #       response_json = JSON.parse(response.body)
+
+  #       yield(response_json, response.to_hash)
+
+  #       # see if we have another page, will either be nil or the hash, which will have ["uri"]
+  #       next_uri = response_json["links"].find { |link| link["rel"] == "nextPage" }
+  #       full_resource_uri = next_uri.try(:[], "uri")
+  #       break if full_resource_uri.nil?
+
+  #       # convert it to a regular path so we don't have to mess with the 
+  #       # full route
+  #       john_deere_resource_path = URI.parse(full_resource_uri).path
+
+  #       # one final check
+  #       break if john_deere_resource_path.nil?
+  #     else
+  #       break
+  #     end
+  #   end
+  # end

data/lib/myjohndeere/map_layer.rb

@@ -0,0 +1,41 @@
+module MyJohnDeere
+  class MapLayer < OrganizationOwnedResource
+    self.base_jd_resource = "mapLayers"
+    self.list_resource_path = "mapLayerSummaries/%{map_layer_summary_id}/#{self.base_jd_resource}"
+    self.retrieve_resource_path = self.base_jd_resource
+    attributes_to_pull_from_json(:id, :title, :extent, :legends)
+
+    def initialize(json_object, access_token = nil)
+      super(json_object, access_token)
+      self.legends["ranges"].map! { |l| MapLegendItem.new(l) }
+    end
+
+    def self.create(access_token, map_layer_summary_id, organization_id,
+        title: "", minimum_latitude: 0, maximum_latitude: 0, 
+        minimum_longitude: 0, maximum_longitude:0, map_layer_id: "", map_legend_items: [])
+      body = {
+        links: [
+          self.owning_organization_link_item(organization_id)
+        ],
+        title: "The title on the map layer",
+        extent: {
+          minimumLatitude: minimum_latitude,
+          maximumLatitude: maximum_latitude,
+          minimumLongitude: minimum_longitude,
+          maximumLongitude: maximum_longitude
+        },
+        legends: {
+           unitId: map_layer_id,
+           ranges: map_legend_items.map { |mls| mls.to_hash }
+        }
+      }
+
+      response = access_token.execute_request(:post, 
+        build_resouce_base_path!(self.list_resource_path, {map_layer_summary_id: map_layer_summary_id}),
+        body: body
+      )
+      #{"Content-Type"=>"text/plain", "X-Deere-Handling-Server"=>"ldxtc3", "X-Frame-Options"=>"SAMEORIGIN", "Location"=>"https://sandboxapi.deere.com/platform/mapLayers/e2711205-c5df-445e-aad5-81eaf9090e6c", "X-Deere-Elapsed-Ms"=>"162", "Vary"=>"Accept-Encoding", "Expires"=>"Thu, 14 Sep 2017 15:52:24 GMT", "Cache-Control"=>"max-age=0, no-cache", "Pragma"=>"no-cache", "Date"=>"Thu, 14 Sep 2017 15:52:24 GMT", "Transfer-Encoding"=>"chunked", "Connection"=>"close, Transfer-Encoding"}
+      return get_created_id_from_response_headers(self.base_jd_resource, response)
+    end
+  end
+end

data/lib/myjohndeere/map_layer_summary.rb

@@ -0,0 +1,40 @@
+module MyJohnDeere
+  class MapLayerSummary < OrganizationOwnedResource
+    self.base_jd_resource = "mapLayerSummaries"
+    self.list_resource_path = "organizations/%{organization_id}/fields/%{field_id}/#{self.base_jd_resource}"
+    self.retrieve_resource_path = self.base_jd_resource
+    attributes_to_pull_from_json(:id, :title, :text, :metadata, :dateCreated, :lastModifiedDate)
+
+    def initialize(json_object, access_token = nil)
+      super(json_object, access_token)
+    end
+
+    def self.create(access_token, organization_id, field_id, 
+        title, caption, metadata = [], date_created=nil)
+      body = {
+        title: title,
+        text: caption,
+        links: [
+            owning_organization_link_item(organization_id),
+            {
+               rel: "contributionDefinition",
+               uri: "#{MyJohnDeere.configuration.endpoint}/#{MyJohnDeere.configuration.contribution_definition_id}"
+            }
+         ],
+        metadata: metadata.map { |md| md.to_hash },
+        dateCreated: (date_created || Time.now).strftime("%Y-%m-%dT%H:%M:%S.%LZ")
+      }
+      response = access_token.execute_request(:post, 
+        build_resouce_base_path!(self.list_resource_path, {field_id: field_id, organization_id: organization_id}),
+        body: body
+      )
+      #{"Content-Type"=>"text/plain", "X-Deere-Handling-Server"=>"ldxtc4", "X-Frame-Options"=>"SAMEORIGIN", "Location"=>"https://sandboxapi.deere.com/platform/mapLayerSummaries/c5e9317e-eda6-48d3-acc8-c3bca3424858", "X-Deere-Elapsed-Ms"=>"362", "Vary"=>"Accept-Encoding", "Expires"=>"Wed, 13 Sep 2017 22:00:45 GMT", "Cache-Control"=>"max-age=0, no-cache", "Pragma"=>"no-cache", "Date"=>"Wed, 13 Sep 2017 22:00:45 GMT", "Transfer-Encoding"=>"chunked", "Connection"=>"close, Transfer-Encoding"}
+      id = get_created_id_from_response_headers(self.base_jd_resource, response)
+      if id.nil?
+        return nil
+      else
+        return self.new(HashUtils.deep_stringify_keys({"id" => id}.merge(body)))
+      end
+    end
+  end
+end

data/lib/myjohndeere/map_legend_item.rb

@@ -0,0 +1,10 @@
+module MyJohnDeere
+  class MapLegendItem < APISupportItem
+    attributes_to_pull_from_json(:label, :minimum, :maximum, :hexColor, :percent)
+    
+    # see attributes_to_pull_from_json for the order if creating yourself
+    def initialize(*args)
+      super(args)
+    end
+  end
+end

data/lib/myjohndeere/metadata_item.rb

@@ -0,0 +1,8 @@
+module MyJohnDeere
+  class MetadataItem < APISupportItem
+    attributes_to_pull_from_json(:key, :value)
+    def initialize(*args)
+      super(args)
+    end
+  end
+end

data/lib/myjohndeere/organization.rb

@@ -0,0 +1,16 @@
+module MyJohnDeere
+  class Organization < SingleResource
+    self.base_jd_resource = "organizations"
+    self.list_resource_path = self.base_jd_resource
+    self.retrieve_resource_path = self.base_jd_resource
+    attributes_to_pull_from_json(:id, :name, :type, :member)
+
+    def initialize(json_object, access_token = nil)
+      super(json_object, access_token)
+    end
+
+    def fields
+      return MyJohnDeere::Field.list(self.access_token, organization_id: self.id)
+    end
+  end
+end