recurly 2.19.14 → 3.0.0.beta.1

data/lib/recurly/subscription.rb

@@ -1,374 +0,0 @@
-module Recurly
-  class Subscription < Resource
-    require 'recurly/subscription/add_ons'
-
-    # @macro [attach] scope
-    #   @scope class
-    #   @return [Pager<Subscription>] A pager that yields +$1+ subscriptions.
-    scope :active,   state: :active
-    scope :canceled, state: :canceled
-    scope :expired,  state: :expired
-    scope :future,   state: :future
-    # @return [Pager<Subscription>] A pager that yields subscriptions in
-    #   trials.
-    scope :in_trial, state: :in_trial
-    # @return [Pager<Subscription>] A pager that yields active, canceled, and
-    #   future subscriptions.
-    scope :live,     state: :live
-    scope :past_due, state: :past_due
-
-    # @return [Pager<Redemption>, []]
-    has_many :redemptions
-
-    # @return [[CustomField], []]
-    has_many :custom_fields, class_name: :CustomField, readonly: false
-
-    # @return [[SubscriptionRampInterval], nil]
-    has_many :ramp_intervals, class_name: :SubscriptionRampInterval
-
-    # @return [Account]
-    belongs_to :account
-
-    # @return [Plan]
-    belongs_to :plan
-
-    # @return [Invoice, nil]
-    has_one :invoice
-
-    # @return [GiftCard, nil]
-    has_one :gift_card
-
-    # @return [ShippingAddress, nil]
-    has_one :shipping_address, class_name: :ShippingAddress, readonly: false
-
-    # @return [InvoiceCollection, nil]
-    has_one :invoice_collection, class_name: :InvoiceCollection, readonly: true
-
-    # @return [BillingInfo, nil]
-    has_one :billing_info, class_name: :BillingInfo, readonly: false
-
-    define_attribute_methods %w(
-      uuid
-      state
-      unit_amount_in_cents
-      cost_in_cents
-      currency
-      quantity
-      updated_at
-      activated_at
-      canceled_at
-      expires_at
-      current_period_started_at
-      current_period_ends_at
-      trial_started_at
-      trial_ends_at
-      pending_subscription
-      subscription_add_ons
-      coupon_code
-      coupon_codes
-      ramp_intervals
-      total_billing_cycles
-      remaining_billing_cycles
-      net_terms
-      net_terms_type
-      collection_method
-      po_number
-      tax_in_cents
-      tax_type
-      tax_region
-      tax_rate
-      tax_inclusive
-      bulk
-      bank_account_authorized_at
-      terms_and_conditions
-      customer_notes
-      vat_reverse_charge_notes
-      address
-      revenue_schedule_type
-      shipping_address_id
-      shipping_method_code
-      shipping_amount_in_cents
-      timeframe
-      started_with_gift
-      converted_at
-      billing_info_uuid
-      no_billing_info_reason
-      imported_trial
-      credit_customer_notes
-      remaining_pause_cycles
-      paused_at
-      auto_renew
-      renewal_billing_cycles
-      first_billing_date
-      first_bill_date
-      next_bill_date
-      current_term_started_at
-      current_term_ends_at
-      total_amount_in_cents
-      resume_at
-      gateway_code
-      transaction_type
-      action_result
-      proration_settings
-    )
-    alias to_param uuid
-
-    def self.preview(attributes = {})
-      new(attributes) { |record| record.preview }
-    end
-
-    def preview
-      clear_errors
-      @response = API.send(:post, "#{path}/preview", to_xml)
-      reload response
-    rescue API::UnprocessableEntity => e
-      apply_errors e
-    end
-
-    # @return [Subscription] A new subscription.
-    def initialize(attributes = {})
-      super({ :currency => Recurly.default_currency }.merge attributes)
-    end
-
-    # Assign a Plan resource (rather than a plan code).
-    #
-    # @param plan [Plan]
-    def plan= plan
-      self.plan_code = (plan.plan_code if plan.respond_to? :plan_code)
-      attributes[:plan] = plan
-    end
-
-    def plan_code
-      self[:plan_code] ||= (plan.plan_code if plan.respond_to? :plan_code)
-    end
-
-    def plan_code= plan_code
-      self[:plan_code] = plan_code
-    end
-
-    # Assign a Coupon resource (rather than a coupon code).
-    #
-    # @param coupon [Coupon]
-    def coupon= coupon
-      self.coupon_code = (
-        coupon.coupon_code if coupon.respond_to? :coupon_code
-      )
-      attributes[:coupon] = coupon
-    end
-
-    # Assign Coupon resources (rather than coupon codes).
-    #
-    # @param coupons [[Coupons]]
-    def coupons= coupons
-      self.coupon_codes = coupons.map do |coupon|
-        coupon.coupon_code if coupon.respond_to? :coupon_code
-      end.compact
-      attributes[:coupons] = coupons
-    end
-
-    # @return [AddOns]
-    def subscription_add_ons
-      self[:subscription_add_ons] ||= AddOns.new self, super
-    end
-    alias add_ons subscription_add_ons
-
-    # Assign an array of subscription add-ons.
-    def subscription_add_ons= subscription_add_ons
-      super AddOns.new self, subscription_add_ons
-    end
-    alias add_ons= subscription_add_ons=
-
-    def pending_subscription
-      sub = self[:pending_subscription]
-      sub.tap {|e| e.currency = currency} if sub.is_a? Subscription
-    end
-
-    # Convert free trial to paid subscription when transaction_type is "moto"
-    # which stands for "Mail Order Telephone Order".
-    #
-    # @return true
-    def convert_trial_moto()
-      builder = XML.new("<subscription/>")
-      builder.add_element('transaction_type', "moto")
-      reload API.put("#{uri}/convert_trial", builder.to_s)
-      true
-    end
-
-    # Convert free trial to paid subscription. Optionally uses a 3ds token.
-    #
-    # @param three_d_secure_action_result_token_id [String] three_d_secure_action_result_token_id
-    #   returned by Recurly.js referencing the result of the 3DS authentication for PSD2
-    # @return true when payment is accepted
-    def convert_trial(three_d_secure_action_result_token_id = nil)
-      body = if three_d_secure_action_result_token_id != nil
-        builder = Recurly::XML.new("<subscription/>")
-        account = builder.add_element('account')
-        billing_info = account.add_element('billing_info')
-        billing_info.add_element('three_d_secure_action_result_token_id', three_d_secure_action_result_token_id)
-        builder.to_s
-      end
-
-      reload API.put("#{uri}/convert_trial", body)
-      true
-    end
-
-    # Cancel a subscription so that it will not renew.
-    #
-    # @param [String] optional timeframe. Choose one of "bill_date" or "term_end"
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the subscription is not active).
-    # @example
-    #   account = Account.find account_code
-    #   subscription = account.subscriptions.first
-    #   subscription.cancel # => true
-    def cancel(timeframe = nil)
-      return false unless link? :cancel
-      params = timeframe.nil? ? {} : { 'timeframe': timeframe }
-      reload follow_link :cancel, params: params
-      true
-    end
-
-    # An array of acceptable refund types.
-    REFUND_TYPES = ['none', 'full', 'partial'].freeze
-
-    # Immediately terminate a subscription (with optional refund).
-    #
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the subscription is not active).
-    # @param refund_type [:none, :full, :partial] <tt>:none</tt> terminates the
-    #   subscription with no refund (the default), <tt>:full</tt> refunds the
-    #   subscription in full, and <tt>:partial</tt> refunds the subscription in
-    #   part.
-    # @raise [ArgumentError] Invalid +refund_type+.
-    # @example
-    #   account = Account.find account_code
-    #   subscription = account.subscriptions.first
-    #   subscription.terminate(:partial) # => true
-    def terminate refund_type = :none
-      return false unless link? :terminate
-      unless REFUND_TYPES.include? refund_type.to_s
-        raise ArgumentError, "refund must be one of: #{REFUND_TYPES.join ', '}"
-      end
-      reload follow_link(:terminate, :params => { :refund => refund_type })
-      true
-    end
-    alias destroy terminate
-
-    # Reactivate a subscription.
-    #
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the subscription is already active), and may raise an exception
-    #   if the reactivation fails.
-    def reactivate
-      return false unless link? :reactivate
-      reload follow_link :reactivate
-      true
-    end
-
-    # Postpone a subscription's renewal date.
-    #
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    #   (e.g., the subscription is not active).
-    # @param next_bill_date [Time] when the subscription should renew.
-    # @param bulk [boolean] set to true for bulk updates (bypassing 60 second wait).
-    def postpone next_bill_date, bulk=false
-      return false unless link? :postpone
-      reload follow_link(:postpone,
-        :params => { :next_bill_date => next_bill_date, :bulk => bulk }
-      )
-      true
-    end
-
-    # Update the notes sections of the subscription. This endpoint also allows you to
-    # update the custom fields.
-    #
-    # @example
-    #   subscription.custom_fields.first.value = nil
-    #   subscription.update_notes(terms_and_conditions: 'New T&C')
-    #   #=>
-    #   #   <subscription>
-    #   #     <custom_fields><custom_field><name>food</name><value nil="nil"/><custom_field></custom_fields>
-    #   #     <terms_and_conditions>New T&C</terms_and_conditions>
-    #   #   </subscription>
-    #   # it's also okay to call without notes
-    #   subscription.update_notes({})
-    #
-    # @param notes [Hash] should be the notes parameters you wish to update
-    # @return [true, false] +true+ when successful, +false+ when unable to
-    def update_notes(notes)
-      return false unless link? :notes
-      self.attributes = notes
-      reload follow_link(:notes, body: to_xml)
-      true
-    end
-
-    # Pauses a subscription or cancels a scheduled pause.
-    #
-    # * For an active subscription without a pause scheduled already,
-    # this will schedule a pause period to begin at the next renewal
-    # date for the specified number of billing cycles (remaining_pause_cycles).
-    # * When a scheduled pause already exists, this will update the remaining
-    # pause cycles with the new value sent. When zero (0) remaining_pause_cycles
-    # is sent for a subscription with a scheduled pause, the pause will be canceled.
-    # * For a paused subscription, the remaining_pause_cycles will adjust the
-    # length of the current pause period. Sending zero (0) in the remaining_pause_cycles
-    # field will cause the subscription to be resumed at the next renewal date.
-    #
-    # @param remaining_pause_cycles [Integer] The number of billing cycles that the subscription will be paused.
-    # @return true
-    def pause(remaining_pause_cycles)
-      builder = XML.new("<subscription/>")
-      builder.add_element('remaining_pause_cycles', remaining_pause_cycles)
-      reload API.put("#{uri}/pause", builder.to_s)
-      true
-    end
-
-    # Resumes a paused subscription.
-    #
-    # For a paused subscription, this will immediately resume the subscription
-    # from the pause, produce an invoice, and return the newly resumed subscription.
-    # Any at-renewal subscription changes will be immediately applied
-    # when the subscription resumes.
-    #
-    # @return true
-    def resume
-      reload API.put("#{uri}/resume")
-      true
-    end
-
-    # Overrides the behavior of `update_attributes` in Resource class so ensure
-    # all attributes are marked as dirty if the plan code changes
-    def update_attributes attributes = {}
-      clear_attributes_if_plan_code_changed attributes
-      super
-    end
-
-    def update_attributes! attributes = {}
-      clear_attributes_if_plan_code_changed attributes
-      super
-    end
-
-    def signable_attributes
-      super.merge :plan_code => plan_code
-    end
-
-    def changed_attributes
-      attrs = super
-      if custom_fields.any?(&:changed?)
-        attrs['custom_fields'] = custom_fields.select(&:changed?)
-      end
-      attrs
-    end
-
-
-    private
-
-    def clear_attributes_if_plan_code_changed attributes
-      if attributes[:plan_code] != plan_code
-        attributes.each do |key, value|
-          self.attributes[key.to_s] = nil
-        end
-      end
-    end
-  end
-end

data/lib/recurly/subscription_add_on.rb

@@ -1,64 +0,0 @@
-module Recurly
-  class SubscriptionAddOn < Resource
-    # @return [MeasuredUnit]
-    has_one :measured_unit
-
-    # @return [Pager<Usage>, []]
-    has_many :usage
-
-    # @return [[Tier], []]
-    has_many :tiers, class_name: :Tier, readonly: false
-
-    # @return [[PercentageTier], []]
-    has_many :percentage_tiers, class_name: :SubAddOnPercentageTier, readonly: false
-
-    define_attribute_methods %w(
-      add_on_code
-      quantity
-      unit_amount_in_cents
-      add_on_type
-      usage_type
-      usage_percentage
-      usage_timeframe
-      usage_calculation_type
-      add_on_source
-    )
-
-    attr_reader :subscription
-
-    def initialize add_on = nil, subscription = nil
-      super()
-
-      case add_on
-      when AddOn, SubscriptionAddOn
-        @add_on = add_on if add_on.is_a? AddOn
-        self.add_on_code = add_on.add_on_code
-        self.quantity = add_on.quantity
-        if add_on.unit_amount_in_cents
-          self.unit_amount_in_cents = add_on.unit_amount_in_cents.to_i
-        end
-        if add_on.respond_to? :add_on_source
-          self.add_on_source = add_on.add_on_source
-        end
-        self.tiers = add_on.tiers if add_on.tiers.any?
-        self.percentage_tiers = add_on.percentage_tiers if add_on.percentage_tiers.any?
-      when Hash
-        self.attributes = add_on
-      when String, Symbol
-        self.add_on_code = add_on
-      end
-
-      self.add_on_code = add_on_code.to_s
-
-      @subscription = subscription
-    end
-
-    def add_on
-      @add_on ||= subscription.plan.add_ons.find add_on_code
-    end
-
-    def currency
-      subscription.currency if subscription
-    end
-  end
-end

data/lib/recurly/subscription_ramp_interval.rb

@@ -1,12 +0,0 @@
-module Recurly
-  class SubscriptionRampInterval < Resource
-    belongs_to :subscription
-
-    define_attribute_methods %w(
-      starting_billing_cycle
-      unit_amount_in_cents
-      starting_on
-      ending_on
-    )
-  end
-end

data/lib/recurly/tax_detail.rb

@@ -1,18 +0,0 @@
-require 'bigdecimal'
-
-module Recurly
-  class TaxDetail < Resource
-    define_attribute_methods %w(
-      name
-      type
-      tax_rate
-      tax_in_cents
-      level
-      billable
-      tax_type
-      tax_region
-    )
-
-    embedded! true
-  end
-end

data/lib/recurly/tax_type.rb

@@ -1,13 +0,0 @@
-module Recurly
-  class TaxType < Resource
-    define_attribute_methods %w(
-      description
-      tax_in_cents
-      type
-      juris_details
-      tax_classification
-    )
-
-    embedded! true
-  end
-end

data/lib/recurly/tier.rb

@@ -1,18 +0,0 @@
-module Recurly
-  class Tier < Resource
-
-    belongs_to :add_on
-    belongs_to :subscription_add_on
-
-    define_attribute_methods %w(
-      ending_quantity
-      unit_amount_in_cents
-    )
-
-    def xml_keys
-      attributes.keys
-    end
-
-    embedded! true
-  end
-end

data/lib/recurly/transaction/errors.rb

@@ -1,119 +0,0 @@
-module Recurly
-  class Transaction < Resource
-    # The base error class for transaction errors, raised when a transaction
-    # fails.
-    #
-    # Error messages are customer-friendly, though only {DeclinedError}
-    # messages should be a part of the normal API flow (a {ConfigurationError},
-    # for example, is a problem that a customer cannot solve and requires your
-    # attention).
-    #
-    # If a record of the transaction was stored in Recurly, it will be
-    # accessible via {Error#transaction}.
-    #
-    # @example
-    #   begin
-    #     subscription.save!
-    #   rescue Recurly::Resource::Invalid => e
-    #     # Display e.record.errors...
-    #   rescue Recurly::Transaction::DeclinedError => e
-    #     # Display e.message and/or subscription (and associated) errors...
-    #   rescue Recurly::Transaction::RetryableError => e
-    #     # You should be able to attempt to save this again later.
-    #   rescue Recurly::Transaction::Error => e
-    #     # Alert yourself of the issue (i.e., log e.transaction).
-    #     # Display a generic error message.
-    #   end
-    class Error < API::UnprocessableEntity
-      # @return [Transaction] The transaction as returned (or updated) by
-      #   Recurly.
-      attr_reader :transaction
-
-      def initialize request, response, transaction
-        super request, response
-        update_transaction transaction
-      end
-
-      # @return [String] A customer-friendly error message.
-      def to_s
-        xml.text '/errors/transaction_error/customer_message'
-      end
-
-      # @return [String] The transaction error code.
-      def transaction_error_code
-        xml.text '/errors/transaction_error/error_code'
-      end
-
-      def gateway_error_code
-        xml.text '/errors/transaction_error/gateway_error_code'
-      end
-
-      def decline_code
-        xml.text '/errors/transaction_error/decline_code'
-      end
-
-      private
-
-      def update_transaction transaction
-        return unless transaction_xml = xml['/errors/transaction']
-
-        @transaction = transaction
-        transaction = Transaction.from_xml transaction_xml
-        if @transaction.nil?
-          @transaction = transaction
-        else
-          @transaction.instance_variable_get(:@attributes).update(
-            transaction.attributes
-          )
-        end
-        @transaction.persist!
-      end
-    end
-
-    # Raised when a transaction fails for a temporary reason. The transaction
-    # should be retried later.
-    class RetryableError < Error
-    end
-
-    # Raised when a transaction fails due to a misconfiguration, e.g. if the
-    # gateway hasn't been configured.
-    class ConfigurationError < Error
-    end
-
-    # Raised when a transaction fails because the billing information was
-    # invalid.
-    class DeclinedError < Error
-    end
-
-    # Raised when the gateway believes this transaction to be a duplicate.
-    class DuplicateError < DeclinedError
-    end
-
-    # Raised when a 3DS result token is needed to complete a transaction
-    class ThreeDSecureError < DeclinedError
-      def three_d_secure_action_token_id
-        xml.text '/errors/transaction_error/three_d_secure_action_token_id'
-      end
-    end
-
-    class << Error
-      CATEGORY_MAP = Hash.new DeclinedError
-      CATEGORY_MAP.update(
-        'communication'             => RetryableError,
-        'configuration'             => ConfigurationError,
-        'duplicate'                 => DuplicateError,
-        '3d_secure_action_required' => ThreeDSecureError
-      )
-
-      def validate! exception, transaction
-        return unless exception.is_a? API::UnprocessableEntity
-
-        category = exception.send(:xml).text(
-          '/errors/transaction_error/error_category'
-        ) and raise CATEGORY_MAP[category].new(
-          exception.request, exception.response, transaction
-        )
-      end
-    end
-  end
-end