easypost 4.13.0 → 5.0.0

data/lib/easypost/services/pickup.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::Pickup < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::Pickup
+
+  # Create a Pickup object
+  def create(params = {})
+    wrapped_params = { pickup: params }
+    @client.make_request(:post, 'pickups', MODEL_CLASS, wrapped_params)
+  end
+
+  # Retrieve a Pickup object
+  def retrieve(id)
+    @client.make_request(:get, "pickups/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve all Pickup objects
+  def all(params = {})
+    @client.make_request(:get, 'pickups', MODEL_CLASS, params)
+  end
+
+  # Buy a Pickup
+  def buy(id, params = {})
+    if params.instance_of?(EasyPost::Models::PickupRate)
+      params = { carrier: params[:carrier], service: params[:service] }
+    end
+
+    @client.make_request(:post, "pickups/#{id}/buy", MODEL_CLASS, params)
+  end
+
+  # Cancel a Pickup
+  def cancel(id, params = {})
+    @client.make_request(:post, "pickups/#{id}/cancel", MODEL_CLASS, params)
+  end
+
+  # Get next page of Pickups
+  def get_next_page(collection, page_size = nil)
+    get_next_page_helper(collection, collection.pickups, 'pickups', MODEL_CLASS, page_size)
+  end
+end

data/lib/easypost/services/rate.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::Rate < EasyPost::Services::Service
+  # Retrieve a Rate
+  def retrieve(id)
+    @client.make_request(:get, "rates/#{id}", EasyPost::Models::Rate)
+  end
+end

data/lib/easypost/services/referral_customer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::ReferralCustomer < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::User
+
+  # Create a referral customer. This function requires the Partner User's API key.
+  def create(params = {})
+    @client.make_request(:post, 'referral_customers', MODEL_CLASS, { user: params })
+  end
+
+  # Update a referral customer. This function requires the Partner User's API key.
+  def update_email(user_id, email)
+    wrapped_params = {
+      user: {
+        email: email,
+      },
+    }
+    @client.make_request(:put, "referral_customers/#{user_id}", MODEL_CLASS, wrapped_params)
+
+    # return true if API succeeds, else an error is throw if it fails.
+    true
+  end
+
+  # Retrieve a list of referral customers. This function requires the Partner User's API key.
+  def all(params = {})
+    @client.make_request(:get, 'referral_customers', MODEL_CLASS, params)
+  end
+
+  # Get the next page of referral customers.
+  def get_next_page(collection, page_size = nil)
+    get_next_page_helper(collection, collection.referral_customers, 'referral_customers', MODEL_CLASS, page_size)
+  end
+
+  # Add credit card to a referral customer. This function requires the ReferralCustomer Customer's API key.
+  def add_credit_card(referral_api_key, number, expiration_month, expiration_year, cvc, priority = 'primary')
+    easypost_stripe_api_key = retrieve_easypost_stripe_api_key
+
+    begin
+      stripe_credit_card_token = create_stripe_token(
+        number,
+        expiration_month,
+        expiration_year,
+        cvc,
+        easypost_stripe_api_key,
+      )
+    rescue StandardError
+      raise EasyPost::Errors::ExternalApiError.new(EasyPost::Constants::STRIPE_CARD_CREATE_FAILED)
+    end
+
+    create_easypost_credit_card(referral_api_key, stripe_credit_card_token, priority)
+  end
+
+  private
+
+  # Retrieve EasyPost's Stripe public API key.
+  def retrieve_easypost_stripe_api_key
+    response = @client.make_request(:get, 'partners/stripe_public_key', EasyPost::Models::EasyPostObject, nil, 'beta')
+    response['public_key']
+  end
+
+  # Get credit card token from Stripe.
+  def create_stripe_token(number, expiration_month, expiration_year,
+                          cvc, easypost_stripe_token)
+    headers = {
+      # This Stripe endpoint only accepts URL form encoded bodies.
+      Authorization: "Bearer #{easypost_stripe_token}",
+      'Content-type': 'application/x-www-form-urlencoded',
+    }
+
+    credit_card_hash = {
+      card: {
+        number: number,
+        exp_month: expiration_month,
+        exp_year: expiration_year,
+        cvc: cvc,
+      },
+    }
+
+    form_encoded_params = EasyPost::InternalUtilities.form_encode_params(credit_card_hash)
+
+    uri = URI.parse('https://api.stripe.com/v1/tokens')
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    request = Net::HTTP::Post.new(uri.request_uri, headers)
+    query = URI.encode_www_form(form_encoded_params)
+
+    response = http.request(request, query)
+    response_json = JSON.parse(response.body)
+    response_json['id']
+  end
+
+  # Submit Stripe credit card token to EasyPost.
+  def create_easypost_credit_card(referral_api_key, stripe_object_id, priority = 'primary')
+    wrapped_params = {
+      credit_card: {
+        stripe_object_id: stripe_object_id,
+        priority: priority,
+      },
+    }
+    referral_client = EasyPost::Client.new(api_key: referral_api_key)
+    referral_client.make_request(:post, 'credit_cards', EasyPost::Models::EasyPostObject, wrapped_params, 'beta')
+  end
+end

data/lib/easypost/services/refund.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::Refund < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::Refund
+
+  # Create a Refund object
+  def create(params = {})
+    wrapped_params = { refund: params }
+    @client.make_request(:post, 'refunds', MODEL_CLASS, wrapped_params)
+  end
+
+  # Retrieve a Refund object
+  def retrieve(id)
+    @client.make_request(:get, "refunds/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve all Refund objects
+  def all(params = {})
+    @client.make_request(:get, 'refunds', MODEL_CLASS, params)
+  end
+
+  # Get the next page of refunds
+  def get_next_page(collection, page_size = nil)
+    get_next_page_helper(collection, collection.refunds, 'refunds', MODEL_CLASS, page_size)
+  end
+end

data/lib/easypost/services/report.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::Report < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::Report
+
+  # Create a Report
+  def create(params = {})
+    unless params[:type]
+      raise ArgumentError, "Missing 'type' parameter in params" # TODO: replace the error in the error-handling overhaul PR
+    end
+
+    type = params.delete(:type)
+    url = "reports/#{type}"
+
+    @client.make_request(:post, url, MODEL_CLASS, params)
+  end
+
+  # Retrieve a Report
+  def retrieve(id)
+    @client.make_request(:get, "reports/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve all Report objects
+  def all(params = {})
+    unless params[:type]
+      raise ArgumentError, "Missing 'type' parameter in params" # TODO: replace the error in the error-handling overhaul PR
+    end
+
+    type = params.delete(:type)
+    url = "reports/#{type}"
+
+    response = @client.make_request(:get, url, MODEL_CLASS, params)
+    response.define_singleton_method(:type) { type }
+    response
+  end
+
+  # Get next page of Report objects
+  def get_next_page(collection, page_size = nil)
+    url = "reports/#{collection.type}"
+    get_next_page_helper(collection, collection.reports, url, MODEL_CLASS, page_size)
+  end
+end

data/lib/easypost/services/scan_form.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::ScanForm < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::ScanForm
+
+  # Create a ScanForm.
+  def create(params = {})
+    @client.make_request(:post, 'scan_forms', MODEL_CLASS, params)
+  end
+
+  # Retrieve a ScanForm.
+  def retrieve(id)
+    @client.make_request(:get, "scan_forms/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve a list of ScanForms
+  def all(params = {})
+    @client.make_request(:get, 'scan_forms', MODEL_CLASS, params)
+  end
+
+  # Get the next page of ScanForms.
+  def get_next_page(collection, page_size = nil)
+    get_next_page_helper(collection, collection.scan_forms, 'scan_forms', MODEL_CLASS, page_size)
+  end
+end

data/lib/easypost/services/shipment.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'set'
+
+class EasyPost::Services::Shipment < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::Shipment
+
+  # Create a Shipment.
+  def create(params = {}, with_carbon_offset = false)
+    wrapped_params = {
+      shipment: params,
+      carbon_offset: with_carbon_offset,
+    }
+
+    @client.make_request(:post, 'shipments', MODEL_CLASS, wrapped_params)
+  end
+
+  # Retrieve a Shipment.
+  def retrieve(id)
+    @client.make_request(:get, "shipments/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve a list of Shipments
+  def all(params = {})
+    response = @client.make_request(:get, 'shipments', MODEL_CLASS, params)
+    response.define_singleton_method(:purchased) { params[:purchased] }
+    response.define_singleton_method(:include_children) { params[:include_children] }
+    response
+  end
+
+  # Get the next page of shipments.
+  def get_next_page(collection, page_size = nil)
+    get_next_page_helper(collection, collection.shipments, 'shipments', MODEL_CLASS, page_size)
+  end
+
+  # Regenerate the rates of a Shipment.
+  def regenerate_rates(id, with_carbon_offset = false)
+    params = { carbon_offset: with_carbon_offset }
+
+    @client.make_request(:post, "shipments/#{id}/rerate", MODEL_CLASS, params)
+  end
+
+  # Get the SmartRates of a Shipment.
+  def get_smart_rates(id)
+    @client.make_request(:get, "shipments/#{id}/smartrate", MODEL_CLASS).result || []
+  end
+
+  # Buy a Shipment.
+  def buy(id, params = {}, with_carbon_offset = false, end_shipper_id = nil)
+    if params.instance_of?(EasyPost::Models::Rate)
+      params = { rate: params.clone }
+    end
+
+    params[:carbon_offset] = params[:with_carbon_offset] || with_carbon_offset
+    params.delete(:with_carbon_offset)
+
+    params[:end_shipper_id] = end_shipper_id if end_shipper_id
+
+    @client.make_request(:post, "shipments/#{id}/buy", MODEL_CLASS, params)
+  end
+
+  # Insure a Shipment.
+  def insure(id, params = {})
+    params = { amount: params } if params.is_a?(Integer) || params.is_a?(Float)
+
+    @client.make_request(:post, "shipments/#{id}/insure", MODEL_CLASS, params)
+  end
+
+  # Refund a Shipment.
+  def refund(id, params = {})
+    @client.make_request(:post, "shipments/#{id}/refund", MODEL_CLASS, params)
+  end
+
+  # Convert the label format of a Shipment.
+  def label(id, params = {})
+    params = { file_format: params } if params.is_a?(String)
+
+    @client.make_request(:get, "shipments/#{id}/label", MODEL_CLASS, params)
+  end
+
+  # Get the lowest SmartRate of a Shipment.
+  def lowest_smart_rate(id, delivery_days, delivery_accuracy)
+    smart_rates = get_smart_rates(id)
+    EasyPost::Util.get_lowest_smart_rate(smart_rates, delivery_days, delivery_accuracy)
+  end
+
+  # Generate a form for a Shipment.
+  def generate_form(id, form_type, form_options = {})
+    params = {}
+    params[:type] = form_type
+    merged_params = params.merge(form_options)
+    wrapped_params = {
+      form: merged_params,
+    }
+
+    @client.make_request(:post, "shipments/#{id}/forms", MODEL_CLASS, wrapped_params)
+  end
+
+  # Retrieves the estimated delivery date of each Rate via SmartRate.
+  def retrieve_estimated_delivery_date(id, planned_ship_date)
+    url = "shipments/#{id}/smartrate/delivery_date"
+    params = { planned_ship_date: planned_ship_date }
+
+    @client.make_request(:get, url, MODEL_CLASS, params).rates
+  end
+end

data/lib/easypost/services/tracker.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::Tracker < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::Tracker
+
+  # Create a Tracker
+  def create(params = {})
+    wrapped_params = { tracker: params }
+
+    @client.make_request(:post, 'trackers', MODEL_CLASS, wrapped_params)
+  end
+
+  # Retrieve a Tracker
+  def retrieve(id)
+    @client.make_request(:get, "trackers/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve a list of Trackers
+  def all(params)
+    response = @client.make_request(:get, 'trackers', MODEL_CLASS, params)
+    response.define_singleton_method(:tracking_code) { params[:tracking_code] }
+    response.define_singleton_method(:carrier) { params[:carrier] }
+    response
+  end
+
+  # Create multiple Tracker objects in bulk.
+  def create_list(params = {})
+    wrapped_params = { 'trackers' => params }
+
+    @client.make_request(:post, 'trackers/create_list', MODEL_CLASS, wrapped_params)
+    true # This endpoint does not return a response so we return true here instead
+  end
+
+  # Get the next page of trackers.
+  def get_next_page(collection, page_size = nil)
+    get_next_page_helper(collection, collection.trackers, 'trackers', MODEL_CLASS, page_size)
+  end
+end

data/lib/easypost/services/user.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::User < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::User
+
+  # Create a child User.
+  def create(params = {})
+    @client.make_request(:post, 'users', MODEL_CLASS, params)
+  end
+
+  # Retrieve a user
+  def retrieve(id)
+    @client.make_request(:get, "users/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve the authenticated User.
+  def retrieve_me
+    @client.make_request(:get, 'users', MODEL_CLASS)
+  end
+
+  # Update a User
+  def update(id, params = {})
+    @client.make_request(:put, "users/#{id}", MODEL_CLASS, params)
+  end
+
+  # Delete a User
+  def delete(id)
+    @client.make_request(:delete, "users/#{id}")
+
+    # Return true if succeeds, an error will be thrown if it fails
+    true
+  end
+
+  # Retrieve a list of all ApiKey objects.
+  def all_api_keys
+    @client.make_request(:get, 'api_keys', EasyPost::Models::ApiKey)
+  end
+
+  # Retrieve a list of ApiKey objects (works for the authenticated user or a child user).
+  def api_keys(id)
+    api_keys = all_api_keys
+
+    if api_keys.id == id
+      # This function was called on the authenticated user
+      my_api_keys = api_keys.keys
+    else
+      # This function was called on a child user (authenticated as parent, only return this child user's details).
+      my_api_keys = []
+      api_keys.children.each do |child|
+        if child.id == id
+          my_api_keys = child.keys
+          break
+        end
+      end
+    end
+
+    my_api_keys
+  end
+
+  # Update the Brand of a User.
+  def update_brand(id, params = {})
+    wrapped_params = { brand: params }
+
+    @client.make_request(:get, "users/#{id}/brand", EasyPost::Models::Brand, wrapped_params)
+  end
+end

data/lib/easypost/services/webhook.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class EasyPost::Services::Webhook < EasyPost::Services::Service
+  MODEL_CLASS = EasyPost::Models::Webhook
+
+  # Create a Webhook.
+  def create(params = {})
+    wrapped_params = { webhook: params }
+    @client.make_request(:post, 'webhooks', MODEL_CLASS, wrapped_params)
+  end
+
+  # Retrieve a Webhook
+  def retrieve(id)
+    @client.make_request(:get, "webhooks/#{id}", MODEL_CLASS)
+  end
+
+  # Retrieve a list of Webhooks
+  def all(params = {})
+    @client.make_request(:get, 'webhooks', MODEL_CLASS, params)
+  end
+
+  # Update a Webhook.
+  def update(id, params = {})
+    @client.make_request(:patch, "webhooks/#{id}", MODEL_CLASS, params)
+  end
+
+  # Delete a Webhook.
+  def delete(id)
+    @client.make_request(:delete, "webhooks/#{id}")
+
+    # Return true if succeeds, an error will be thrown if it fails
+    true
+  end
+end

data/lib/easypost/services.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EasyPost::Services
+end
+
+require_relative 'models'
+require_relative 'services/base' # Must be imported first before the rest of child services
+require_relative 'services/address'
+require_relative 'services/api_key'
+require_relative 'services/batch'
+require_relative 'services/beta_rate'
+require_relative 'services/beta_referral_customer'
+require_relative 'services/billing'
+require_relative 'services/carrier_account'
+require_relative 'services/carrier_metadata'
+require_relative 'services/customs_info'
+require_relative 'services/customs_item'
+require_relative 'services/end_shipper'
+require_relative 'services/event'
+require_relative 'services/insurance'
+require_relative 'services/order'
+require_relative 'services/parcel'
+require_relative 'services/pickup'
+require_relative 'services/rate'
+require_relative 'services/referral_customer'
+require_relative 'services/refund'
+require_relative 'services/report'
+require_relative 'services/scan_form'
+require_relative 'services/shipment'
+require_relative 'services/tracker'
+require_relative 'services/user'
+require_relative 'services/webhook'