effective_orders 4.0.0beta12 → 4.0.0beta13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 376115e079468c5d3491790fa4ecf3b3246a50ae
-  data.tar.gz: 7fe5bd8bf1858d610165c69dbb5ea607ce43a592
+  metadata.gz: fdea3f4d9f23be9fc167ecab4c4fb9e713f5dace
+  data.tar.gz: 28345325ce45052bd240e048b52eefea6fcd06e4
 SHA512:
-  metadata.gz: d23090e89bd8b6d52de083e31960952b3a770d22879acfa38df41996fc55cfd9e70f21b5edad298b7dd25fc034801b02ddcc7666bedd185dd791baebe7a532bb
-  data.tar.gz: a0aff96d9a98967c8a5463a31973535d2f7d0c6cc5910200d5cfc158af5bc1d2d47e9fdaa777914bb7666cebc905a3ee0f1c138f9009f8ce2e5b47b3c8cc2ef1
+  metadata.gz: 1b03283f67b8f5f9d3d046b7f4f94e58f4631a6aa0f142ca560fbb829657220c139e949b7737d25f5217817996d55adb286f2ed7578939b579183006c0e581d6
+  data.tar.gz: f32aa391e9dcf39a615c392198ddc997d0f823535931b3a59b253877681d75c3d03a9a8d9000efec46d1561a66cff93905cafe86ae823b427f464deddda57178

data/app/assets/javascripts/effective_orders/subscriptions.js.coffee

@@ -40,3 +40,6 @@ $(document).on 'click', ".effective-orders-stripe-token-required[type='submit']"
     description: plan.name
     amount: plan.amount
     panelLabel: "{{amount}}/#{plan.interval} Go!"
+
+$(document).on 'change', "input[name='effective_subscripter[stripe_plan_id]']", (event) ->
+  $(event.currentTarget).closest('form').find(".effective-orders-stripe-token-required[type='submit']").click()

data/app/controllers/effective/webhooks_controller.rb

@@ -39,21 +39,22 @@ module Effective
         # when 'charge.failed' # Card declined. 4000 0000 0000 0341
 
         when 'invoice.payment_succeeded'
-          customer = Effective::Customer.where(stripe_customer_id: @event.data.object.customer).first!
           customer.update_attributes!(status: EffectiveOrders::ACTIVE)
 
           send_email(:subscription_payment_succeeded, customer)
         when 'invoice.payment_failed'
-          customer = Effective::Customer.where(stripe_customer_id: @event.data.object.customer).first!
           customer.update_attributes!(status: EffectiveOrders::PAST_DUE)
 
           send_email(:subscription_payment_failed, customer)
         when 'customer.subscription.deleted'
-          customer = Effective::Customer.where(stripe_customer_id: @event.data.object.customer).first!
           customer.update_attributes!(stripe_subscription_id: nil, status: nil, active_card: nil)
           customer.subscriptions.delete_all
 
           send_email(:subscription_canceled, customer)
+        when 'customer.subscription.created'
+          send_email(:subscription_created, customer)
+        when 'customer.subscription.updated'
+          send_email(:subscription_updated, customer)
         else
           Rails.logger.info "[STRIPE WEBHOOK] Unhandled event type #{@event.type}"
         end
@@ -64,6 +65,10 @@ module Effective
 
     private
 
+    def customer
+      @customer ||= Effective::Customer.where(stripe_customer_id: @event.data.object.customer).first!
+    end
+
     def send_email(email, *mailer_args)
       Effective::OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
     end

data/app/helpers/effective_subscriptions_helper.rb

@@ -64,6 +64,4 @@ module EffectiveSubscriptionsHelper
     }
   end
 
-
-
 end

data/app/mailers/effective/orders_mailer.rb

@@ -1,46 +1,30 @@
 module Effective
   class OrdersMailer < ActionMailer::Base
-    helper EffectiveOrdersHelper
+    default from: EffectiveOrders.mailer[:default_from]
 
+    helper EffectiveOrdersHelper
     layout EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout'
 
     def order_receipt_to_admin(order_param)
       return true unless EffectiveOrders.mailer[:send_order_receipt_to_admin]
 
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+      @user = @order.user
 
-      mail(
-        to: EffectiveOrders.mailer[:admin_email],
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_order_receipt_to_admin(@order)
-      )
+      @subject = subject_for(@order, :order_receipt_to_admin, "Order Receipt: ##{@order.to_param}")
+
+      mail(to: EffectiveOrders.mailer[:admin_email], from: EffectiveOrders.mailer[:default_from], subject: @subject)
     end
 
     def order_receipt_to_buyer(order_param)  # Buyer
       return true unless EffectiveOrders.mailer[:send_order_receipt_to_buyer]
 
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+      @user = @order.user
 
-      mail(
-        to: @order.user.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_order_receipt_to_buyer(@order)
-      )
-    end
+      @subject = subject_for(@order, :order_receipt_to_buyer, "Order Receipt: ##{@order.to_param}")
 
-    def order_receipt_to_seller(order_param, seller, order_items)
-      return true unless EffectiveOrders.mailer[:send_order_receipt_to_seller]
-
-      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-      @user = seller.user
-      @order_items = order_items
-      @subject = subject_for_order_receipt_to_seller(@order, @order_items, seller.user)
-
-      mail(
-        to: @user.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: @subject
-      )
+      mail(to: @order.user.email, subject: @subject)
     end
 
     # This is sent when an admin creates a new order or /admin/orders/new
@@ -49,12 +33,11 @@ module Effective
       return true unless EffectiveOrders.mailer[:send_payment_request_to_buyer]
 
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+      @user = @order.user
 
-      mail(
-        to: @order.user.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_payment_request_to_buyer(@order)
-      )
+      @subject = subject_for(@order, :payment_request_to_buyer, "Request for Payment: Invoice ##{@order.to_param}")
+
+      mail(to: @order.user.email, subject: @subject)
     end
 
     # This is sent when someone chooses to Pay by Cheque
@@ -62,12 +45,11 @@ module Effective
       return true unless EffectiveOrders.mailer[:send_pending_order_invoice_to_buyer]
 
       @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+      @user = @order.user
 
-      mail(
-        to: @order.user.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_pending_order_invoice_to_buyer(@order)
-      )
+      @subject = subject_for(@order, :pending_order_invoice_to_buyer, "Pending Order: ##{@order.to_param}")
+
+      mail(to: @order.user.email, subject: @subject)
     end
 
     # Sent by the invoice.payment_succeeded webhook event
@@ -75,12 +57,12 @@ module Effective
       return true unless EffectiveOrders.mailer[:send_subscription_payment_succeeded]
 
       @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+      @subscriptions = @customer.subscriptions
+      @user = @customer.user
 
-      mail(
-        to: @customer.user.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_subscription_payment_succeeded(@customer)
-      )
+      @subject = subject_for(@customer, :subscription_payment_succeeded, 'Thank you for your payment')
+
+      mail(to: @customer.user.email, subject: @subject)
     end
 
     # Sent by the invoice.payment_failed webhook event
@@ -88,12 +70,38 @@ module Effective
       return true unless EffectiveOrders.mailer[:send_subscription_payment_failed]
 
       @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+      @subscriptions = @customer.subscriptions
+      @user = @customer.user
 
-      mail(
-        to: @customer.user.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_subscription_payment_failed(@customer)
-      )
+      @subject = subject_for(@customer, :subscription_payment_failed, 'Payment failed - please update your card details')
+
+      mail(to: @customer.user.email, subject: @subject)
+    end
+
+    # Sent by the customer.subscription.created webhook event
+    def subscription_created(customer_param)
+      return true unless EffectiveOrders.mailer[:send_subscription_created]
+
+      @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+      @subscriptions = @customer.subscriptions
+      @user = @customer.user
+
+      @subject = subject_for(@customer, :subscription_created, 'New Subscription')
+
+      mail(to: @customer.user.email, subject: @subject)
+    end
+
+    # Sent by the customer.subscription.updated webhook event
+    def subscription_updated(customer_param)
+      return true unless EffectiveOrders.mailer[:send_subscription_updated]
+
+      @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+      @subscriptions = @customer.subscriptions
+      @user = @customer.user
+
+      @subject = subject_for(@customer, :subscription_updated, 'Subscription Changed')
+
+      mail(to: @customer.user.email, subject: @subject)
     end
 
     # Sent by the invoice.payment_failed webhook event
@@ -101,25 +109,24 @@ module Effective
       return true unless EffectiveOrders.mailer[:send_subscription_canceled]
 
       @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+      @subscriptions = @customer.subscriptions
+      @user = @customer.user
 
-      mail(
-        to: @customer.user.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_subscription_canceled(@customer)
-      )
+      @subject = subject_for(@customer, :subscription_canceled, 'Subscription canceled')
+
+      mail(to: @customer.user.email, subject: @subject)
     end
 
     # Sent by the effective_orders:notify_trial_users rake task.
-    def subscription_trial_expiring(subscribable)
-      return true unless EffectiveOrders.mailer[:send_subscription_trial_expiring]
+    def subscription_trialing(subscribable)
+      return true unless EffectiveOrders.mailer[:send_subscription_trialing]
 
       @subscribable = subscribable
+      @user = @subscribable.subscribable_buyer
 
-      mail(
-        to: @subscribable.subscribable_buyer.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_subscription_trial_expiring(@subscribable)
-      )
+      @subject = subject_for(@customer, :subscription_trialing, 'Trial is active')
+
+      mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
     end
 
     # Sent by the effective_orders:notify_trial_users rake task.
@@ -127,28 +134,23 @@ module Effective
       return true unless EffectiveOrders.mailer[:send_subscription_trial_expired]
 
       @subscribable = subscribable
+      @user = @subscribable.subscribable_buyer
 
-      mail(
-        to: @subscribable.subscribable_buyer.email,
-        from: EffectiveOrders.mailer[:default_from],
-        subject: subject_for_subscription_trial_expired(@subscribable)
-      )
+      @subject = subject_for(@customer, :subscription_trial_expired, 'Trial expired')
+
+      mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
     end
 
     def order_error(order: nil, error: nil, to: nil, from: nil, subject: nil, template: 'order_error')
-      if order.present?
-        @order = (order.kind_of?(Effective::Order) ? order : Effective::Order.find(order))
-        @subject = (subject || "An error occurred with order: ##{@order.try(:to_param)}")
-      else
-        @subject = (subject || "An order error occurred with an unknown order")
-      end
-
+      @order = (order.kind_of?(Effective::Order) ? order : Effective::Order.find(order))
       @error = error.to_s
 
+      @subject = subject_for(@order, :error, "An error occurred with order: ##{@order.try(:to_param)}")
+
       mail(
         to: (to || EffectiveOrders.mailer[:admin_email]),
         from: (from || EffectiveOrders.mailer[:default_from]),
-        subject: prefix_subject(@subject),
+        subject: (subject || @subject)
       ) do |format|
         format.html { render(template) }
       end
@@ -156,109 +158,15 @@ module Effective
 
     private
 
-    def subject_for_order_receipt_to_admin(order)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_order_receipt_to_admin]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || "Order Receipt: ##{order.to_param}")
-    end
-
-    def subject_for_order_receipt_to_buyer(order)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_order_receipt_to_buyer]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || "Order Receipt: ##{order.to_param}")
-    end
-
-    def subject_for_order_receipt_to_seller(order, order_items, seller)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_order_receipt_to_seller]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, order_items, seller, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || "#{order_items.length} of your products #{order_items.length > 1 ? 'have' : 'has'} been purchased")
-    end
-
-    def subject_for_payment_request_to_buyer(order)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_payment_request_to_buyer]
+    def subject_for(order, action, fallback)
+      subject = EffectiveOrders.mailer["subject_for_#{action}".to_sym]
+      prefix = EffectiveOrders.mailer[:subject_prefix].to_s
 
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || "Request for Payment: Invoice ##{order.to_param}")
-    end
-
-    def subject_for_pending_order_invoice_to_buyer(order)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_pending_order_invoice_to_buyer]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || "Pending Order: ##{order.to_param}")
-    end
-
-    def subject_for_subscription_payment_succeeded(customer)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_payment_succeeded]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
+      subject = self.instance_exec(order, &subject) if subject.respond_to?(:call)
+      subject = subject.presence || fallback
 
-      prefix_subject(string_or_callable.presence || 'Thank you for your payment')
+      prefix.present? ? (prefix.chomp(' ') + ' ' + subject) : subject
     end
 
-    def subject_for_subscription_payment_failed(customer)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_payment_failed]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || 'Payment failed - please update your card details')
-    end
-
-    def subject_for_subscription_canceled(customer)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_canceled]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || 'Subscription canceled')
-    end
-
-    def subject_for_subscription_trial_expiring(customer)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_trial_expiring]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || 'Trial expiring soon')
-    end
-
-    def subject_for_subscription_trial_expired(customer)
-      string_or_callable = EffectiveOrders.mailer[:subject_for_subscription_trial_expired]
-
-      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
-        string_or_callable = self.instance_exec(order, &string_or_callable)
-      end
-
-      prefix_subject(string_or_callable.presence || 'Trial expired')
-    end
-
-    def prefix_subject(text)
-      prefix = (EffectiveOrders.mailer[:subject_prefix].to_s rescue '')
-      prefix.present? ? (prefix.chomp(' ') + ' ' + text) : text
-    end
   end
 end

data/app/views/effective/orders_mailer/subscription_created.html.haml

@@ -0,0 +1,13 @@
+%p.effective-orders-receipt-info Subscription created
+
+%p Thank you for subscribing!
+
+%p You are currently subscribed to the following:
+
+%ul
+  - @subscriptions.each do |subscription|
+    %li #{subscription.subscribable.to_s} - #{subscription}
+
+%p Please click the following link to view past invoices or update your card settings:
+
+%p= link_to(effective_orders.customer_settings_url, effective_orders.customer_settings_url)

data/app/views/effective/orders_mailer/subscription_updated.html.haml

@@ -0,0 +1,13 @@
+%p.effective-orders-receipt-info Subscription updated
+
+%p Your subscription has changed
+
+%p You are currently subscribed to the following:
+
+%ul
+  - @subscriptions.each do |subscription|
+    %li #{subscription.subscribable.to_s} - #{subscription}
+
+%p Please click the following link to view past invoices or update your card settings:
+
+%p= link_to(effective_orders.customer_settings_url, effective_orders.customer_settings_url)

data/config/effective_orders.rb

@@ -112,21 +112,19 @@ EffectiveOrders.setup do |config|
   config.pretend_message = '* payment information is not required to process this order at this time.'
 
   # Mailer Settings
-  # effective_orders will send out receipts to the buyer, seller and admins.
+  # effective_orders sends out receipts to buyers and admins as well as trial and subscription related emails.
   # For all the emails, the same :subject_prefix will be prefixed.  Leave as nil / empty string if you don't want any prefix
   #
-  # The subject_for_admin_receipt, subject_for_buyer_receipt, subject_for_payment_request and
-  # subject_for_seller_receipt can be one of:
+  # All the subject_* keys below can one of:
   # - nil / empty string to use the built in defaults
   # - A string with the full subject line for this email
   # - A Proc to create the subject line based on the email
-  # In all three of these cases, the subject_prefix will still be used.
+  # The subject_prefix will then be applied ontop of these.
+  #
+  # send_order_receipt_to_buyer: Proc.new { |order| "Order #{order.to_param} has been purchased"}
+  # subject_for_subscription_payment_succeeded: Proc.new { |order| "Order #{order.to_param} has been purchased"}
 
-  # The Procs are the same for admin & buyer receipt, the seller Proc is different
-  # subject_for_order_receipt_to_admin: Proc.new { |order| "Order #{order.to_param} has been purchased"}
-  # subject_for_order_receipt_to_buyer: Proc.new { |order| "Order #{order.to_param} has been purchased"}
-  # subject_for_payment_request_to_buyer: Proc.new { |order| "Pending Order #{order.to_param}"}
-  # subject_for_order_receipt_to_seller: Proc.new { |order, order_items, seller| "Order #{order.to_param} has been purchased"}
+  # subject_for_subscription_trialing: Proc.new { |subscribable| "Pending Order #{order.to_param}"}
 
   config.mailer = {
     send_order_receipt_to_admin: true,
@@ -135,23 +133,32 @@ EffectiveOrders.setup do |config|
     send_pending_order_invoice_to_buyer: true,
     send_order_receipts_when_mark_as_paid: false,
 
+    send_subscription_created: true,
+    send_subscription_updated: true,
+    send_subscription_canceled: true,
     send_subscription_payment_succeeded: true,
     send_subscription_payment_failed: true,
-    send_subscription_canceled: true,
-    send_subscription_trial_expiring: true,   # Only if you schedule the rake task to run
+
+    send_subscription_trialing: true,   # Only if you schedule the rake task to run
     send_subscription_trial_expired: true,    # Only if you schedule the rake task to run
 
     subject_prefix: '[example]',
 
+    # Procs yield an Effective::Order object
     subject_for_order_receipt_to_admin: '',
     subject_for_order_receipt_to_buyer: '',
     subject_for_payment_request_to_buyer: '',
     subject_for_pending_order_invoice_to_buyer: '',
 
+    # Procs yield an Effective::Customer object
+    subject_for_subscription_created: '',
+    subject_for_subscription_updated: '',
+    subject_for_subscription_canceled: '',
     subject_for_subscription_payment_succeeded: '',
     subject_for_subscription_payment_failed: '',
-    subject_for_subscription_canceled: '',
-    subject_for_subscription_trial_expiring: '',
+
+    # Procs yield the acts_as_subscribable object
+    subject_for_subscription_trialing: '',
     subject_for_subscription_trial_expired: '',
 
     layout: 'effective_orders_mailer_layout',

data/lib/effective_orders/version.rb

@@ -1,3 +1,3 @@
 module EffectiveOrders
-  VERSION = '4.0.0beta12'.freeze
+  VERSION = '4.0.0beta13'.freeze
 end

data/lib/generators/effective_orders/install_generator.rb

@@ -23,6 +23,19 @@ module EffectiveOrders
         template ('../' * 3) + 'config/effective_orders.rb', 'config/initializers/effective_orders.rb'
       end
 
+      def copy_mailer_layout
+        layout = 'app/views/layouts/effective_orders_mailer_layout.html.haml'
+        template ('../' * 3) + layout, layout
+      end
+
+      def copy_mailer_templates
+        path = 'app/views/effective/orders_mailer/'
+
+        Dir["#{source_paths.first}/../../../#{path}**"].map { |file| file.split('/').last }.each do |name|
+          template (('../' * 3) + path + name), (path + name)
+        end
+      end
+
       def copy_mailer_preview
         mailer_preview_path = (Rails.application.config.action_mailer.preview_path rescue nil)
 

data/lib/generators/templates/effective_orders_mailer_preview.rb

@@ -11,11 +11,6 @@ class EffectiveOrdersMailerPreview < ActionMailer::Preview
     Effective::OrdersMailer.order_receipt_to_buyer(build_preview_order)
   end
 
-  def order_receipt_to_seller
-    order = build_preview_order
-    Effective::OrdersMailer.order_receipt_to_seller(order, preview_customer, order.order_items)
-  end
-
   def payment_request_to_buyer
     Effective::OrdersMailer.payment_request_to_buyer(build_preview_order)
   end
@@ -32,12 +27,20 @@ class EffectiveOrdersMailerPreview < ActionMailer::Preview
     Effective::OrdersMailer.subscription_payment_failed(preview_customer)
   end
 
+  def subscription_created
+    Effective::OrdersMailer.subscription_created(preview_customer)
+  end
+
+  def subscription_updated
+    Effective::OrdersMailer.subscription_updated(preview_customer)
+  end
+
   def subscription_canceled
     Effective::OrdersMailer.subscription_canceled(preview_customer)
   end
 
-  def subscription_trial_expiring
-    Effective::OrdersMailer.subscription_trial_expiring(preview_subscribable)
+  def subscription_trialing
+    Effective::OrdersMailer.subscription_trialing(preview_subscribable)
   end
 
   def subscription_trial_expired
@@ -51,7 +54,7 @@ class EffectiveOrdersMailerPreview < ActionMailer::Preview
   protected
 
   def build_preview_order
-    order = Effective::Order.new
+    order = Effective::Order.new(id: 1)
     order.user = preview_user
     preview_order_items.each { |atts| order.order_items.build(atts) }
     order.valid?
@@ -90,22 +93,24 @@ class EffectiveOrdersMailerPreview < ActionMailer::Preview
   end
 
   def preview_customer
-    Effective::Customer.new(user: preview_user, active_card: '**** **** **** 1234 Visa 04/20')
+    customer = Effective::Customer.new(user: preview_user, active_card: '**** **** **** 1234 Visa 04/20')
+
+    if preview_subscribable.present?
+      customer.subscriptions.build(subscribable: preview_subscribable, name: 'Bronze Plan')
+      customer.subscriptions.build(subscribable: preview_subscribable, name: 'Silver Plan')
+    end
+
+    customer
   end
 
   def preview_subscribable
-    Class.new do
-      include ActiveModel::Model
-      attr_accessor :buyer
+    Rails.application.eager_load!
 
-      def to_s
-        'My cool service'
-      end
+    klasses = Array(ActsAsSubscribable.descendants).compact
+    return unless klasses.present?
 
-      def trial_expires_at
-        Time.zone.now + 1.day
-      end
-    end.new(buyer: preview_user)
+    klasses.map { |klass| klass.all.order(Arel.sql('random()')).first }.compact.first ||
+    klasses.first.new(subscribable_buyer: preview_user)
   end
 
 end

data/lib/tasks/effective_orders_tasks.rake

@@ -28,10 +28,9 @@ namespace :effective_orders do
     end
   end
 
-
-# rake effective_orders:send_trial_expiring_emails
-  desc 'Sends trial expiring and expired emails to each subscribable. Schedule me to run once per day.'
-  task send_trial_expiring_emails: :environment do
+  # rake effective_orders:send_trial_emails
+  desc 'Sends subscription_trialing and subscription_trial_expired emails to each subscribable. Schedule me to run once per day.'
+  task send_trial_emails: :environment do
     trial_remind_at = Array(EffectiveOrders.trial[:remind_at]).compact
     exit unless trial_remind_at.present? && trial_remind_at.all? { |x| x.present? }
 
@@ -43,6 +42,7 @@ namespace :effective_orders do
     begin
       ActsAsSubscribable.descendants.each do |klass|
         klass.trialing.find_each do |subscribable|
+
           if subscribable.trialing_until == today
             puts "sending trial expired to #{subscribable}"
             Effective::OrdersMailer.subscription_trial_expired(subscribable).deliver_now
@@ -50,25 +50,21 @@ namespace :effective_orders do
 
           next if subscribable.trial_past_due? # We already notified them
 
-          reminders.each do |remind_at|
-            date = (subscribable.trialing_until - EffectiveOrders.trial.fetch(:length)) # Should be same as created_at.beginning_of_day
+          date = (subscribable.trialing_until - EffectiveOrders.trial.fetch(:length)) # Should be same as created_at.beginning_of_day
 
+          reminders.each do |remind_at|
             next unless date == (today + remind_at)
-
-            puts "sending trial expiring to #{subscribable}. expires in #{(subscribable.trialing_until - today) / 1.day.to_i} days."
-            Effective::OrdersMailer.subscription_trial_expiring(subscribable).deliver_now
+            Effective::OrdersMailer.subscription_trialing(subscribable).deliver_now
           end
         end
       end
 
-      puts 'send_trial_expiring_emails completed'
-      EffectiveLogger.success('scheduled task send_trial_expiring_emails completed') if defined?(EffectiveLogger)
+      puts 'send_trial_emails completed'
+      EffectiveLogger.success('scheduled task send_trial_emails completed') if defined?(EffectiveLogger)
     rescue => e
       ExceptionNotifier.notify_exception(e) if defined?(ExceptionNotifier)
       raise e
     end
-
-    true
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_orders
 version: !ruby/object:Gem::Version
-  version: 4.0.0beta12
+  version: 4.0.0beta13
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-31 00:00:00.000000000 Z
+date: 2018-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -223,10 +223,12 @@ files:
 - app/views/effective/orders_mailer/payment_request_to_buyer.html.haml
 - app/views/effective/orders_mailer/pending_order_invoice_to_buyer.html.haml
 - app/views/effective/orders_mailer/subscription_canceled.html.haml
+- app/views/effective/orders_mailer/subscription_created.html.haml
 - app/views/effective/orders_mailer/subscription_payment_failed.html.haml
 - app/views/effective/orders_mailer/subscription_payment_succeeded.html.haml
 - app/views/effective/orders_mailer/subscription_trial_expired.html.haml
-- app/views/effective/orders_mailer/subscription_trial_expiring.html.haml
+- app/views/effective/orders_mailer/subscription_trialing.html.haml
+- app/views/effective/orders_mailer/subscription_updated.html.haml
 - app/views/effective/subscripter/_form.html.haml
 - app/views/effective/subscriptions/_plan.html.haml
 - app/views/effective/subscriptions/_subscription.html.haml