Beyond api v2

lib/beyond_api.rb

@@ -7,6 +7,7 @@
 require "beyond_api/ext"
 require "beyond_api/utils"
 require "beyond_api/services/base_service"
+require "beyond_api/services/product_management/category"
 require "beyond_api/services/product_management/image"
 require "beyond_api/services/product_management/product"
 require "beyond_api/services/product_management/variation"

lib/beyond_api/services/base_service.rb

@@ -10,5 +10,39 @@ def initialize(session)
       # raise InvalidSessionError, "Invalid session" unless session.is_a? BeyondApi::Session
       # raise InvalidSessionError, "Session api_url cannot be nil" if session.api_url.nil?
     end
+
+    def fetch_all_pages(url, resource, params = {})
+      if params[:paginated] == false
+        result = fetch_pages(url, resource, params, BeyondApi.configuration.all_pagination_size)
+        adjust_response(result)
+        result
+      else
+        fetch_page(url, params)
+      end
+    end
+
+    private
+
+    def adjust_response(result)
+      result[:page][:size] = result[:page][:total_elements]
+      result[:page][:total_pages] = 1
+      result[:page][:number] = 0
+    end
+
+    def fetch_page(url, params = {})
+      BeyondApi::Request.get(@session, url, params)
+    end
+
+    def fetch_pages(url, resource, params, size)
+      result = fetch_page(url, params.merge(page: 0, size:))
+
+      (1..result[:page][:total_pages] - 1).each do |page|
+        result[:embedded][resource].concat(
+          fetch_page(url, params.merge(page:, size:))[:embedded][resource]
+        )
+      end
+
+      result
+    end
   end
 end

lib/beyond_api/services/product_management/category.rb

@@ -0,0 +1,9 @@
+module BeyondApi
+  module ProductManagement
+    class Category < BaseService
+      def find(id)
+        BeyondApi::Request.get(@session, "/categories/#{id}")
+      end
+    end
+  end
+end

lib/beyond_api/services/product_management/product.rb

@@ -1,6 +1,11 @@
 module BeyondApi
   module ProductManagement
     class Product < BaseService
+      def all(params = {})
+        # BeyondApi::Request.get(@session, "/products", params)
+        fetch_all_pages("/products", :products, params)
+      end
+
       def find(id)
         BeyondApi::Request.get(@session, "/products/#{id}")
       end

lib/beyond_api/services/product_view/category.rb

@@ -2,7 +2,7 @@ module BeyondApi
   module ProductView
     class Category < BaseService
       def all(params = {})
-        BeyondApi::Request.get(@session, "/product-view/categories", params)
+        fetch_all_pages("/product-view/categories", :categories, params)
       end
 
       def find(id)

lib/beyond_api/utils.rb

@@ -16,88 +16,5 @@ def file_content_type(file_path)
         "image/gif"
       end
     end
-
-    def handle_all_request(url, resource, params = {})
-      paginated_size = BeyondApi.configuration.all_pagination_size
-
-      if params[:paginated] == false
-        result = all_paginated(url, params.merge(page: 0, size: paginated_size))
-
-        (1..result[:page][:total_pages] - 1).each do |page|
-          result[:embedded][resource].concat(
-            all_paginated(url,
-                          params.merge(page: page,
-                                       size: paginated_size))[:embedded][resource]
-          )
-        end
-
-        result[:page][:size] = result[:page][:total_elements]
-        result[:page][:total_pages] = 1
-        result[:page][:number] = 0
-
-        result
-      else
-        all_paginated(url, params)
-      end
-    end
-
-    def handle_error(response)
-      raise BeyondApi::Error.new({}, 500)
-      # BeyondApi.logger.error "[Beyond API] #{status}: #{response}"
-      # error = BeyondApi::Error.new(response, status)
-      # BeyondApi.configuration.raise_error_requests ? raise(error) : error
-    end
-
-    def handle_response(response, status, respond_with_true: false)
-      if status.between?(200, 299)
-        return true if respond_with_true
-
-        response = sanitize_response(response)
-        BeyondApi.configuration.object_struct_responses ? to_object_struct(response) : response
-      else
-        handle_error(response, status)
-      end
-    end
-
-    def sanitize_key(key)
-      key.chars.first == "_" ? key[1..-1] : key
-    end
-
-    def sanitize_response(hash)
-      {}.tap do |h|
-        hash.each do |key, value|
-          next if key == "_links" && BeyondApi.configuration.remove_response_links
-
-          key = sanitize_key(key) if BeyondApi.configuration.remove_response_key_underscores
-          h[key.underscore.to_sym] = transform(value)
-        end
-      end
-    end
-
-    def to_object_struct(data)
-      if data.is_a? Hash
-        OpenStruct.new(data.map { |key, val| [key, to_object_struct(val)] }.to_h)
-      elsif data.is_a? Array
-        data.map { |o| to_object_struct(o) }
-      else
-        data
-      end
-    end
-
-    private
-
-    def all_paginated(url, params = {})
-      response, status = BeyondApi::Request.get(@session, url, params)
-
-      handle_response(response, status)
-    end
-
-    def transform(thing)
-      case thing
-      when Hash then sanitize_response(thing)
-      when Array then thing.map { |v| transform(v) }
-      else; thing
-      end
-    end
   end
 end