e_plat 0.2.4 → 0.4.0

data/lib/e_plat/resource/collection.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module EPlat
+	class Collection < ActiveResource::Collection
+
+		def initialize(parsed = {})
+			super parsed
+		end
+
+		def next_page?
+			return unless pagination_available?
+			@next_url.present?
+		end
+
+		def previous_page?
+			return unless pagination_available?
+			@previous_url.present?
+		end
+
+		def next_page_info
+			return unless pagination_available?
+			extract_page_info(@next_url)
+		end
+	
+		def previous_page_info
+			return unless pagination_available?
+			extract_page_info(@previous_url)
+		end
+
+		def fetch_next_page
+			return unless pagination_available?
+			fetch_page(@next_url)
+		end
+
+		def fetch_previous_page
+			return unless pagination_available?
+			fetch_page(@previous_url)
+		end
+
+		
+		private
+
+		def fetch_page(url)
+			return [] unless url.present?
+			url = "#{ resource_class.collection_path }#{ url }" if client.bigcommerce?
+
+			resource_class.all(from: url)
+		end
+
+		def pagination_links
+			case client.platform
+			when :shopify
+				@pagination_links ||= EPlat::Paginated::LinkHeaders.new(
+					(full_response&.headers&.to_h || {})[:link]
+				)
+			when :bigcommerce
+				response    = JSON.parse(full_response.body)
+				return unless response.is_a? Hash
+				link_params = response.dig('meta', 'pagination', 'links')
+				return unless link_params.present?
+
+				@pagination_links ||= EPlat::Paginated::LinkParams.new(
+					link_params
+				)
+			else
+				raise "Unknown platform"
+			end
+		end
+
+		def pagination_available?
+			@next_url 	  = pagination_links&.next_link&.url&.to_s
+			@previous_url = pagination_links&.previous_link&.url&.to_s
+
+			@next_url.present? or @previous_url.present?
+		end
+
+		def extract_page_info(url)
+			return unless url.present?
+
+			query_params = URI.decode_www_form(URI(url).query).to_h 
+			query_params[client.pagination_param]
+		end
+
+
+		private
+
+			def client
+				Current.e_plat_session
+			end
+
+	end
+end

data/lib/e_plat/resource/concerns/aliases.rb

@@ -3,6 +3,7 @@ module EPlat
 	module Concerns
 		module Aliases
 			extend ActiveSupport::Concern
+
 			attr_accessor :type_coercer
 		 				
 			def add_aliases!(aliases, type_schema)
@@ -14,20 +15,27 @@ module EPlat
 					args 		= action.values.first
 					e_plat_key	= args[:e_plat_key]
 					native_key	= args[:native_key]
-					
+					@is_virtual = args[:virtual_collection]
+
 					case action_name
 					when :alias_attribute
 						add_to_instance! alias_mapped_getter(e_plat_key, native_key, proc: args[:custom_e_plat_getter])
 						add_to_instance! alias_mapped_setter(e_plat_key, native_key, proc: args[:custom_native_setter])
+						# puts alias_mapped_setter(e_plat_key, native_key, proc: args[:custom_native_setter]) if e_plat_key == 'variant_id'
 						processed << e_plat_key
 					end
 				end
 				
 				type_schema.each do |e_plat_key, type|
 					next if processed.include?(e_plat_key)
-					add_to_instance! mapped_getter(e_plat_key)
+					add_to_instance! mapped_getter(e_plat_key), @is_virtual
 				end
 
+				native_keys.each do |native_key|
+					next if processed.include?(native_key)
+
+					add_to_instance! native_setter(native_key), @is_virtual
+				end
 			end
 			
 			
@@ -39,7 +47,7 @@ module EPlat
 					
 					<<-STRING
 						def #{ e_plat_key }
-							current_value = self.attributes['#{ native_key }']
+							current_value = #{ native_key_path(native_key) }
 							#{ proc_line }
 							type_coercer.type_value!('#{ e_plat_key }', current_value)
 						end
@@ -50,10 +58,15 @@ module EPlat
 					proc_line = (proc) ? "new_value = #{ proc.strip }.call(new_value)" : nil
 					
 					<<-STRING
-						def #{ e_plat_key }=(value)
+						def #{e_plat_key}=(value)
 							new_value = value
 							#{proc_line}
-							self.attributes['#{ native_key }'] = new_value
+
+							unless new_value == #{ native_key_path(native_key) }
+								#{ native_key_path(native_key) } = new_value
+								attribute_will_change!('#{e_plat_key}')
+								#{ nested_attribute_will_change(native_key) if native_key&.include?('[') }
+							end
 						end
 					STRING
 				end
@@ -66,11 +79,77 @@ module EPlat
 					STRING
 				end
 
-				def add_to_instance!(meta_programming_string)
+				def native_setter(native_key)
+					<<-STRING
+						def #{native_key}=(value)
+							super
+							attribute_will_change!('#{native_key}')
+						end
+					STRING
+				end
+
+				def native_key_path(native_key)
+					segments = native_key.split(/[\[\]]+/).reject(&:empty?)
+					path_code = @is_virtual ? "self.mapping.virtual_collection.resource" : "self" 
+				  
+					segments.each do |segment|
+						if segment.match(/^\d+$/) # Check if the segment is a number (array index)
+							path_code += "[#{segment}]"
+						else
+							path_code += ".#{segment}"
+						end
+					end
+				  
+					path_code
+				end
+				
+
+				# ".send('#{ native_key_parent }').attribute_will_change!('#{ native_key }')"
+
+				def add_to_instance!(meta_programming_string, is_virtual=false)
+					# puts meta_programming_string if meta_programming_string.include?('note')
+
 					self.instance_eval { eval meta_programming_string }
 				end
-			
-			
+
+				# doesn't support two indexes in a row. i.e. [0][0]
+				def nested_attribute_will_change(native_key) # "[consignments][0][shipping][0][line_items][0][variant_id]"
+					ref_object = @is_virtual ? "mapping.virtual_collection.resource" : "self" 
+					parts = native_key.scan(/(\w+)|(\d+)/).flatten.compact # ["consignments", "0", "shipping", "0", "line_items", "0", "variant_id"]
+				
+					method_chain = ""
+					change_statements = []
+					
+					first_attribute = parts.find { |part| !is_index?(part) }
+					if first_attribute
+						change_statements << "#{ref_object}.attribute_will_change!('#{first_attribute}')"
+					end
+				
+					parts.each_with_index do |part, index|
+						method_chain += is_index?(part) ? "[#{part}]" : ".#{part}"
+				
+						next_call     = parts[index + 1]
+						attribute_key = is_index?(next_call) ? parts[index + 2] : next_call 
+						next if (is_index?(part) && next_call && attribute_key.nil?) or !is_index?(part)
+
+						change_statement = "#{ref_object}#{method_chain}.attribute_will_change!('#{attribute_key}')"
+						change_statements << change_statement 
+					end 
+
+					<<-STRING
+						attribute_will_change!('#{parts.last}')
+						#{change_statements.join("\n")}
+					STRING
+				end
+
+
+				def is_index?(part)
+					part&.match?(/\d+/)
+				end
+
+
+				
+				
 	
 			# Requires an array of hashes which each contain a single :alias_attribute entry. 
 			# This will expose e_plat_key getter and setter methods that interact with the 
@@ -82,19 +161,24 @@ module EPlat
 			# Like the below example, optional stringified procs can be passed in to respect the e_plat or native interfaces version of the value. e.g. enums
 			# 
 			# {
-			# 	alias_attribute: {native_key: "name", e_plat_key: "handle"}	
+			# 	alias_attribute: {native_key: "description",  e_plat_key: "body_html"}
+			# }, {
+			# 	alias_attribute: {
+			#		native_key: "description",  
+			#		e_plat_key: "body_html", 
+			#		custom_e_plat_getter: "-> (value) { value&.gsub(' ', '-') }",
+			#		custom_native_setter: "-> (value) { value&.gsub('-', ' ') }" 
+			#	}
+			# }, {
+			#    existing_entry: {native_key: "id", e_plat_key: "id"}
 			# },
 			# {
-			# 	alias_attribute: {native_key: 	"availability", e_plat_key: "status", 
-			# 		custom_e_plat_getter: "-> (value) { 
-			# 			{'preorder'=>'active', 'available' => 'active', 'disabled' => 'draft'}[value] || value
-			# 		}",
-			# 		custom_native_setter: "-> (value) { 
-			# 			{'available' => 'active', 'disabled' => 'draft'}.invert[value] || value
-			# 		}" #invert will merge new duped keys
-			# 	}
+			#  	 alias_attribute: {native_key: "billing_address[email]", e_plat_key: "email"}
 			# }
-			
+			# {
+			#  	 alias_attribute: {native_key: "[nested][deeply][in][2][attribute]", e_plat_key: "hey"}
+			# }
+			# 
 		end
 	end
 end

data/lib/e_plat/resource/concerns/dirty.rb

@@ -0,0 +1,54 @@
+module EPlat
+	module Concerns
+		module Dirty
+			extend ActiveSupport::Concern
+			# manages the self.changed_attributes hash
+			# this is important for the as_json method, which will only include changed attributes when updating an existing resource
+			# only supports native attributes
+
+			included do
+				def changed_attributes
+					@changed_attributes ||= {}
+				end
+
+				def attribute_will_change!(attr)
+					changed_attributes[attr] = read_attribute(attr)
+
+					native_keys.include?(attr) ? e_plat_attribute_will_change!(attr) : native_attribute_will_change!(attr)
+				end
+
+				def attribute_changed?(attr)
+					changed_attributes.include?(attr)
+				end
+
+				def read_attribute(attr)
+					self.send(attr)
+				end
+
+				def reload!
+					try(:super)
+					changed_attributes.clear
+				end
+
+
+				private
+
+				def native_attribute_will_change!(eplat_attr)
+					key = self.mapping.native_key_to(eplat_attr)
+					return unless key && self.respond_to?(key)
+
+					changed_attributes[key] = send(key)
+				end
+
+				def e_plat_attribute_will_change!(native_attr)
+					key = self.mapping.e_plat_key_to(native_attr)
+					return unless key && self.respond_to?(key)
+					
+					changed_attributes[key] = send(key)
+				end
+			end
+
+
+		end
+	end
+end

data/lib/e_plat/resource/concerns/metafieldable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EPlat
+	module Concerns
+		module Metafieldable #< ActiveResource::CustomMethods
+
+			def metafields(**options)
+				options.merge!(resource: self.class.collection_name, resource_id: id)
+
+				Metafield.find(:all, 
+					from: current_resources_metafield_path, 
+					params: options
+				)
+			end
+
+			def find_metafield(id)
+				metafields.find { |m| m.id == id }
+			end
+
+			def add_metafield(metafield)
+				raise ArgumentError, "You can only add metafields to a resource that has been saved" if new?
+
+				metafield.owner_id = id
+				metafield.owner_resource = self.class.element_name
+				metafield.save
+				metafield
+			end
+
+			
+			private
+
+			def current_resources_metafield_path
+				uri = URI.parse(element_path)
+				uri.path = uri.path.gsub(".json", "/metafields.json")
+				uri.path += "/metafields"  if uri.path.exclude?("json")
+				uri.path.gsub!('v2', 'v3') if client.bigcommerce? # metafield uses v3 API, even though orders are only available in v2
+
+				uri.to_s
+			end
+
+		end
+	end
+end

data/lib/e_plat/resource/concerns/overwrite_instance_methods.rb

@@ -1,11 +1,113 @@
 module EPlat
 	module Concerns
-		module OverwriteInstanceMethods	
-			
-			def include_root_in_json
-				client.shopify? && top_level_resource?
+		module OverwriteInstanceMethods
+			extend ActiveSupport::Concern	
+
+			def to_json(options = {})
+				#add this option here so root is added at the top of the JSON, as_json to every nested resource
+				root_at_top_of_json = self.mapping.include_root_in_request_body?(self)
+				options[:root] 		= self.element_name if root_at_top_of_json 
+
+				super(options)
 			end
-			
+
+			def as_json(options = {})
+				full_json = super(options)
+				return {} if read_only?
+
+				if mapping.class.virtual_collections.present?
+					virtual_keys = mapping.class.virtual_collections.map{|c| c[:name]}.map(&:to_s)
+					
+					full_json.reject!{|key, value| virtual_keys.include?(key) } # not needed in JSON, as it's just a proxy for setting the real attributes
+				end
+
+				return full_json if new_record? # new records request with all attributes
+				
+				request_json = 
+					if include_root_in_json or options[:root].present?
+						{ element_name => select_changed_attributes_and_collection_keys(full_json[element_name]) }
+					else
+						select_changed_attributes_and_collection_keys(full_json)
+					end
+
+				if top_level_resource? # then check that any present collections have all entries represented with atleast an ID, so they're not removed
+					hash_without_root(request_json).each do |key, value|
+						next unless arrayOfPresentHashes?(value)
+
+						hash_without_root(request_json)[key].filter!(&:present?)
+						hash_without_root(request_json)[key] += unrepresented_collection_ids(key, value).map{ |id| { "id" => id } }
+					end
+				end
+
+ 				add_root_if_needed(request_json, options[:root]).reject do |k,v| 
+					if v.is_a?(Array) 
+						v.reject(&:empty?).empty?
+					else 
+						v.nil? || v.blank?
+					end
+				end
+			end
+
+			# Create and return a class definition for a resource inside the current resource
+			def create_resource_for(resource_name)
+				resource = Class.new(EPlat::Base) # <- this line changed
+				resource.prefix = self.class.prefix
+				resource.site = self.class.site
+				self.class.const_set(resource_name, resource)
+		
+				resource
+			end
+
+			def create
+				self.attributes = mapping.via_native_attributes_where_possible(attributes)
+				super
+			end
+
+			def update
+				self.attributes = mapping.via_native_attributes_where_possible(attributes)
+				super
+			end
+
+
+			private
+
+			def select_changed_attributes_and_collection_keys(json)
+				sanitised_json = json.dup
+				
+				sanitised_json.select!{|key, value| changed_attributes.has_key?(key.to_s) || arrayOfPresentHashes?(value) }
+
+				if sanitised_json.present? # then we'll add an ID so that the resource can be updated
+					sanitised_json['id'] = json['id'] if json['id'] && client.can_update_nested_resources?
+				end
+
+				sanitised_json || {}
+			end
+
+			def arrayOfPresentHashes?(value)
+				value.is_a?(Array) && value.first.is_a?(Hash) && value.first.present?
+			end
+
+			def unrepresented_collection_ids(key, arrayOfHashes)
+				return [] unless client.can_update_nested_resources?
+				
+				all_instance_ids 		 = try(key)&.map(&:id) || [] 
+				represented_instance_ids = arrayOfHashes.map{|item| item["id"] }
+				
+				all_instance_ids.compact - represented_instance_ids.compact
+			end
+
+			def hash_without_root(json)
+				self.include_root_in_json ? json[self.element_name] : json
+			end
+
+			def add_root_if_needed(json, root)
+				if root and !json.has_key?(root)
+					{ root => json }
+				else
+					json
+				end
+			end
+
 		end
 	end
-end
+end

data/lib/e_plat/resource/concerns/overwrite_request_methods.rb

@@ -1,50 +1,86 @@
 module EPlat
 	module Concerns
-		module OverwriteRequestMethods	
+		module OverwriteRequestMethods
 			
-			def find(*arguments)
-				initialize_singleton!
-				arguments.second[:params].merge!(client.send "#{element_name}_default_find_args")  if arguments.second
-				arguments.second[:params].merge!(mapping.to_native_keys arguments.second[:params]) if arguments.second
-				
-				super
+			def self.included(base)
+				base.extend ClassMethods
 			end
-			
-			def instantiate_collection(collection, original_params = {}, prefix_options = {})
-				collection = collection["data"] if collection.is_a?(Hash) && collection["data"].present?
-				
-				super
-			end
-			
-			def new(attributes, persisted=false)
-				initialize_singleton!
-				self.mapping = EPlat::Mapping.new_instance(specifc_mapping: specifc_mapping_name)
-				
-				attributes = attributes.send( *top_key_method(mapping.native_top_key) ) if attributes[mapping.native_top_key]
-				super
-			end
-			
-			def create(attributes = {})
-				initialize_singleton!
-				super
-			end
-			
-			def include_root_in_json
-				client.shopify? && top_level_resource?
-			end
-			
-			
-			private
-				
+
+			module ClassMethods
+				def find(*arguments)
+					initialize_singleton!
+
+					if arguments.second && arguments.second[:params]
+						arguments.second[:params].merge!(client.try("#{element_name}_default_request_args") || {})
+						arguments.second[:params] = mapping.via_native_attributes_where_possible(arguments.second[:params])
+					else
+						arguments << {params: (client.try("#{element_name}_default_request_args") || {}) }
+					end
+
+					super
+				end
+
+				def find_by(params)
+					find(:all, params: params)&.first
+				end
+
+				def instantiate_collection(collection, original_params = {}, prefix_options = {})
+					collection = collection["data"] if collection.is_a?(Hash) && collection["data"]
+					super
+				end
+
+				def new(attributes, persisted = false)
+					initialize_singleton!
+
+					self.mapping = EPlat::Mapping.new_instance(specifc_mapping: specifc_mapping_name, resource: nil)
+
+					if attributes[mapping.native_top_key]
+						attributes = attributes.send(*top_key_method(mapping.native_top_key))
+					end
+					attributes = attributes.with_defaults(mapping.class::DEFAULT_VALUES)
+
+					super
+				end
+
+				def create(attributes = {})
+					initialize_singleton!
+					attributes = mapping.via_native_attributes_where_possible(attributes)
+
+					super
+				end
+
+				def update(attributes = {})
+					initialize_singleton!
+					attributes = mapping.via_native_attributes_where_possible(attributes)
+					
+					super
+				end
+
+				private
+
 				def top_key_method(top_key)
 					(top_key == :itself) ? top_key : [:[], top_key]
 				end
-				
+
 				def specifc_mapping_name
 					class_constant_string = self.name.gsub("EPlat::", "")
-					"EPlat::Mapping::#{ client.platform.capitalize }::V#{ client.api_version.camelize }::#{ class_constant_string }"
+					"EPlat::Mapping::#{client.platform.capitalize}::V#{client.api_version.camelize}::#{class_constant_string}"
 				end
+			end
+
+
+			def collection_path(options = {})
+				options = options.merge client.try("#{element_name}_default_request_args") || {}
+
+				super(options)
+			end
+
+			def element_path(options = {})
+				options = options.merge client.try("#{element_name}_default_request_args") || {}
+
+				super(options)
+			end
 			
 		end
 	end
-end
+end

data/lib/e_plat/resource/countable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EPlat
+	module Countable
+
+		def count(options = {})
+			initialize_singleton!
+
+			if counts_via_meta_data?
+				raw_data  = connection.get(collection_path, headers)
+				data_hash = ActiveSupport::JSON.decode(raw_data.body)
+				data = data_hash.dig("meta", "pagination", "total")
+			elsif count_key_next_to_root?
+				raw = get(:count, options)
+				data = JSON.parse raw.full_response.body
+			else
+				data = get(:count, options)
+			end
+
+			count = 
+				case data
+				when Hash then data["count"]
+				else data
+				end
+
+			Integer(count)
+		end
+
+
+		private
+
+			def counts_via_meta_data?
+				return false unless client.bigcommerce?
+
+				self == EPlat::Product or self == EPlat::Product::Variant
+			end
+
+			def count_key_next_to_root?
+				client.bigcommerce? && self == EPlat::Order
+			end
+
+	end
+end