spree_account_recurring 1.0.0

data/app/controllers/spree/subscriptions_controller.rb

@@ -0,0 +1,69 @@
+module Spree
+  class SubscriptionsController < StoreController
+    prepend_before_filter :load_object
+    before_action :find_active_plan, only: [:new, :create]
+    before_action :find_plan, only: [:show, :destroy]
+    before_action :find_subscription, only: [:show, :destroy]
+    before_action :authenticate_subscription, only: [:new, :create]
+
+    def new
+      @subscription = @plan.subscriptions.build
+    end
+
+    def create
+      @subscription = @plan.subscriptions.build(subscription_params.merge(user_id: spree_current_user.id))
+      if @subscription.save_and_manage_api
+        redirect_to recurring_plan_subscription_url(@plan, @subscription), notice: "Thank you for subscribing!"
+      else
+        render :new
+      end
+    end
+
+    def destroy
+      if @subscription.save_and_manage_api(unsubscribed_at: Time.current)
+        redirect_to plans_path, notice: "Subscription has been cancelled."
+      else
+        render :show
+      end
+    end
+
+    private
+
+    def find_active_plan
+      unless @plan = Spree::Plan.active.where(id: params[:plan_id]).first
+        flash[:error] = "Plan not found."
+        redirect_to plans_url
+      end
+    end
+
+    def find_plan
+      unless @plan = Spree::Plan.where(id: params[:plan_id]).first
+        flash[:error] = "Plan not found."
+        redirect_to plans_url
+      end
+    end
+
+    def find_subscription
+      unless @subscription = @plan.subscriptions.undeleted.where(id: params[:id]).first
+        flash[:error] = "Subscription not found."
+        redirect_to root_url
+      end
+    end
+
+    def subscription_params
+      params.require(:subscription).permit(:email, :card_token)
+    end
+
+    def load_object
+      @user ||= spree_current_user
+      authorize! params[:action].to_sym, @user
+    end
+
+    def authenticate_subscription
+      if subscription = spree_current_user.subscriptions.undeleted.first
+        flash[:alert] = "You have already subscribed."
+        redirect_to recurring_plan_subscription_url(@plan, subscription)
+      end
+    end
+  end
+end

data/app/models/concerns/before_each.rb

@@ -0,0 +1,21 @@
+module BeforeEach
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def method_added(method)
+      method = method.to_s.gsub(/_with(out)?_before$/, '')
+      with_method, without_method = "#{method}_with_before", "#{method}_without_before"
+
+      return if method == 'before_each' or method_defined?(with_method)
+
+      define_method(with_method) do |*args, &block|
+        before_each
+        send(without_method, *args, &block)
+      end
+      alias_method_chain(method, :before)
+    end
+  end
+
+  def before_each
+  end
+end

data/app/models/concerns/restrictive_destroyer.rb

@@ -0,0 +1,44 @@
+module RestrictiveDestroyer
+  extend ActiveSupport::Concern
+
+  included do
+    before_destroy :destroyable?
+  end
+
+  module ClassMethods
+    def acts_as_restrictive_destroyer(options={})
+      raise ArgumentError, "Hash expected, got #{options.class.name}" unless options.is_a?(Hash)
+      class_attribute :restrictive_destroyer_config, :restrictive_destroyer_col_ref
+      self.restrictive_destroyer_config = { column: "deleted_at" }.merge!(options)
+      self.restrictive_destroyer_col_ref = "#{self.table_name}.#{restrictive_destroyer_config[:column]}"
+      scope :undeleted, -> { where("#{restrictive_destroyer_col_ref} IS NULL") }
+      scope :deleted, -> { where("#{restrictive_destroyer_col_ref} IS NOT NULL") }
+    end
+  end
+  
+  def readonly?
+    is_destroyed?
+  end
+
+  def restrictive_destroy
+    update_attributes("#{restrictive_destroyer_attr_ref}" => Time.current)
+  end
+
+  def restrictive_destroy_with_api
+    save_and_manage_api("#{restrictive_destroyer_attr_ref}" => Time.current)
+  end
+
+  def is_destroyed?
+    !send("#{restrictive_destroyer_attr_ref}_changed?") && send("#{restrictive_destroyer_attr_ref}?")
+  end
+
+  private
+
+  def restrictive_destroyer_attr_ref
+    self.class.restrictive_destroyer_config[:column]
+  end
+
+  def destroyable?
+    false
+  end
+end

data/app/models/concerns/spree/plan/api_handler.rb

@@ -0,0 +1,46 @@
+module Spree
+  class Plan < ActiveRecord::Base
+    module ApiHandler
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :set_api_plan_id, on: :create
+        after_create :create_plan
+        after_update :delete_plan, :if => [:deleted_at_changed?, :deleted_at?]
+        after_update :update_plan, :if => :name_changed?
+      end
+
+      def create_plan
+        provider.create_plan(self)
+      end
+
+      def delete_plan
+        provider.delete_plan(self)
+      end
+
+      def update_plan
+        provider.update_plan(self)
+      end
+
+      def save_and_manage_api(*args)
+        begin
+          new_record? ? save : update_attributes(*args)
+        rescue provider.error_class, ActiveRecord::RecordNotFound => e
+          logger.error "Error: #{e.message}"
+          errors.add :base, e.message
+          false
+        end
+      end
+
+      def provider
+        recurring.present? ? recurring : (raise ActiveRecord::RecordNotFound.new("Provider not found."))
+      end
+
+      private
+
+      def set_api_plan_id
+        provider.set_api_plan_id(self)
+      end
+    end
+  end
+end

data/app/models/concerns/spree/recurring/stripe_recurring/api_handler.rb

@@ -0,0 +1,28 @@
+module Spree
+  class Recurring < ActiveRecord::Base
+    class StripeRecurring < Spree::Recurring
+      module ApiHandler
+        extend ActiveSupport::Concern
+
+        included do
+          include BeforeEach
+          include PlanApiHandler
+          include SubscriptionApiHandler
+          include SubscriptionEventApiHandler
+        end
+
+        def error_class
+          Stripe::InvalidRequestError
+        end
+
+        def raise_invalid_object_error(object, type)
+          raise error_class.new("Not a valid object.") unless object.is_a?(type)
+        end
+
+        def set_api_key
+          Stripe.api_key = preferred_secret_key
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/recurring/stripe_recurring/api_handler/plan_api_handler.rb

@@ -0,0 +1,49 @@
+module Spree
+  class Recurring < ActiveRecord::Base
+    class StripeRecurring < Spree::Recurring
+      module ApiHandler 
+        module PlanApiHandler
+          def create_plan(plan)
+            raise_invalid_object_error(plan, Spree::Plan)
+            Stripe::Plan.create(
+              amount: stripe_amount(plan.amount),
+              interval: plan.interval,
+              interval_count: plan.interval_count,
+              name: plan.name,
+              currency: plan.currency,
+              id: plan.api_plan_id,
+              trial_period_days: plan.trial_period_days
+            )
+          end
+
+          def delete_plan(plan)
+            raise_invalid_object_error(plan, Spree::Plan)
+            stripe_plan = retrieve_api_plan(plan)
+            stripe_plan.delete
+          end
+
+          def update_plan(plan)
+            raise_invalid_object_error(plan, Spree::Plan)
+            stripe_plan = retrieve_api_plan(plan)
+            stripe_plan.name = plan.name
+            stripe_plan.save
+          end
+
+          def set_api_plan_id(plan)
+            plan.api_plan_id = "KS-Plan-#{Time.current.to_i}"
+          end
+
+          private
+
+          def retrieve_api_plan(plan)
+            Stripe::Plan.retrieve(plan.api_plan_id)
+          end
+
+          def stripe_amount(amount)
+            amount * 100
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/recurring/stripe_recurring/api_handler/subscription_api_handler.rb

@@ -0,0 +1,20 @@
+module Spree
+  class Recurring < ActiveRecord::Base
+    class StripeRecurring < Spree::Recurring
+      module ApiHandler
+        module SubscriptionApiHandler
+          def subscribe(subscription)
+            raise_invalid_object_error(subscription, Spree::Subscription)
+            customer = subscription.user.find_or_create_stripe_customer(subscription.card_token)
+            customer.subscriptions.create(plan: subscription.api_plan_id)
+          end
+
+          def unsubscribe(subscription)
+            raise_invalid_object_error(subscription, Spree::Subscription)
+            subscription.user.api_customer.cancel_subscription
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/recurring/stripe_recurring/api_handler/subscription_event_api_handler.rb

@@ -0,0 +1,19 @@
+module Spree
+  class Recurring < ActiveRecord::Base
+    class StripeRecurring < Spree::Recurring
+      module ApiHandler
+        module SubscriptionEventApiHandler
+          def retrieve_event(event_id)
+            begin
+              Stripe::Event.retrieve(event_id)
+            rescue error_class => e
+              logger.error "Stripe Event error: #{e.message}"
+              errors.add :base, "Stripe Event error: #{e.message}"
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/subscription/api_handler.rb

@@ -0,0 +1,38 @@
+module Spree
+  class Subscription < ActiveRecord::Base
+    module ApiHandler
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :card_token
+        before_create :subscribe
+        before_update :unsubscribe, :if => [:unsubscribed_at_changed?, :unsubscribed_at?]
+      end
+
+      def subscribe
+        provider.subscribe(self)
+        self.subscribed_at = Time.current
+      end
+
+      def unsubscribe
+        provider.unsubscribe(self)
+      end
+
+      def save_and_manage_api(*args)
+        begin
+          new_record? ? save : update_attributes(*args)
+        rescue provider.error_class, ActiveRecord::RecordNotFound => e
+          logger.error "Error while subscribing: #{e.message}"
+          errors.add :base, "There was a problem with your credit card"
+          false
+        end
+      end
+
+      def provider
+        plan.try(:recurring).present? ? plan.recurring : (raise ActiveRecord::RecordNotFound.new("Provider not found."))
+      end
+
+      private
+    end
+  end
+end

data/app/models/concerns/spree/subscription/role_subscriber.rb

@@ -0,0 +1,36 @@
+module Spree
+  class Subscription < ActiveRecord::Base
+    module RoleSubscriber
+      extend ActiveSupport::Concern
+
+      included do
+        before_create :add_role_subscriber, :unless => :unsubscribed_at?
+        before_update :remove_role_subscriber, :if => :unsubscribed_at?
+      end
+
+      def add_role_subscriber
+        if role = subscriber_role
+          user.spree_roles << role
+        else
+          errors.add :base, "Subscriber role is not present."
+          false
+        end
+      end
+
+      def remove_role_subscriber
+        if role = subscriber_role
+          user.spree_roles.destroy(role)
+        else
+          errors.add :base, "Subscriber role is not present."
+          false
+        end
+      end
+
+      private
+
+      def subscriber_role
+        Spree::Role.where(name: 'subscriber').first
+      end
+    end
+  end
+end

data/app/models/spree/plan.rb

@@ -0,0 +1,31 @@
+module Spree
+  class Plan < ActiveRecord::Base
+    include RestrictiveDestroyer
+    include ApiHandler
+
+    acts_as_restrictive_destroyer
+
+    belongs_to :recurring
+    has_many :subscriptions
+
+    validates :amount, :interval, :interval_count, :name, :currency, :recurring_id, :api_plan_id, presence: true
+    attr_readonly :amount, :interval, :currency, :id, :trial_period_days, :interval_count, :recurring_id, :api_plan_id
+
+    before_validation :manage_default, if: :default_changed?
+
+    scope :active, -> { undeleted.where(active: true) }
+    scope :visible, -> { active.joins(:recurring).where(["spree_recurrings.active = ? AND spree_recurrings.deleted_at IS NULL", true]) }
+
+    def visible?
+      active? && !is_destroyed? && recurring.visible?
+    end
+
+    def manage_default
+      recurring.plans.undeleted.where.not(id: id).update_all(default: false)
+    end
+
+    def self.default
+      visible.find_by(default: true)
+    end
+  end
+end

data/app/models/spree/recurring.rb

@@ -0,0 +1,27 @@
+module Spree
+  class Recurring < ActiveRecord::Base
+    include RestrictiveDestroyer
+
+    acts_as_restrictive_destroyer
+
+    preference :secret_key, :string
+    preference :public_key, :string
+
+    has_many :plans
+    attr_readonly :type
+    validates :type, :name, presence: true
+    scope :active, -> { undeleted.where(active: true) }
+
+    def self.display_name
+      name.gsub(%r{.+:}, '')
+    end
+
+    def visible?
+      active? && !is_destroyed?
+    end
+
+    def default_plan
+      plans.default
+    end
+  end
+end