shopify-gold 2.0.0.pre

data/app/controllers/gold/admin/billing_controller.rb

@@ -0,0 +1,190 @@
+module Gold
+  module Admin
+    # Main controller for Gold to be used in app
+    class BillingController < ApplicationController
+      credentials = Gold.configuration.admin_credentials
+      http_basic_authenticate_with name: credentials[:user],
+                                   password: credentials[:password]
+
+      around_action :shopify_session
+
+      rescue_from Statesman::TransitionFailedError,
+                  Statesman::GuardFailedError,
+                  Gold::Exceptions::MetadataMissing do |e|
+        flash[:danger] = e.message
+        go_back
+      end
+
+      def transition
+        transitions = [params[:to]].flatten
+
+        transitions.each do |t|
+          billing.transition_to!(t, metadata)
+        end
+
+        flash[:success] = "Transitioned to '#{transitions.join(',')}'"
+        go_back
+      end
+
+      # rubocop:disable Metrics/LineLength:Length
+      def change_tier
+        tier = Tier.find(params[:tier])
+
+        outcome = SelectTierOp.new(billing, tier).call
+
+        if outcome.ok?
+          charge_outcome = ChargeOp.new(billing, process_charge_url).call
+
+          if charge_outcome.is_a?(Outcomes::ActiveCharge)
+            accept_or_decline_outcome = AcceptOrDeclineChargeOp.new(billing, charge_outcome.charge_id).call
+
+            if accept_or_decline_outcome.ok?
+              apply_tier_outcome = ApplyTierOp.new(billing).call
+
+              if apply_tier_outcome.ok? # rubocop:disable Metrics/BlockNesting
+                flash[:success] = "Changed billing to '#{tier.name}', no merchant action required"
+              else
+                flash[:danger] = "Failed to apply tier because '#{apply_tier_outcome.reason}'"
+              end
+            else
+              flash[:danger] = "Failed to accept or decline charge because '#{accept_or_decline_outcome.reason}'"
+            end
+          elsif charge_outcome.is_a?(Outcomes::ChargeNotNeeded)
+            flash[:success] = "Applied free tier '#{tier.name}', no merchant action required. You may need to cancel their current charge."
+          else
+            flash[:warning] = "Changing tier, but merchant action is required before tier is applied"
+          end
+        else
+          flash[:danger] = "Failed to apply tier because '#{outcome.reason}'"
+        end
+
+        go_back
+      end
+      # rubocop:enable Metrics/LineLength:Length
+
+      # Issue a credit to a shop
+      def issue_credit
+        outcome = IssueCreditOp.new(billing, params[:amount], params[:reason]).call
+
+        if outcome.ok?
+          flash["success"] = "Issued credit"
+        else
+          flash["danger"] = "Failed to issue credit because '#{outcome.message}'"
+        end
+
+        go_back
+      end
+
+      def cancel_charge
+        begin
+          charge = ShopifyAPI::RecurringApplicationCharge.find(params[:charge_id])
+          charge.cancel
+          flash["success"] = "Cancelled charge"
+        rescue ActiveResource::ResourceNotFound
+          flash["warning"] = "That charge was not found for '#{ShopifyAPI::Base.site}'"
+        end
+
+        go_back
+      end
+
+      # Suspend a shop
+      def suspend
+        if params[:confirm_suspend].blank?
+          flash[:danger] = "Please confirm you want to suspend this account"
+          go_back && return
+        end
+
+        SuspendOp.new(billing).call
+        flash[:success] = "Account suspended"
+        go_back
+      end
+
+      # Unsuspend a shop
+      def unsuspend
+        UnsuspendOp.new(billing).call
+        flash[:success] = "Account unsuspended"
+        go_back
+      end
+
+      def apply_discount
+        outcome = ApplyDiscountOp.new(billing,
+                                      params[:percentage].to_i,
+                                      process_charge_url).call
+
+        if outcome.ok?
+          flash[:warning] = "Discount applied, merchant must reauthorize the charge"
+        else
+          flash[:danger] = "Failed to apply discount because '#{outcome.message}'"
+        end
+
+        go_back
+      end
+
+      def override_shopify_plan
+        plan = params[:plan].presence
+        if billing.update(shopify_plan_override: plan)
+          flash[:success] = if plan
+                              "Changed Shopify plan to '#{plan}'"
+                            else
+                              "Removed Shopify plan override"
+                            end
+        else
+          flash[:danger] = "Failed to save shop"
+        end
+
+        go_back
+      end
+
+      def reset_trial_days
+        case params[:trial_action]
+        when "reset"
+          if billing.update(trial_starts_at: Time.current)
+            flash[:success] = "New trial starts... now! You might need to" \
+                              "cancel their charge first."
+          else
+            flash[:danger] = "Failed to reset trial days"
+          end
+        when "clear"
+          if billing.update(trial_starts_at: nil)
+            flash[:success] = "Trial started over. The merchant will be faced" \
+                              "with a new charge upon login."
+          else
+            flash[:danger] = "Failed to clear trial days"
+          end
+        else
+          flash[:danger] = "Don't know what to do with" \
+                          " '#{params[:trial_action]}' trial action"
+        end
+
+        go_back
+      end
+
+      private
+
+      def shopify_session
+        billing.shop.with_shopify_session do
+          yield
+        end
+      end
+
+      def billing
+        @billing ||= Billing.find(params[:id])
+      end
+
+      def metadata
+        md = {
+          applied_by: "admin"
+        }
+
+        if params.dig(:metadata, :key).present?
+          md[params[:metadata][:key]] = params[:metadata][:value]
+        end
+        md
+      end
+
+      def go_back
+        redirect_back(fallback_location: main_app.gold_admin_engine_path)
+      end
+    end
+  end
+end

data/app/controllers/gold/application_controller.rb

@@ -0,0 +1,17 @@
+module Gold
+  # Controller that all Gold controllers inherit from.
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+    around_action :catch_halt
+
+    layout "application"
+
+    private
+
+    # Allows an action to stop processing (like `return`, but works even in
+    # nested calls) and return a response to the user.
+    def catch_halt
+      catch(:halt) { yield }
+    end
+  end
+end

data/app/controllers/gold/authenticated_controller.rb

@@ -0,0 +1,15 @@
+require_dependency "gold/application_controller"
+
+module Gold
+  # Similar to ShopifyApp::AuthenticatedController, but inherits from Gold's
+  # ApplicationController.
+  class AuthenticatedController < ApplicationController
+    # Include all of the contents of ShopifyApp::AuthenticatedController
+    include ShopifyApp::Localization
+    include ShopifyApp::LoginProtection
+    include ShopifyApp::EmbeddedApp
+
+    before_action :login_again_if_different_shop
+    around_action :shopify_session
+  end
+end

data/app/controllers/gold/billing_controller.rb

@@ -0,0 +1,185 @@
+module Gold
+  # Handles all merchant billing interactions.
+  class BillingController < AuthenticatedController
+    include Concerns::MerchantFacing
+    include Outcomes
+
+    layout "gold/billing"
+
+    rescue_from Statesman::TransitionFailedError do |e|
+      billing = Billing.find_by!(shop_id: session[:shopify])
+      Gold.logger.error("Shop '#{billing.shop.shopify_domain}' failed to " \
+                        "transtion '#{e}'")
+      render "gold/billing/transition_error", layout: "gold/billing",
+                                              status: :internal_server_error
+    end
+
+    # Show the terms of service.
+    def terms
+      @already_accepted = !billing.can_transition_to?(:accepted_terms)
+    end
+
+    # Handle acceptance or declination of the terms of service.
+    def process_terms
+      accepted = params[:accept].present?
+      outcome = AcceptOrDeclineTermsOp.new(billing, accepted).call
+      case outcome
+      when AcceptedTerms
+        params.permit!
+        Gold.configuration.on_terms&.call(billing, params.to_h)
+        redirect_to select_tier_url
+      else
+        @error = true
+        render :terms
+      end
+    end
+
+    # Show the possible tiers to select from.
+    def tier
+      billing # Expose the @billing variable to the view
+      @tiers = Tier.visible
+    end
+
+    # Process a tier selection.
+    def select_tier
+      @tiers = Tier.visible
+      @tier = Tier.find(params[:tier])
+      outcome = SelectTierOp.new(billing, @tier).call
+      case outcome
+      when SameTier, TierApplied
+        redirect_to main_app.root_url
+      when CannotSelectTier
+        flash.now[:error] = "You may not select this tier currently"
+        render :tier
+      when ChargeNeeded
+        handle_charge_outcome ChargeOp.new(billing, process_charge_url).call
+      else
+        raise "Not sure how to handle #{outcome} on tier selection"
+      end
+    end
+
+    # Show the merchant that they have an outstanding charge and let them
+    # approve/decline it.
+    def outstanding_charge
+      outcome = ResolveOutstandingChargeOp.new(billing).call
+
+      case outcome
+      when PendingCharge
+        Gold.logger.info("[#{billing.id}] Charge is pending")
+        @confirmation_url = outcome.confirmation_url
+      when AcceptedCharge
+        Gold.logger.info("[#{billing.id}] Charge is accepted")
+        redirect_to outcome.return_url
+      when MissingCharge
+        Gold.logger.info("[#{billing.id}] Charge is missing")
+        redirect_to missing_charge_url
+      when ExpiredCharge
+        Gold.logger.info("[#{billing.id}] Charge is expired")
+        redirect_to expired_charge_url
+      when ActiveCharge
+        unless billing.current_state == :billing
+          AcceptOrDeclineChargeOp.new(billing, outcome.charge_id).call
+
+          unless ApplyTierOp.new(billing).call.ok?
+            raise "Charge was #{accepted_outcome}, but should have been active"
+          end
+
+          Gold.logger.info("[#{billing.id}] Charge is ready")
+        end
+
+        redirect_to main_app.root_url
+      else
+        raise "Not sure how to handle #{outcome} on outstanding charge"
+      end
+    end
+
+    # Process a charge confirmation when a merchant is redirected back from
+    # Shopify.
+    def process_charge
+      outcome = AcceptOrDeclineChargeOp.new(billing, params[:charge_id]).call
+
+      case outcome
+      when ActiveCharge
+        ApplyTierOp.new(billing).call
+        redirect_to main_app.root_url
+      when DeclinedCharge
+        redirect_to declined_charge_url
+      when ExpiredCharge
+        redirect_to expired_charge_url
+      when Uninstalled
+        redirect_to uninstalled_url
+      when CannotProcessCharge
+        redirect_to missing_charge_url
+      end
+    end
+
+    # Show the merchant that the charge has expired and direct them to try
+    # again.
+    def declined_charge
+      ensure_billing_is :sudden_charge_declined, :delayed_charge_declined
+    end
+
+    # Show the merchant that the charge has expired and direct them to try
+    # again.
+    def expired_charge
+      ensure_billing_is :sudden_charge_expired, :delayed_charge_expired
+    end
+
+    # Explain to the merchant that their charge is missing and direct them to
+    # try again.
+    def missing_charge
+    end
+
+    # Allow the merchant to retry the charge when necessary.
+    def retry_charge
+      handle_charge_outcome ChargeOp.new(billing, process_charge_url).call
+    end
+
+    # Show the merchant a suspension page if they have been suspended.
+    def suspended
+      ensure_billing_is :marked_as_suspended, :suspended
+    end
+
+    # Show the merchant a message about them uninstalling the app if they are
+    # still logged in.
+    def uninstalled
+      ensure_billing_is :marked_as_uninstalled,
+                        :uninstalled,
+                        :frozen,
+                        :cleanup,
+                        :done
+    end
+
+    private
+
+    # Redirect to the appropriate location based on the return value from
+    # ChargeOp.
+    def handle_charge_outcome(outcome)
+      Gold.logger.info("[#{billing.id}] Handling charge outcome")
+
+      case outcome
+      when ChargeNotNeeded
+        Gold.logger.info("[#{billing.id}] Charge is not needed")
+        redirect_to main_app.root_url
+      when ActiveCharge
+        Gold.logger.info("[#{billing.id}] Charge is active")
+        redirect_to main_app.root_url
+      when AcceptedCharge
+        Gold.logger.info("[#{billing.id}] Charge is accepted")
+        redirect_to outcome.return_url
+      when PendingCharge
+        Gold.logger.info("[#{billing.id}] Charge is pending")
+        redirect_to outcome.confirmation_url
+      end
+    end
+
+    # Ensure that the current merchant is in one of the provided states or
+    # redirect to the app's root URL.
+    def ensure_billing_is(*states)
+      return if states.include?(billing.current_state)
+
+      redirect_to main_app.root_url
+      throw :halt
+    end
+  end
+end

data/app/controllers/gold/concerns/merchant_facing.rb

@@ -0,0 +1,85 @@
+module Gold
+  module Concerns
+    # Helpers that make it easier to work with the current merchant's billing
+    # information in controllers.
+    module MerchantFacing
+      def self.included(base)
+        base.helper_method :billing
+      end
+
+      # Returns the Gold::Billing instance for the currently logged-in merchant.
+      def billing
+        @billing ||= Billing.find_by!(shop_id: session[:shopify])
+      end
+
+      # `before_action` filter that forces a merchant to deal with
+      # billing-related states (outstanding charges, acceptance of terms, etc)
+      # before continuing with their work.
+      def confront_mandatory_billing_action
+        ConfrontMandatoryBillingAction.new(self).call
+      end
+
+      # Provides access to routes, passing in a particular controller as
+      # context. We go through the effort of putting this into a separate class
+      # because we do not want to directly include the url helpers into whatever
+      # controller we are included into because that might override routes. This
+      # solution isolates the Gold routes from whatever routes the app that Gold
+      # is embedded in may have defined.
+      class HasAccessToRoutes
+        include Engine.routes.url_helpers
+        delegate :default_url_options, :url_options, to: :@context
+
+        def initialize(context)
+          @context = context
+          @engine = context.gold_engine
+        end
+      end
+
+      # See documentation on `confront_mandatory_billing_action`.
+      class ConfrontMandatoryBillingAction < HasAccessToRoutes
+        def call
+          begin
+            state = @context.billing.current_state
+          rescue ActiveRecord::RecordNotFound
+            state = nil
+          end
+
+          Gold.logger.info("Confronting billing, state is '#{state}'")
+
+          case state
+          when nil, :new
+            Gold.logger.info("Redirecting to terms page...")
+            return @context.redirect_to(@engine.terms_url)
+          when :select_tier, :reinstalled, :accepted_terms
+            Gold.logger.info("Redirecting to select tier...")
+            return @context.redirect_to(@engine.select_tier_url)
+          when :charge_missing
+            Gold.logger.info("Redirecting to missing charge...")
+            return @context.redirect_to(@engine.missing_charge_url)
+          when :sudden_charge, :delayed_charge, :optional_charge
+            Gold.logger.info("Redirecting to outstanding charge...")
+            return @context.redirect_to(@engine.outstanding_charge_url)
+          when :sudden_charge_declined, :delayed_charge_declined
+            Gold.logger.info("Redirecting to declined charge...")
+            return @context.redirect_to(@engine.declined_charge_url)
+          when :sudden_charge_expired, :delayed_charge_expired
+            Gold.logger.info("Redirecting to expired charge...")
+            return @context.redirect_to(@engine.expired_charge_url)
+          when :marked_as_delinquent, :delinquent
+            Gold.logger.info("Redirecting to missing charge...")
+            return @context.redirect_to(@engine.missing_charge_url)
+          when :marked_as_suspended, :suspended
+            Gold.logger.info("Redirecting to suspended page...")
+            return @context.redirect_to(@engine.suspended_path)
+          when :marked_as_uninstalled, :uninstalled, :frozen, :done
+            Gold.logger.info("Redirecting to uninstalled page...")
+            return @context.redirect_to(@engine.uninstalled_path)
+          when :cleanup
+            Gold.logger.info("Shop is cleanup, redirecting to unavailable...")
+            return @context.redirect_to(@engine.unavailable_path)
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/app_uninstalled_job.rb

@@ -0,0 +1,2 @@
+# Defers to the Gold implementation.
+AppUninstalledJob = Gold::AppUninstalledJob

data/app/jobs/gold/after_authenticate_job.rb

@@ -0,0 +1,36 @@
+module Gold
+  # Run when the app is installed, reinstalled, or a user logs in. This is
+  # essentially how Gold is bootstrapped, so there is an assumption made
+  # here (the shop class has a `#with_shopify_session` method). This is true
+  # with the default Shop class that Shopify sets up, but if that is different
+  # for your environment, you will need to create your own custom version of
+  # this job.
+  class AfterAuthenticateJob < ApplicationJob
+    include Outcomes
+
+    def perform(shop_domain:)
+      # Look up the shop associated with the Shopify session.
+      shop = Gold.shop_class.find_by!(Gold.shop_domain_attribute => shop_domain)
+
+      # Create a billing instance if this store is newly installed or already
+      # cleaned up.
+      billing = Billing.find_or_create_by!(shop: shop)
+
+      shop.with_shopify_session do
+        outcome = InstallOp.new(billing).call
+
+        case outcome
+        when ChargeNeeded, MissingCharge
+          process_charge_url = Engine.routes.url_helpers.process_charge_url
+          logger.info("#{shop_domain} has reinstalled and needs to approve a " \
+                      "charge for their selected tier")
+          ChargeOp.new(billing, process_charge_url).call
+        when Success
+          logger.info("#{shop_domain} successfully installed the app")
+        end
+
+        outcome
+      end
+    end
+  end
+end

data/app/jobs/gold/app_uninstalled_job.rb

@@ -0,0 +1,10 @@
+module Gold
+  # Uninstalls the app for the merchant.
+  class AppUninstalledJob < ApplicationJob
+    def perform(shop_domain:, webhook: nil) # rubocop:disable Lint/UnusedMethodArgument
+      shop = Gold.shop_class.find_by!(Gold.shop_domain_attribute => shop_domain)
+      billing = Gold::Billing.find_by!(shop: shop)
+      UninstallOp.new(billing).call
+    end
+  end
+end

data/app/jobs/gold/application_job.rb

@@ -0,0 +1,20 @@
+module Gold
+  # Base for all Gold-related background jobs to build upon.
+  class ApplicationJob < ActiveJob::Base
+    include Engine.routes.url_helpers
+
+    queue_as :gold
+
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    # discard_on ActiveJob::DeserializationError
+
+    protected
+
+    def default_url_options
+      Rails.application.config.default_url_options
+    end
+  end
+end

data/app/mailers/gold/application_mailer.rb

@@ -0,0 +1,7 @@
+module Gold
+  # Defaults for all Gold-related mailers.
+  class ApplicationMailer < ActionMailer::Base
+    default from: Gold.configuration.contact_email
+    layout "mailer"
+  end
+end

data/app/mailers/gold/billing_mailer.rb

@@ -0,0 +1,36 @@
+module Gold
+  # Sends billing-related emails to merchants.
+  class BillingMailer < ApplicationMailer
+    layout "gold/mailer"
+
+    # Inform a merchant about their account becoming suspended.
+    def suspension(billing)
+      billing.shop.with_shopify_session do
+        @shop = ShopifyAPI::Shop.current
+        mail(to: @shop.email,
+             subject: "We have suspended your access to #{Gold.configuration.app_name}")
+      end
+    end
+
+    # Inform a merchant about their non-payment.
+    def delinquent(billing)
+      billing.shop.with_shopify_session do
+        @shop = ShopifyAPI::Shop.current
+        mail(to: @shop.email,
+             subject: "We need you to approve a charge for " \
+                      "#{Gold.configuration.app_name}")
+      end
+    end
+
+    def affiliate_to_paid(billing, confirmation_url)
+      billing.shop.with_shopify_session do
+        @shop = ShopifyAPI::Shop.current
+        @confirmation_url = confirmation_url
+        app_name = Gold.configuration.app_name
+
+        mail(to: @shop.email,
+             subject: "[Action Required] Charge needed for #{app_name}")
+      end
+    end
+  end
+end