shopify-gold 2.0.0.pre

data/app/operations/gold/accept_or_decline_charge_op.rb

@@ -0,0 +1,119 @@
+module Gold
+  module Outcomes
+    DeclinedCharge = Class.new(Failure)
+    CannotProcessCharge = Class.new(Failure)
+  end
+
+  # The charge was accepted or denied by the merchant.
+  class AcceptOrDeclineChargeOp
+    include Outcomes
+    include Retries
+
+    def initialize(billing, charge_id)
+      @billing = billing
+      @charge_id = charge_id.to_i
+      @charge_transition = @billing.state_machine.last_transition_to(
+        :sudden_charge,
+        :delayed_charge,
+        :optional_charge
+      )
+    end
+
+    def call
+      unless @charge_transition
+        Gold.logger.warn("[#{@billing.id}] Cannot find any charge creation events")
+        return CannotProcessCharge.new(:not_found)
+      end
+
+      expected_charge_id = @charge_transition.metadata["charge_id"]
+
+      if expected_charge_id != @charge_id
+        Gold.logger.warn(
+          "[#{@billing.id}] Expecting charge to be #{expected_charge_id.inspect} " \
+          "but it was #{@charge_id.inspect}"
+        )
+        return CannotProcessCharge.new(:old_charge)
+      end
+
+      charge = find_charge
+
+      if !charge
+        CannotProcessCharge.new(:not_found)
+      elsif charge.status == "active"
+        Gold.logger.info("[#{@billing.id}] This charge has already been activated")
+        @billing.transition_to!(accepted_state)
+        @billing.transition_to!(activated_state)
+        return ActiveCharge.new(@charge_id)
+      elsif charge.status == "accepted"
+        @billing.transition_to!(accepted_state)
+        activate_charge(charge)
+      elsif charge.status == "declined"
+        case @charge_transition.to_state.to_sym
+        when :sudden_charge
+          @billing.transition_to!(:sudden_charge_declined)
+        when :delayed_charge
+          @billing.transition_to!(:delayed_charge_declined)
+        when :optional_charge
+          # Also see FindOutstandingCharge, as it does the same logic
+          @billing.transition_to_or_stay_in!(:optional_charge_declined)
+          @billing.transition_to!(:billing)
+        end
+
+        DeclinedCharge.new
+      elsif charge.status == "expired"
+        @billing.transition_to!(expired_state)
+        ExpiredCharge.new
+      else
+        Gold.logger.warn("[#{@billing.id}] Charge failed '#{charge.status}'")
+        CannotProcessCharge.new(:bad_state)
+      end
+    rescue ActiveResource::ForbiddenAccess
+      @billing.transition_to!(:marked_as_uninstalled)
+      Outcomes::Uninstalled.new
+    end
+
+    private
+
+    def accepted_state
+      case @charge_transition.to_state.to_sym
+      when :sudden_charge then :sudden_charge_accepted
+      when :delayed_charge then :delayed_charge_accepted
+      when :optional_charge then :optional_charge_accepted
+      else
+        raise "Don't know what to do with #{@charge_transition.to_state}"
+      end
+    end
+
+    def activated_state
+      :charge_activated
+    end
+
+    def expired_state
+      case @charge_transition.to_state.to_sym
+      when :sudden_charge then :sudden_charge_expired
+      when :delayed_charge then :delayed_charge_expired
+      when :optional_charge then :optional_charge_declined
+      else
+        raise "Don't know what to do with #{@charge_transition.to_state}"
+      end
+    end
+
+    def find_charge
+      request_with_retries do
+        ShopifyAPI::RecurringApplicationCharge.find(@charge_id)
+      end
+    rescue ActiveResource::ResourceNotFound
+      Gold.logger.warn("[#{@billing.id}] failed to retrieve charge from Shopify")
+      nil
+    end
+
+    # Consumes a charge and activates it
+    def activate_charge(charge)
+      request_with_retries do
+        charge.activate
+        @billing.transition_to!(activated_state)
+        return ActiveCharge.new(charge.id)
+      end
+    end
+  end
+end

data/app/operations/gold/accept_or_decline_terms_op.rb

@@ -0,0 +1,26 @@
+module Gold
+  module Outcomes
+    AcceptedTerms  = Class.new(Success)
+    DeclinedTerms  = Class.new(Failure)
+  end
+
+  # Mark a store as having accepted/denied our Terms of Service.
+  class AcceptOrDeclineTermsOp
+    include Outcomes
+
+    def initialize(billing, accepted)
+      @billing = billing
+      @accepted = accepted
+    end
+
+    def call
+      if @accepted
+        @billing.transition_to!(:accepted_terms)
+
+        return AcceptedTerms.new
+      end
+
+      DeclinedTerms.new
+    end
+  end
+end

data/app/operations/gold/apply_discount_op.rb

@@ -0,0 +1,32 @@
+module Gold
+  module Outcomes
+    CannotApplyDiscount = Class.new(Failure)
+    SameDiscount = Class.new(Success)
+  end
+
+  # Applies a discount to a shop and creates a new charge for them.
+  class ApplyDiscountOp
+    include Outcomes
+
+    def initialize(billing, percentage, return_url, test = false)
+      @billing = billing
+      @percentage = percentage.to_i
+      @return_url = return_url
+      @test = test
+    end
+
+    def call
+      # Validate the discount
+      if @percentage < 0 || @percentage >= 100
+        return CannotApplyDiscount.new(:invalid_percentage)
+      end
+
+      return SameDiscount.new if @percentage == @billing.discount_percentage
+
+      @billing.transition_to!(:apply_discount, percentage: @percentage)
+      @billing.update(discount_percentage: @percentage)
+
+      ChargeOp.new(@billing, @return_url, @test).call
+    end
+  end
+end

data/app/operations/gold/apply_tier_op.rb

@@ -0,0 +1,51 @@
+module Gold
+  # Apply the tier that the shop has selected.
+  class ApplyTierOp
+    include Outcomes
+    include Retries
+
+    def initialize(billing)
+      @billing = billing
+    end
+
+    def call
+      begin
+        tier = @billing.last_selected_tier
+      rescue UnknownTier => e
+        return TierNotFound.new(e.message)
+      end
+
+      unless %i[apply_tier apply_free_tier].include?(@billing.current_state)
+        if tier.free?
+          @billing.transition_to!(:apply_free_tier, tier_id: tier.id)
+        else
+          @billing.transition_to!(:apply_tier, tier_id: tier.id)
+        end
+      end
+
+      @billing.tier = tier
+      @billing.save!
+
+      if tier.free?
+        if Gold.configuration.allow_automated_charge_cancellation
+          # Remove any outstanding active charges
+          if (charge = ShopifyAPI::RecurringApplicationCharge.current)
+            request_with_retries do
+              Gold.logger.info("[#{@billing.id}] Free tier applied, canceling " \
+                               "charge '#{charge.price}' for " \
+                               "'#{@billing.shop.shopify_domain}'")
+              charge.cancel
+            end
+          end
+        else
+          Gold.logger.info("[#{@billing.id}] Would have cancelled charge for " \
+                          "'#{@billing.shop.shopify_domain}', but prevented by setting")
+        end
+      end
+
+      @billing.transition_to!(:billing)
+      Gold.configuration.on_apply_tier&.call(@billing, tier.id)
+      TierApplied.new
+    end
+  end
+end

data/app/operations/gold/charge_op.rb

@@ -0,0 +1,99 @@
+module Gold
+  # Creates a charge for a shop.
+  class ChargeOp
+    MAX_ATTEMPTS = 3
+
+    include Retries
+    include Outcomes
+
+    def initialize(billing, return_url, test_charge = Gold.configuration.test_charge?)
+      @billing = billing
+      @return_url = return_url
+      @test_charge = test_charge
+    end
+
+    # Find a previous charge to use or create a new one
+    def call
+      return ChargeNotNeeded.new(:tier_is_free) if tier.free?
+      return ChargeNotNeeded.new(:in_billing_state) if @billing.current_state == :billing
+
+      charges = ShopifyAPI::RecurringApplicationCharge.all
+      if (charge = find_matching_charge(charges, @billing, "active"))
+        Gold.logger.info("[#{@billing.id}] There is an existing charge (#{charge.id}) " \
+                          "ready to use; skip charge creation")
+
+        transition_to_charge_state!(charge_id: charge.id)
+        return ActiveCharge.new(charge.id)
+      elsif (charge = find_matching_charge(charges, @billing, "accepted"))
+        Gold.logger.info("[#{@billing.id}] There is an accepted charge (#{charge.id}) " \
+                          "that we haven't registered yet; redirecting to that now")
+
+        # Log that this charge is the one we want to use
+        transition_to_charge_state!(charge_id: charge.id)
+        return AcceptedCharge.new(charge.decorated_return_url)
+      elsif (charge = find_matching_charge(charges, @billing, "pending"))
+        Gold.logger.info("[#{@billing.id}] Reusing an existing charge: #{charge.id}")
+
+        # Mark the charge as ready for the merchant to review
+        transition_to_charge_state!(charge_id: charge.id)
+        return PendingCharge.new(charge.confirmation_url)
+      else
+        # Construct a new RecurringApplicationCharge for the tier
+        charge = build_charge(@billing, tier)
+
+        request_with_retries do
+          charge.save!
+        end
+
+        # Mark the charge as ready for the merchant to review
+        transition_to_charge_state!(charge_id: charge.id)
+
+        return PendingCharge.new(charge.confirmation_url)
+      end
+    end
+
+    protected
+
+    def tier
+      @billing.last_selected_tier
+    end
+
+    # Attempt to transition to :sudden_charge, then :delayed_charge, else fail
+    def transition_to_charge_state!(metadata)
+      if @billing.transition_to_or_stay_in(:sudden_charge, metadata)
+      elsif @billing.transition_to_or_stay_in(:delayed_charge, metadata)
+      elsif @billing.transition_to_or_stay_in(:optional_charge, metadata)
+      else
+        message = "Cannot transition from '#{@billing.current_state}' " \
+                  "to 'delayed_charge', 'optional_charge', or 'sudden_charge'"
+        raise Statesman::TransitionFailedError, message
+      end
+    end
+
+    def find_matching_charge(charges, billing, status)
+      charges.find do |charge|
+        charge.status == status &&
+          charge.price.to_d == billing.calculate_price(tier) &&
+          billing.trial_starts_at && # Trial must have already started
+          (status == "active" || charge.return_url == @return_url) &&
+          charge.test == @test_charge
+      end
+    end
+
+    def build_charge(billing, tier)
+      name = "#{Gold.configuration.app_name} #{tier.name}"
+
+      if billing.discount_percentage > 0
+        name += " (#{billing.discount_percentage}% discount)"
+      end
+
+      ShopifyAPI::RecurringApplicationCharge.new(
+        name: name,
+        price: billing.calculate_price(tier),
+        return_url: @return_url,
+        test: @test_charge,
+        trial_days: billing.calculate_trial_days(tier)
+      )
+    end
+  end
+end

data/app/operations/gold/check_charge_op.rb

@@ -0,0 +1,50 @@
+module Gold
+  module Outcomes
+    MismatchCharge = Class.new(Failure)
+  end
+
+  # Ensure that the charge is correct and active.
+  class CheckChargeOp
+    include Outcomes
+    include Retries
+
+    def initialize(billing, test_charge = Gold.configuration.test_charge?)
+      @billing = billing
+      @test_charge = test_charge
+    end
+
+    def call
+      @billing.transition_to(:check_charge) unless @billing.current_state == :check_charge
+
+      charges = request_with_retries do
+        ShopifyAPI::RecurringApplicationCharge.all
+      end
+
+      active_charge = charges.find { |charge| charge.status == "active" }
+      frozen_charge = charges.find { |charge| charge.status == "frozen" }
+
+      if active_charge && billing_matches_charge?(active_charge)
+        @billing.transition_to!(:billing)
+        return ActiveCharge.new(active_charge.id)
+      elsif frozen_charge && @billing.transition_to(:frozen)
+        return FrozenCharge.new
+      elsif active_charge
+        @billing.transition_to!(:charge_missing)
+        return MismatchCharge.new
+      else
+        @billing.transition_to!(:charge_missing)
+        return MissingCharge.new
+      end
+    end
+
+    private
+
+    def billing_matches_charge?(charge)
+      tier = @billing.last_selected_tier
+
+      @billing.calculate_price(tier) == charge.price.to_d && # Price must match
+        @billing.trial_starts_at && # Trial must have already started
+        @test_charge == charge.test
+    end
+  end
+end

data/app/operations/gold/cleanup_op.rb

@@ -0,0 +1,20 @@
+module Gold
+  # Clean up resources associated with a store after a merchant has uninstalled
+  # and a sufficient amount of time has passed.
+  class CleanupOp
+    include Outcomes
+
+    def initialize(billing)
+      @billing = billing
+    end
+
+    def call
+      @billing.transition_to_or_stay_in!(:cleanup)
+
+      Gold.configuration.on_cleanup&.call(@billing)
+
+      @billing.transition_to!(:done)
+      Success.new
+    end
+  end
+end

data/app/operations/gold/convert_affiliate_to_paid_op.rb

@@ -0,0 +1,32 @@
+module Gold
+  class ConversionError < StandardError; end
+
+  # Convert an affiliate store to a paid store.
+  class ConvertAffiliateToPaidOp
+    def initialize(billing, return_url, test_charge = Gold.configuration.test_charge?)
+      @billing = billing
+      @return_url = return_url
+      @test_charge = test_charge
+    end
+
+    def call
+      unless @billing.shopify_plan.paying?
+        raise ConversionError, "This is not a paying plan"
+      end
+
+      @billing.transition_to_or_stay_in!(:affiliate_to_paid)
+
+      if @billing.last_selected_tier.free?
+        ApplyTierOp.new(@billing).call
+      else
+        outcome = ChargeOp.new(@billing, @return_url, @test_charge).call
+
+        if outcome.is_a? Outcomes::PendingCharge
+          BillingMailer.affiliate_to_paid(@billing, outcome.confirmation_url).deliver_now
+        end
+
+        outcome
+      end
+    end
+  end
+end

data/app/operations/gold/freeze_op.rb

@@ -0,0 +1,15 @@
+module Gold
+  # Invoked when Shopify suspends a merchant. This is the opposite of `ThawOp`.
+  class FreezeOp
+    include Outcomes
+
+    def initialize(billing)
+      @billing = billing
+    end
+
+    def call
+      @billing.transition_to_or_stay_in!(:frozen)
+      Success.new
+    end
+  end
+end

data/app/operations/gold/install_op.rb

@@ -0,0 +1,30 @@
+module Gold
+  InstallFailed = Class.new(Outcomes::Failure)
+
+  # Invoked when a shop has installed (or reinstalled) this app.
+  class InstallOp
+    include Outcomes
+
+    def initialize(billing)
+      @billing = billing
+    end
+
+    def call
+      # If possible, transition to reinstalled
+      @billing.transition_to(:reinstalled)
+
+      case @billing.current_state
+      when :frozen
+        return CheckChargeOp.new(@billing).call
+      when :cleanup
+        Gold.logger.warn("[#{@billing.id}] Tried installing?" \
+                         "'#{@billing.shop.shopify_domain}', but on cleanup")
+        return InstallFailed.new(:cleanup_in_progress)
+      end
+
+      Gold.configuration.on_install&.call(@billing)
+
+      Success.new
+    end
+  end
+end

data/app/operations/gold/issue_credit_op.rb

@@ -0,0 +1,55 @@
+module Gold
+  # Returned when a credit cannot be issued, likely due to a restriction on
+  # Shopify's side.
+  module Outcomes
+    CannotIssueCredit = Class.new(Failure)
+  end
+
+  # Provide a credit to a merchant.
+  class IssueCreditOp
+    MAX_ATTEMPTS = 3
+
+    include Outcomes
+    include Retries
+
+    def initialize(billing, amount, reason, test = false)
+      @billing = billing
+      @amount = amount.to_d
+      @reason = reason
+      @test = test
+    end
+
+    def call
+      return CannotIssueCredit.new(:amount_not_positive) if @amount <= 0
+      return CannotIssueCredit.new(:missing_reason) if @reason.blank?
+      return CannotIssueCredit.new(:invalid_tier) if @billing.last_selected_tier&.free?
+
+      @billing.transition_to!(:issue_credit, amount: @amount, reason: @reason)
+
+      # Now create the credit on Shopify's end
+      credit = new_credit
+
+      request_with_retries do
+        credit.save
+      end
+
+      # Mark the credit as applied
+      @billing.transition_to!(:billing)
+
+      if credit.valid?
+        Success.new
+      else
+        CannotIssueCredit.new(:rejected_by_shopify,
+                              credit.errors.full_messages.join(", "))
+      end
+    end
+
+    def new_credit
+      ShopifyAPI::ApplicationCredit.new(
+        description: @reason,
+        amount: @amount,
+        test: @test
+      )
+    end
+  end
+end

data/app/operations/gold/mark_as_delinquent_op.rb

@@ -0,0 +1,21 @@
+module Gold
+  # Invoked when Helium suspends a merchant for violating ToS.
+  class MarkAsDelinquentOp
+    include Outcomes
+
+    def initialize(billing)
+      @billing = billing
+    end
+
+    def call
+      @billing.transition_to_or_stay_in!(:marked_as_delinquent)
+
+      # Communicate delinquency to the merchant.
+      BillingMailer.delinquent(@billing).deliver_now
+
+      @billing.transition_to!(:delinquent)
+
+      Success.new
+    end
+  end
+end

data/app/operations/gold/resolve_outstanding_charge_op.rb

@@ -0,0 +1,90 @@
+module Gold
+  # Look up billing information and see if they have a charge or not based on
+  # the charges we've previously created
+  class ResolveOutstandingChargeOp
+    include Outcomes
+    include Retries
+
+    def initialize(billing)
+      @billing = billing
+    end
+
+    def call
+      return MissingCharge.new(:no_charge_state) unless charge_state_transition
+
+      charge_id = charge_state_transition.metadata["charge_id"]
+
+      begin
+        charge = request_with_retries do
+          ShopifyAPI::RecurringApplicationCharge.find(charge_id)
+        end
+      rescue ActiveResource::ResourceNotFound
+        return MissingCharge.new(:shopify_missing)
+      end
+
+      case charge.status
+      when "active", "frozen"
+        return ActiveCharge.new(charge_id)
+      when "accepted"
+        return AcceptedCharge.new(charge.decorated_return_url)
+      when "pending"
+        return PendingCharge.new(charge.confirmation_url)
+      when "expired"
+        if sudden_charge?
+          @billing.transition_to!(:sudden_charge_expired)
+          return ExpiredCharge.new
+        elsif delayed_charge?
+          @billing.transition_to!(:delayed_charge_expired)
+          return ExpiredCharge.new
+        elsif optional_charge?
+          # It is OK for an optional charge to expire. Put the merchant back in
+          # a normal billing state and let them retry their charge later, if
+          # desired.
+          @billing.transition_to!(:optional_charge_declined)
+          @billing.transition_to!(:billing)
+          return ActiveCharge.new(charge_id)
+        end
+        @billing.transition_to!(expired_state)
+        return ExpiredCharge.new
+      when "declined"
+        if sudden_charge?
+          @billing.transition_to!(:sudden_charge_declined)
+          return MissingCharge.new(:charge_declined)
+        elsif delayed_charge?
+          @billing.transition_to!(:delayed_charge_declined)
+          return MissingCharge.new(:charge_declined)
+        elsif optional_charge?
+          @billing.transition_to_or_stay_in!(:optional_charge_declined)
+          @billing.transition_to!(:billing)
+          return ActiveCharge.new(charge_id)
+        end
+      when "cancelled"
+        return MissingCharge.new(:charge_cancelled)
+      else
+        raise MissingCharge.new(:bad_status, "Bad status: '#{charge.status}'")
+      end
+    end
+
+    private
+
+    def charge_state_transition
+      @charge_state_transition ||=
+        @billing.state_machine.last_transition_to(:sudden_charge,
+                                                  :delayed_charge,
+                                                  :optional_charge)
+    end
+
+    def sudden_charge?
+      charge_state_transition.nil? ||
+        charge_state_transition.to_state.to_sym == :sudden_charge
+    end
+
+    def delayed_charge?
+      charge_state_transition.to_state.to_sym == :delayed_charge
+    end
+
+    def optional_charge?
+      charge_state_transition.to_state.to_sym == :optional_charge
+    end
+  end
+end