shopify_api 8.1.0 → 9.0.0

data/lib/shopify_api/graphql/task.rake

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+require 'fileutils'
+
+namespace :shopify_api do
+  namespace :graphql do
+    desc 'Dumps a local JSON schema file of the Shopify Admin API'
+    task :dump do
+      usage = <<~USAGE
+
+        Usage: rake shopify_api:graphql:dump [<args>]
+
+        Dumps a local JSON schema file of the Shopify Admin API. The schema is specific to an
+        API version and authentication is required (either OAuth or private app).
+
+        Dump the schema file for the 2020-01 API version using private app authentication:
+          $ rake shopify_api:graphql:dump SHOP_URL="https://API_KEY:PASSWORD@SHOP_NAME.myshopify.com" API_VERSION=2020-01
+
+        Dump the schema file for the unstable API version using an OAuth access token:
+          $ rake shopify_api:graphql:dump SHOP_DOMAIN=SHOP_NAME.myshopify.com ACCESS_TOKEN=abc API_VERSION=unstable
+
+        See https://github.com/Shopify/shopify_api#getting-started for more
+        details on getting started with authenticated API calls.
+
+        Arguments:
+          ACCESS_TOKEN  OAuth access token (shop specific)
+          API_VERSION   API version handle [example: 2020-01]
+          SHOP_DOMAIN   Shop domain (without path) [example: SHOP_NAME.myshopify.com]
+          SHOP_URL      Shop URL for private apps [example: https://API_KEY:PASSWORD@SHOP_NAME.myshopify.com]
+      USAGE
+
+      access_token = ENV['ACCESS_TOKEN'] || ENV['access_token']
+      api_version = ENV['API_VERSION'] || ENV['api_version']
+      shop_url = ENV['SHOP_URL'] || ENV['shop_url']
+      shop_domain = ENV['SHOP_DOMAIN'] || ENV['shop_domain']
+
+      unless access_token || api_version || shop_url || shop_domain
+        puts usage
+        exit(1)
+      end
+
+      unless shop_url || shop_domain
+        puts 'Error: either SHOP_DOMAIN or SHOP_URL is required for authentication'
+        puts usage
+        exit(1)
+      end
+
+      if shop_url && shop_domain
+        puts 'Error: SHOP_DOMAIN and SHOP_URL cannot be used together. Use one or the other for authentication.'
+        puts usage
+        exit(1)
+      end
+
+      if shop_domain && !access_token
+        puts 'Error: ACCESS_TOKEN required when SHOP_DOMAIN is used'
+        puts usage
+        exit(1)
+      end
+
+      unless api_version
+        puts 'Error: API_VERSION required. Example: 2020-01'
+        puts usage
+        exit(1)
+      end
+
+      Rake::Task['environment'].invoke if Rake::Task.task_defined?('environment')
+
+      ShopifyAPI::ApiVersion.fetch_known_versions
+      ShopifyAPI::ApiVersion.version_lookup_mode = :raise_on_unknown
+
+      shopify_session = ShopifyAPI::Session.new(domain: shop_domain, token: access_token, api_version: api_version)
+      ShopifyAPI::Base.activate_session(shopify_session)
+
+      if shop_url
+        ShopifyAPI::Base.site = shop_url
+      end
+
+      puts "Fetching schema for #{ShopifyAPI::Base.api_version.handle} API version..."
+
+      client = ShopifyAPI::GraphQL::HTTPClient.new(ShopifyAPI::Base.api_version)
+      document = GraphQL.parse('{ __schema { queryType { name } } }')
+      response = client.execute(document: document).to_h
+
+      unless response['data'].present?
+        puts "Error: failed to query the API."
+        puts "Response: #{response}"
+        puts 'Ensure your SHOP_DOMAIN or SHOP_URL are valid and you have valid authentication credentials.'
+        puts usage
+        exit(1)
+      end
+
+      schema_location = ShopifyAPI::GraphQL.schema_location
+      FileUtils.mkdir_p(schema_location) unless Dir.exist?(schema_location)
+
+      schema_file = schema_location.join("#{api_version}.json")
+      GraphQL::Client.dump_schema(client, schema_file.to_s)
+
+      puts "Wrote file #{schema_file}"
+    end
+  end
+end

data/lib/shopify_api/resources/assigned_fulfillment_order.rb

@@ -0,0 +1,16 @@
+module ShopifyAPI
+  class AssignedFulfillmentOrder < Base
+
+    def initialize(attributes = {}, persisted = false)
+      ShopifyAPI::Base.version_validation!(FulfillmentOrder::MINIMUM_VERSION)
+      super(attributes, persisted)
+    end
+
+    def self.find(scope, *args)
+      ShopifyAPI::Base.version_validation!(FulfillmentOrder::MINIMUM_VERSION)
+
+      assigned_fulfillment_orders = super(scope, *args)
+      assigned_fulfillment_orders.map { |afo| FulfillmentOrder.new(afo.attributes) }
+    end
+  end
+end

data/lib/shopify_api/resources/base.rb

@@ -132,6 +132,14 @@ module ShopifyAPI
         !!early_july_pagination
       end
 
+      def version_validation!(minimum_version)
+        available_in_version = ShopifyAPI::ApiVersion.find_version(minimum_version)
+
+        unless ShopifyAPI::Base.api_version >= available_in_version
+          raise NotImplementedError, "The minimum supported version is #{minimum_version}."
+        end
+      end
+
       private
 
       attr_accessor :early_july_pagination

data/lib/shopify_api/resources/fulfillment.rb

@@ -9,5 +9,39 @@ module ShopifyAPI
     def cancel; load_attributes_from_response(post(:cancel, {}, only_id)); end
     def complete; load_attributes_from_response(post(:complete, {}, only_id)); end
     def open; load_attributes_from_response(post(:open, {}, only_id)); end
+
+    def order_id=(order_id)
+      prefix_options[:order_id] = order_id
+    end
+
+    def load(attributes, remove_root = false, persisted = false)
+      order_id = attributes['order_id']
+      prefix_options[:order_id] = order_id if order_id
+      super(attributes, remove_root, persisted)
+    end
+
+    def save
+      if prefix_options[:order_id].present?
+        super
+      else
+        line_items = attributes['line_items_by_fulfillment_order'] || attributes[:line_items_by_fulfillment_order]
+        if line_items.blank?
+          raise ShopifyAPI::ValidationException,
+                "either 'line_items_by_fulfillment_order' or prefix_options[:order_id] is required"
+        end
+
+        fulfillmentV2 = FulfillmentV2.new(attributes)
+        result = fulfillmentV2.save
+        load(fulfillmentV2.attributes, false, true)
+        result
+      end
+    end
+
+    def update_tracking(tracking_info:, notify_customer:)
+      fulfillmentV2 = FulfillmentV2.new(attributes)
+      result = fulfillmentV2.update_tracking(tracking_info: tracking_info, notify_customer: notify_customer)
+      load(fulfillmentV2.attributes, false, true)
+      result
+    end
   end
 end

data/lib/shopify_api/resources/fulfillment_order.rb

@@ -0,0 +1,137 @@
+module ShopifyAPI
+  class FulfillmentOrder < Base
+    MINIMUM_VERSION = '2020-01'
+
+    def initialize(attributes = {}, persisted = false)
+      ShopifyAPI::Base.version_validation!(MINIMUM_VERSION)
+      super(attributes, persisted)
+    end
+
+    def self.find(scope, *args)
+      ShopifyAPI::Base.version_validation!(MINIMUM_VERSION)
+
+      if scope == :all
+        order_id = args.first&.dig(:params, :order_id)
+        raise ShopifyAPI::ValidationException, "'order_id' is required" if order_id.blank?
+
+        order = ::ShopifyAPI::Order.new(id: order_id)
+        order.fulfillment_orders(args.first[:params].except(:order_id))
+      else
+        super(scope, *args)
+      end
+    end
+
+    def fulfillments(options = {})
+      fulfillment_hashes = get(:fulfillments, options)
+      fulfillment_hashes.map { |fulfillment_hash| Fulfillment.new(fulfillment_hash) }
+    end
+
+    def locations_for_move
+      locations_for_move_hashes = get(:locations_for_move, {})
+
+      locations_for_move_hashes.map do |locations_for_move_hash|
+        FulfillmentOrderLocationsForMove.new(locations_for_move_hash)
+      end
+    end
+
+    def move(new_location_id:)
+      body = {
+        fulfillment_order: {
+          new_location_id: new_location_id
+        }
+      }
+      keyed_fulfillment_orders = keyed_fulfillment_orders_from_response(post(:move, {}, body.to_json))
+      load_keyed_fulfillment_order(keyed_fulfillment_orders, 'original_fulfillment_order')
+      keyed_fulfillment_orders
+    end
+
+    def cancel
+      keyed_fulfillment_orders = keyed_fulfillment_orders_from_response(post(:cancel, {}, only_id))
+      load_keyed_fulfillment_order(keyed_fulfillment_orders, 'fulfillment_order')
+      keyed_fulfillment_orders
+    end
+
+    def close(message: nil)
+      body = {
+        fulfillment_order: {
+          message: message
+        }
+      }
+      load_attributes_from_response(post(:close, {}, body.to_json))
+    end
+
+    def request_fulfillment(fulfillment_order_line_items: nil, message: nil)
+      body = {
+        fulfillment_request: {
+          fulfillment_order_line_items: fulfillment_order_line_items,
+          message: message
+        }
+      }
+      keyed_fulfillment_orders = keyed_fulfillment_orders_from_response(post(:fulfillment_request, {}, body.to_json))
+      load_keyed_fulfillment_order(keyed_fulfillment_orders, 'original_fulfillment_order')
+      keyed_fulfillment_orders
+    end
+
+    def accept_fulfillment_request(message: nil)
+      body = {
+        fulfillment_request: {
+          message: message
+        }
+      }
+      load_attributes_from_response(post('fulfillment_request/accept', {}, body.to_json))
+    end
+
+    def reject_fulfillment_request(message: nil)
+      body = {
+        fulfillment_request: {
+          message: message
+        }
+      }
+      load_attributes_from_response(post('fulfillment_request/reject', {}, body.to_json))
+    end
+
+    def request_cancellation(message: nil)
+      body = {
+        cancellation_request: {
+          message: message
+        }
+      }
+      load_attributes_from_response(post(:cancellation_request, {}, body.to_json))
+    end
+
+    def accept_cancellation_request(message: nil)
+      body = {
+        cancellation_request: {
+          message: message
+        }
+      }
+      load_attributes_from_response(post('cancellation_request/accept', {}, body.to_json))
+    end
+
+    def reject_cancellation_request(message: nil)
+      body = {
+        cancellation_request: {
+          message: message
+        }
+      }
+      load_attributes_from_response(post('cancellation_request/reject', {}, body.to_json))
+    end
+
+    private
+
+    def load_keyed_fulfillment_order(keyed_fulfillment_orders, key)
+      if keyed_fulfillment_orders[key]&.attributes
+        load(keyed_fulfillment_orders[key].attributes, false, true)
+      end
+    end
+
+    def keyed_fulfillment_orders_from_response(response)
+      return load_attributes_from_response(response) if response.code != '200'
+
+      keyed_fulfillment_orders = ActiveSupport::JSON.decode(response.body)
+      keyed_fulfillment_orders.transform_values do |fulfillment_order_attributes|
+        FulfillmentOrder.new(fulfillment_order_attributes) if fulfillment_order_attributes
+      end
+    end
+  end
+end

data/lib/shopify_api/resources/fulfillment_order_locations_for_move.rb

@@ -0,0 +1,4 @@
+module ShopifyAPI
+  class FulfillmentOrderLocationsForMove < Base
+  end
+end

data/lib/shopify_api/resources/fulfillment_v2.rb

@@ -0,0 +1,20 @@
+module ShopifyAPI
+  class FulfillmentV2 < Base
+    self.element_name = 'fulfillment'
+
+    def initialize(attributes = {}, persisted = false)
+      ShopifyAPI::Base.version_validation!(FulfillmentOrder::MINIMUM_VERSION)
+      super(attributes, persisted)
+    end
+
+    def update_tracking(tracking_info:, notify_customer:)
+      body = {
+        fulfillment: {
+          tracking_info: tracking_info,
+          notify_customer: notify_customer
+        }
+      }
+      load_attributes_from_response(post(:update_tracking, {}, body.to_json))
+    end
+  end
+end

data/lib/shopify_api/resources/order.rb

@@ -30,6 +30,13 @@ module ShopifyAPI
       Transaction.create(capture_transaction)
     end
 
+    def fulfillment_orders(options = {})
+      ShopifyAPI::Base.version_validation!(FulfillmentOrder::MINIMUM_VERSION)
+
+      fulfillment_order_hashes = get(:fulfillment_orders, options)
+      fulfillment_order_hashes.map { |fulfillment_order_hash| FulfillmentOrder.new(fulfillment_order_hash) }
+    end
+
     class ClientDetails < Base
     end
   end

data/lib/shopify_api/session.rb

@@ -91,9 +91,9 @@ module ShopifyAPI
       self.extra = extra
     end
 
-    def create_permission_url(scope, redirect_uri = nil)
-      params = {:client_id => api_key, :scope => scope.join(',')}
-      params[:redirect_uri] = redirect_uri if redirect_uri
+    def create_permission_url(scope, redirect_uri, options = {})
+      params = { client_id: api_key, scope: scope.join(','), redirect_uri: redirect_uri }
+      params[:state] = options[:state] if options[:state]
       construct_oauth_url("authorize", params)
     end
 

data/lib/shopify_api/version.rb

@@ -1,3 +1,3 @@
 module ShopifyAPI
-  VERSION = "8.1.0"
+  VERSION = "9.0.0"
 end

data/test/assigned_fulfillment_order_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+require 'fulfillment_order_test_helper'
+
+class AssignedFulFillmentOrderTest < Test::Unit::TestCase
+  include FulfillmentOrderTestHelper
+
+  def setup
+    super
+    @url_prefix = url_prefix_for_activated_session_for('2020-01')
+    @fulfillment_order_fixture = load_fixture('assigned_fulfillment_orders')
+  end
+
+  context "AssignedFulfillmentOrder" do
+    context ".new" do
+      should "raise NotImplementedError when api_version is older than 2020-01" do
+        url_prefix_for_activated_session_for('2019-10')
+
+        assert_raises NotImplementedError do
+          ShopifyAPI::AssignedFulfillmentOrder.new(ActiveSupport::JSON.decode(@fulfillment_order_fixture))
+        end
+      end
+    end
+
+    context "#all" do
+      should "raise NotImplementedError when api_version is older than 2020-01" do
+        @url_prefix = url_prefix_for_activated_session_for('2019-10')
+
+        fake 'assigned_fulfillment_orders',
+          url: "#{@url_prefix}/assigned_fulfillment_orders.json",
+          method: :get,
+          body: @fulfillment_order_fixture,
+          extension: false
+
+        assert_raises NotImplementedError do
+          ShopifyAPI::AssignedFulfillmentOrder.all(params: { assigned_status: 'cancellation_requested' })
+        end
+      end
+
+      should "list assigned fulfillment orders by assigned_status" do
+        fake 'assigned_fulfillment_orders',
+          url: "#{@url_prefix}/assigned_fulfillment_orders.json?assigned_status=cancellation_requested",
+          method: :get,
+          body: @fulfillment_order_fixture,
+          extension: false
+
+        assigned_fulfillment_orders = ShopifyAPI::AssignedFulfillmentOrder.all(
+            params: { assigned_status: 'cancellation_requested' }
+        )
+
+        assert_equal 2, assigned_fulfillment_orders.count
+        assigned_fulfillment_orders.each do |fulfillment_order|
+          assert fulfillment_order.is_a?(ShopifyAPI::FulfillmentOrder)
+          assert_equal 'in_progress', fulfillment_order.status
+          assert_equal 'cancellation_accepted', fulfillment_order.request_status
+        end
+      end
+
+      should "be able to list assigned fulfillment orders by location_ids" do
+        assigned_location_id = 905684977
+        fake 'assigned_fulfillment_orders',
+          url: "#{@url_prefix}/assigned_fulfillment_orders.json?location_ids%5B%5D=#{assigned_location_id}",
+          method: :get,
+          body: @fulfillment_order_fixture, extension: false
+
+        assigned_fulfillment_orders = ShopifyAPI::AssignedFulfillmentOrder.all(
+            params: { location_ids: [assigned_location_id] }
+        )
+
+        assert_equal 2, assigned_fulfillment_orders.count
+        assigned_fulfillment_orders.each do |fulfillment_order|
+          assert fulfillment_order.is_a?(ShopifyAPI::FulfillmentOrder)
+          assert_equal assigned_location_id, fulfillment_order.assigned_location_id
+        end
+      end
+    end
+  end
+end