catalogapi 0.1.0rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c9c28867fd78f2bf1b6e7d6b057d53a4fd471af73a0476e36b6dc48c459b6862
+  data.tar.gz: 8ba13d73491d7c3dd241f6a4be279637a70f79267cea4f05e39330105d360f44
+SHA512:
+  metadata.gz: 17b9fc60b840d8681866eeb58ee62c3ca419bf5d22336f50907ac7fac20534fc4ceafca7679b6750e58af338ecb726b143d8ad490316cca8e62fd34d44c4d506
+  data.tar.gz: 258662e822644bfa46291eff01d1a048f837d39bbcb1a6af62adecd24a9f84edde02e6f51d16cc17b9a84cbd0668aec2d92b80655580ae36e27ef3ed26b318bd

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+script.rb

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in catalogapi.gemspec
+gemspec
+
+gem 'rake', '~> 12.0'
+
+group :development, :test do
+  gem 'pry'
+  gem 'rspec', '~> 3.0'
+  gem 'webmock'
+end

data/Gemfile.lock

@@ -0,0 +1,74 @@
+PATH
+  remote: .
+  specs:
+    catalogapi (0.1.0rc1)
+      http (~> 4.0)
+      openssl (~> 2.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    coderay (1.1.3)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.4.4)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    ffi (1.13.1)
+    ffi-compiler (1.0.1)
+      ffi (>= 1.0.0)
+      rake
+    hashdiff (1.0.1)
+    http (4.4.1)
+      addressable (~> 2.3)
+      http-cookie (~> 1.0)
+      http-form_data (~> 2.2)
+      http-parser (~> 1.2.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    http-form_data (2.3.0)
+    http-parser (1.2.1)
+      ffi-compiler (>= 1.0, < 2.0)
+    method_source (1.0.0)
+    openssl (2.2.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    public_suffix (4.0.5)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    safe_yaml (1.0.5)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.7)
+    webmock (3.8.3)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  catalogapi!
+  pry
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  webmock
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -0,0 +1,136 @@
+# CatalogAPI
+
+Ruby wrapper around the http://catalogapi.com/ API
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'catalogapi'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install catalogapi
+
+## Usage
+
+### Setup your CatalogAPI
+
+```
+CatalogAPI.key         = 'test-key'    # provided by CatalogAPI.com
+CatalogAPI.token       = 'test-token'  # provided by CatalogAPI.com
+CatalogAPI.environment = 'development' # or production, default is development
+CatalogAPI.username    = 'username'    # provided by CatalogAPI.com (subdomain)
+```
+
+### Catalogs
+
+#### List Available Catalogs
+
+```
+CatalogAPI::Catalog.list_available.data
+=> [
+  #<CatalogAPI::Catalog @currency="USD", @export_uri=...,
+  #<CatalogAPI::Catalog @currency="USD", @export_uri=...,
+]
+```
+
+#### List the item categories available in a catalog
+
+```
+CatalogAPI::Catalog.new(socket_id: '123').breakdown.data
+=> [
+  #<CatalogAPI::Category
+    @category_id="99",
+    @children=[#<CatalogAPI::Category @category_id="11"...>],
+    ...
+  >,
+  ...
+]
+```
+
+#### Searches a catalog by keyword, category, or price range.
+
+```
+CatalogAPI::Catalog.new(socket_id: '123').search(search: 'ipod').data
+=> [
+  #<CatalogAPI::Item
+    @brand="Apple",
+    @catalog_item_id=1234
+    ...
+  >,
+  ...
+]
+```
+
+__Note the `paginated` option will paginate over all pages and aggregate the result__
+
+### Items
+
+#### View the full details of a single item.
+
+```
+CatalogAPI::Item.new(catalog_item_id: 1, socket_id: 2).view.data
+=> #<CatalogAPI::Item
+  ...
+  @catalog_item_id="1",
+  ...
+  @description=
+  ...
+>
+```
+
+### Orders
+
+#### List all orders
+
+```
+CatalogAPI::Order.list(external_user_id).data
+=> [
+  #<CatalogAPI::Order
+    external_user_id=1
+    ...
+  >,
+  ...
+]
+```
+__Note the `paginated` option will paginate over all pages and aggregate the result__
+
+#### Place an order
+```
+CatalogAPI::Order.new(
+  items: CatalogAPI::Item.new,
+  first_name: "Test",
+  last_name: "Testman",
+  address_1: "123 Test Street",
+  city: "Cincinnati",
+  state_province: "OH",
+  postal_code: "00000",
+  country: "US"
+).place.data
+=> #<CatalogAPI::Order @order_number="XXXX-XXXXX-XXXXX-XXXX" ...>
+```
+
+#### Track an order
+
+```
+CatalogAPI::Order.new(order_number: '4004-20883-04361-0098').track.data
+=> #<CatalogAPI::Item:0x00007f92d6430948 @order_number="4004-20883-04361-0098" ...>
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/catalogapi.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'catalogapi'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/catalogapi.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'lib/catalogapi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'catalogapi'
+  spec.version       = CatalogAPI::VERSION
+  spec.authors       = ['davidrichey']
+  spec.email         = ['david.richey@memberhub.com']
+
+  spec.summary       = 'Ruby gem that wraps http://catalogapi.com/ API'
+  spec.description   = 'Simple ruby library to interact with the http://catalogapi.com/ API'
+  spec.homepage      = 'http://github.com/memberhubteam/catalogapi'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'http://github.com/memberhubteam/catalogapi'
+  spec.metadata['changelog_uri'] = 'http://github.com/memberhubteam/catalogapi/blob/master/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'http', '~> 4.0'
+  spec.add_dependency 'openssl', '~> 2.2'
+end

data/lib/catalogapi.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'catalogapi/request'
+require 'catalogapi/catalog'
+require 'catalogapi/category'
+require 'catalogapi/item'
+require 'catalogapi/order'
+require 'catalogapi/version'
+
+require 'pry'
+
+module CatalogAPI
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :environment, :key, :token, :username
+
+    def development?
+      !production?
+    end
+
+    def production?
+      environment == 'production'
+    end
+
+    def request
+      CatalogAPI::Request
+    end
+  end
+
+  # @return [Services::OnlineRewards::Request] request to the list_available_catalogs endpoint
+  def list_available_catalogs
+    request.new(:list_available_catalogs).get
+  end
+
+  # @param socket_id [String] the Socket ID from the list_available_catalogs
+  # @return [Services::OnlineRewards::Request]
+  def catalog_breakdown(socket_id)
+    request.new(:catalog_breakdown).get(socket_id: socket_id)
+  end
+
+  # @param socket_id [String] the Socket ID from the list_available_catalogs
+  # @param search [String] keywork to search for
+  # @return [Services::OnlineRewards::Request]
+  def search_catalog(socket_id, search)
+    request.new(:search_catalog).get(socket_id: socket_id, search: search)
+  end
+end

data/lib/catalogapi/catalog.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module CatalogAPI
+  class Catalog
+    class << self
+      # @return [Array[CatalogAPI::Catalog]] Returns a list of the catalog sockets you have available on your account.
+      def list_available
+        request = CatalogAPI.request.new(:list_available_catalogs).get
+        sockets = request.json.dig(
+          :list_available_catalogs_response, :list_available_catalogs_result,
+          :domain, :sockets, :Socket
+        ).to_a
+        request.data = sockets.map { |socket| new(socket) }
+        request
+      end
+    end
+
+    attr_reader :currency, :export_uri, :language, :point_to_currency_ratio,
+                :region, :socket_id, :socket_name
+    def initialize(opts)
+      @currency = opts[:currency]
+      @export_uri = opts[:export_uri]
+      @language = opts[:language]
+      @point_to_currency_ratio = opts[:point_to_currency_ratio]
+      @region = opts[:region]
+      @socket_id = opts[:socket_id]
+      @socket_name = opts[:socket_name]
+    end
+
+    # @return [Array[CatalogAPI::Category]] Returns a list of item categories available in a catalog
+    def breakdown(is_flat: 0)
+      raise CatalogAPI::Error, 'No Socket ID' if socket_id.nil?
+
+      request = CatalogAPI.request.new(:catalog_breakdown).get(socket_id: socket_id, is_flat: is_flat)
+      catgories = request.json.dig(
+        :catalog_breakdown_response, :catalog_breakdown_result, :categories,
+        :Category
+      ).to_a
+      request.data = catgories.map { |cateogry| CatalogAPI::Category.new(cateogry) }
+      request
+    end
+
+    # @option options [String] :name Searches the names of items.
+    # @option options [String] :search Search the name, description and model of items.
+    # @option options [String] :category_id Returns only items within this category_id. (This includes any child categories of the category_id.) The category_id comes from the catalog_breakdown method.
+    # @option options [String] :min_points Return only items that have a point value of at least this value.
+    # @option options [String] :max_points Return only items that have a point value of no more than this value.
+    # @option options [String] :min_price Return only items that have a price of at least this value.
+    # @option options [String] :max_price Return only items that have a price of no more than this value.
+    # @option options [String] :max_rank Do not return items with a rank higher than this value.
+    # @option options [String] :tag We have the ability to "tag" certain items based on custom criteria that is unique to our clients. If we setup these tags on your catalog, you can pass a tag name with your search.
+    # @option options [String] :page The page number. Defaults to 1.
+    # @option options [String] :paginated Whether to paginate the call or return the first page result default: nil
+    # @option options [String] :per_page The number of items to return, per page. Can be from 1 to 50. Defaults to 10.
+    # @option options [String] :sort The following sort values are supported: 'points desc', 'points asc', 'rank asc', 'score desc', 'random asc'
+    # @option options [String] :catalog_item_ids Return only items in the given list.
+    # @return [Array[CatalogAPI::Item]] Searches a catalog by keyword, category, or price range.
+    def search(options = {}, request = nil)
+      raise CatalogAPI::Error, 'No Socket ID' if socket_id.nil?
+
+      request ||= CatalogAPI.request.new(:search_catalog)
+      request = request.get(options.to_h.merge(socket_id: socket_id))
+      items = request.json.dig(
+        :search_catalog_response, :search_catalog_result, :items, :CatalogItem
+      ).to_a
+      request.data += items.map { |item| CatalogAPI::Item.new(item.merge(socket_id: socket_id)) }
+      # Pagination
+      next_page = options[:paginated] ? request.next_page : nil
+      request = search(options.merge(page: next_page), request) if next_page
+      request
+    end
+  end
+end

data/lib/catalogapi/category.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CatalogAPI
+  class Category
+    attr_reader :category_id, :children, :depth, :item_count, :name,
+                :parent_category_id
+    def initialize(opts)
+      @category_id = opts[:category_id]
+      @children = opts.dig(:children, :Category).to_a.map do |child|
+        CatalogAPI::Category.new(child)
+      end
+      @depth = opts[:depth]
+      @item_count = opts[:item_count]
+      @name = opts[:name]
+      @parent_category_id = opts[:parent_category_id]
+    end
+  end
+end

data/lib/catalogapi/item.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module CatalogAPI
+  class Item
+    attr_accessor :description
+
+    attr_reader :brand, :catalog_item_id, :catalog_price, :categories,
+                :currency, :has_options, :image_150, :image_300,
+                :image_75, :model, :name, :options, :original_points,
+                :original_price, :points, :rank, :retail_price,
+                :shipping_estimate, :socket_id, :tags,
+                :quantity, :option_id
+    def initialize(opts)
+      @brand = opts[:brand]
+      @catalog_item_id = opts[:catalog_item_id]
+      @catalog_price = opts[:catalog_price]
+      @categories = opts[:categories].to_h[:integer]
+      @currency = opts[:currency] || 'USD'
+      @description = opts[:description]
+      @has_options = opts[:has_options]
+      @image_150 = opts[:image_150]
+      @image_300 = opts[:image_300]
+      @image_75 = opts[:image_75]
+      @model = opts[:model]
+      @name = opts[:name]
+      @options = opts[:options]
+      @original_points = opts[:original_points]
+      @original_price = opts[:original_price]
+      @points = opts[:points]
+      @rank = opts[:rank]
+      @retail_price = opts[:retail_price]
+      @shipping_estimate = opts[:shipping_estimate]
+      @socket_id = opts[:socket_id]
+      @tags = opts[:tags].to_h[:string]
+      @quantity = opts[:quantity] || 1
+      @option_id = opts[:option_id]
+    end
+
+    def order_params
+      {
+        catalog_item_id: catalog_item_id,
+        quantity: quantity,
+        currency: currency,
+        catalog_price: catalog_price.to_f,
+        option_id: option_id
+      }.reject { |_k, v| v.nil? }.to_h
+    end
+
+    def orderable?
+      !catalog_item_id.nil? && !catalog_price.nil?
+    end
+
+    def view
+      raise CatalogAPI::Error, 'No Socket ID' if socket_id.nil?
+      raise CatalogAPI::Error, 'No Catalog Item ID' if catalog_item_id.nil?
+
+      request = CatalogAPI.request.new(:view_item)
+                          .get(socket_id: socket_id, catalog_item_id: catalog_item_id)
+      fields = request.json.dig(:view_item_response, :view_item_result, :item)
+      request.data = self.class.new(fields)
+      request
+    end
+  end
+end

data/lib/catalogapi/order.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module CatalogAPI
+  class Order
+    attr_reader :date_placed, :external_user_id, :order_number,
+                :external_order_number, :first_name, :last_name,
+                :address_1, :address_2, :address_3, :city, :state_province,
+                :postal_code, :country, :phone_number, :email, :items
+
+    def initialize(opts)
+      @date_placed = nil
+      if opts[:date_placed] && !opts[:date_placed].empty?
+        @date_placed = Time.parse(opts[:date_placed]).to_time
+      end
+      @external_user_id = opts[:external_user_id]
+      @order_number = opts[:order_number]
+
+      @external_user_id = opts[:external_user_id]
+      @external_order_number = opts[:external_order_number]
+      @first_name = opts[:first_name]
+      @last_name = opts[:last_name]
+      @address_1 = opts[:address_1]
+      @address_2 = opts[:address_2]
+      @address_3 = opts[:address_3]
+      @city = opts[:city]
+      @state_province = opts[:state_province]
+      @postal_code = opts[:postal_code]
+      @country = opts[:country]
+      @email = opts[:email]
+      @phone_number = opts[:phone_number]
+      @items = opts[:items].to_a
+    end
+
+    class << self
+      # @option options [String] :external_user_id external user id used placing the order
+      # @option options [String] :page page number of results to return when there are more than per_page results.
+      # @option options [String] :per_page number of orders to return. Defaults to 10. Can be increased to a maximum of 50.
+      # @option options [String] :paginated return all orders by paginating over all pages
+      # @return [Array[CatalogAPI::Order]] return all orders placed by that user.
+      def list(options = {}, request = nil)
+        external_user_id = options[:external_user_id]
+        raise CatalogAPI::Error, 'No External User ID' if external_user_id.nil?
+
+        request ||= CatalogAPI.request.new(:order_list)
+        request = request.get(options.merge(external_user_id: external_user_id))
+        orders = request.json.dig(
+          :order_list_response, :order_list_result, :orders, :OrderSummary
+        ).to_a
+        request.data += orders.map { |item| CatalogAPI::Order.new(item.merge(external_user_id: external_user_id)) }
+        # Pagination
+        next_page = options[:paginated] ? request.next_page : nil
+        request = list(options.merge(page: next_page), request) if next_page
+        request
+      end
+    end
+
+    # Place an order without requiring a cart.
+    # @return [CatalogAPI::Order]
+    def place
+      raise CatalogAPI::Error, 'No Items' if items.nil? || items.length.zero?
+      raise CatalogAPI::Error, 'No Socket ID' if items.first.socket_id.nil?
+      raise CatalogAPI::Error, 'No First Name' if first_name.nil?
+      raise CatalogAPI::Error, 'No Last Name' if last_name.nil?
+      raise CatalogAPI::Error, 'No Adress1' if address_1.nil?
+      raise CatalogAPI::Error, 'No City' if city.nil?
+      raise CatalogAPI::Error, 'No State' if state_province.nil?
+      raise CatalogAPI::Error, 'No Postal Code' if postal_code.nil?
+      raise CatalogAPI::Error, 'No Country' if country.nil?
+      raise CatalogAPI::Error, 'No Items' if items.nil?
+
+      request = CatalogAPI.request.new(:order_place)
+      request.post(place_params(request))
+      json = request.json.dig(:order_place_response, :order_place_result)
+      request.data = CatalogAPI::Order.new(json)
+      request
+    end
+
+    # @return [CatalogAPI::Order] Return the details of a previously placed order, including any shipment information.
+    def track
+      raise CatalogAPI::Error, 'No Order Number' if order_number.nil?
+
+      request = CatalogAPI.request.new(:order_track).get(order_number: order_number)
+      json = request.json.dig(:order_track_response, :order_track_result, :order)
+      items = json.dig(:items, :OrderItem).to_a.map { |i| CatalogAPI::Item.new(i) }
+      request.data = CatalogAPI::Order.new(json.merge(items: items))
+      request
+    end
+
+    private
+
+    def place_params(request)
+      {
+        order_place: {
+          order_place_request: {
+            credentials: request.required_params(''),
+            socket_id: items.first.socket_id,
+            external_user_id: external_user_id,
+            external_order_number: external_order_number,
+            first_name: first_name,
+            last_name: last_name,
+            address_1: address_1,
+            address_2: address_2,
+            address_3: address_3,
+            city: city,
+            state_province: state_province,
+            postal_code: postal_code,
+            country: country,
+            phone_number: phone_number,
+            email: email,
+            items: items.map(&:order_params)
+          }.reject { |_k, v| v.nil? }.to_h
+        }
+      }
+    end
+  end
+end

data/lib/catalogapi/request.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'openssl'
+require 'securerandom'
+require 'time'
+
+module CatalogAPI
+  class Request
+    attr_accessor :method_name, :path, :response, :json, :data, :body
+    def initialize(method_name, path: nil)
+      @data = []
+      @method_name = method_name
+      @path = path || method_name
+    end
+
+    def base_url
+      env = CatalogAPI.production? ? 'prod' : 'dev'
+      username = CatalogAPI.username
+      "https://#{username}.#{env}.catalogapi.com/v1"
+    end
+
+    def get(params = {})
+      url = "#{base_url}/rest/#{path}"
+      self.response = HTTP.get(url, { params: params.merge(required_params) })
+      json_response
+    end
+
+    def post(params = {})
+      url = "#{base_url}/json/#{path}"
+      puts params
+      self.response = HTTP.post(url, { json: params })
+      json_response
+    end
+
+    def json_response
+      check_status!
+      self.json = JSON.parse(response.body.to_s, symbolize_names: true)
+      self
+    end
+
+    # CatalogAPI Error
+    class Error < StandardError
+      attr_accessor :code, :body
+      def initialize(response)
+        puts response.inspect
+        puts response.body
+        @body = response.body
+        @code = response.code
+      end
+
+      def message
+        "#{code} #{body}"
+      end
+    end
+
+    def first
+      data.first
+    end
+
+    def each(&block)
+      data.each(&block)
+    end
+
+    def map(&block)
+      data.map(&block)
+    end
+
+    def next_page
+      page_info = json.dig(
+        "#{method_name}_response".to_sym, "#{method_name}_result".to_sym, :pager
+      ).to_h
+      return nil unless page_info[:has_next].to_i == 1
+
+      page_info[:page] + 1
+    end
+
+    def required_params(prepend = 'creds_')
+      {
+        "#{prepend}datetime".to_sym => time,
+        "#{prepend}uuid".to_sym => uuid,
+        "#{prepend}checksum".to_sym => checksum,
+        "#{prepend}method".to_sym => method_name.to_s
+      }
+    end
+
+    private
+
+    # http://memberhub.catalogapi.com/docs/checksums/
+    def checksum
+      Base64.encode64(OpenSSL::HMAC.digest('sha1', CatalogAPI.key, concatted))
+            .gsub("\n", '')
+    end
+
+    def check_status!
+      case response.code.to_i
+      when 200 then response
+      else raise Error, response
+      end
+    end
+
+    def concatted
+      @concatted ||= "#{method_name}#{uuid}#{time}"
+    end
+
+    def time
+      @time ||= Time.now.utc.iso8601
+    end
+
+    def uuid
+      @uuid ||= SecureRandom.uuid
+    end
+  end
+end

data/lib/catalogapi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CatalogAPI
+  VERSION = '0.1.0rc1'
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: catalogapi
+version: !ruby/object:Gem::Version
+  version: 0.1.0rc1
+platform: ruby
+authors:
+- davidrichey
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: Simple ruby library to interact with the http://catalogapi.com/ API
+email:
+- david.richey@memberhub.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- catalogapi.gemspec
+- lib/catalogapi.rb
+- lib/catalogapi/catalog.rb
+- lib/catalogapi/category.rb
+- lib/catalogapi/item.rb
+- lib/catalogapi/order.rb
+- lib/catalogapi/request.rb
+- lib/catalogapi/version.rb
+homepage: http://github.com/memberhubteam/catalogapi
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: http://github.com/memberhubteam/catalogapi
+  source_code_uri: http://github.com/memberhubteam/catalogapi
+  changelog_uri: http://github.com/memberhubteam/catalogapi/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Ruby gem that wraps http://catalogapi.com/ API
+test_files: []