disco_app 0.9.8

data/app/jobs/disco_app/concerns/app_installed_job.rb

@@ -0,0 +1,39 @@
+module DiscoApp::Concerns::AppInstalledJob
+  extend ActiveSupport::Concern
+
+  included do
+    before_enqueue { @shop.awaiting_install! }
+    before_perform { @shop.installing! }
+    after_perform { @shop.installed! }
+  end
+
+  # Perform application installation.
+  #
+  # - Synchronise webhooks.
+  # - Synchronise carrier service, if required.
+  # - Perform initial update of shop information.
+  # - Subscribe to default plan, if any exists.
+  #
+  def perform(shop, plan_code = nil, source = nil)
+    DiscoApp::SynchroniseWebhooksJob.perform_now(@shop)
+    DiscoApp::SynchroniseCarrierServiceJob.perform_now(@shop)
+    DiscoApp::ShopUpdateJob.perform_now(@shop)
+
+    @shop.reload
+
+    if default_plan.present?
+      DiscoApp::SubscriptionService.subscribe(@shop, default_plan, plan_code, source)
+    end
+  end
+
+  # Provide an overridable hook for applications to examine the @shop object
+  # and return the default plan, if any, the shop should be subscribed to. If
+  # nil is returned, no automatic subscription will take place and the store
+  # owner will be forced to choose a plan after installation.
+  #
+  # If implementing this method, it should be memoized.
+  def default_plan
+    nil
+  end
+
+end

data/app/jobs/disco_app/concerns/app_uninstalled_job.rb

@@ -0,0 +1,20 @@
+module DiscoApp::Concerns::AppUninstalledJob
+  extend ActiveSupport::Concern
+
+  included do
+    before_enqueue { @shop.awaiting_uninstall! }
+    before_perform { @shop.uninstalling! }
+    after_perform { @shop.uninstalled! }
+  end
+
+  # Perform application uninstallation.
+  #
+  # - Mark any recurring application charges as cancelled.
+  # - Remove any stored sessions for the shop.
+  #
+  def perform(domain, shop_data)
+    DiscoApp::ChargesService.cancel_recurring_charges(@shop)
+    @shop.sessions.delete_all
+  end
+
+end

data/app/jobs/disco_app/concerns/render_asset_group_job.rb

@@ -0,0 +1,8 @@
+module DiscoApp::Concerns::RenderAssetGroupJob
+  extend ActiveSupport::Concern
+
+  def perform(shop, instance, asset_group)
+    instance.render_asset_group(asset_group.to_sym)
+  end
+
+end

data/app/jobs/disco_app/concerns/shop_update_job.rb

@@ -0,0 +1,13 @@
+module DiscoApp::Concerns::ShopUpdateJob
+  extend ActiveSupport::Concern
+
+  # Perform an update of the current shop's information.
+  def perform(shop, shop_data = nil)
+    # If we weren't provided with shop data (eg from a webhook), fetch it.
+    shop_data ||= ActiveSupport::JSON::decode(ShopifyAPI::Shop.current.to_json)
+
+    # Update attributes stored directly on the Shop model, along with the data hash itself.
+    @shop.update(shop_data.with_indifferent_access.slice(*DiscoApp::Shop.column_names).except(:id, :created_at).merge(data: shop_data))
+  end
+
+end

data/app/jobs/disco_app/concerns/subscription_changed_job.rb

@@ -0,0 +1,7 @@
+module DiscoApp::Concerns::SubscriptionChangedJob
+  extend ActiveSupport::Concern
+
+  def perform(shop, subscription)
+  end
+
+end

data/app/jobs/disco_app/concerns/synchronise_carrier_service_job.rb

@@ -0,0 +1,52 @@
+module DiscoApp::Concerns::SynchroniseCarrierServiceJob
+  extend ActiveSupport::Concern
+
+  # Ensure that any carrier service required by our app is registered.
+  def perform(shop)
+    # Don't proceed unless we have a name and callback url.
+    return unless carrier_service_name and callback_url
+
+    # Registered the carrier service if it hasn't been registered yet.
+    unless current_carrier_service_names.include?(carrier_service_name)
+      ShopifyAPI::CarrierService.create(
+        name: carrier_service_name,
+        callback_url: callback_url,
+        service_discovery: true,
+        format: :json
+      )
+    end
+
+    # Ensure any existing carrier services (with the correct name) are active
+    # and have a current callback URL.
+    current_carrier_services.each do |carrier_service|
+      if carrier_service.name == carrier_service_name
+        carrier_service.callback_url = callback_url
+        carrier_service.active = true
+        carrier_service.save
+      end
+    end
+  end
+
+  protected
+
+    def carrier_service_name
+      DiscoApp.configuration.app_name
+    end
+
+    def callback_url
+      nil
+    end
+
+  private
+
+    # Return a list of currently registered carrier service names.
+    def current_carrier_service_names
+      current_carrier_services.map(&:name)
+    end
+
+    # Return a list of currently registered carrier services.
+    def current_carrier_services
+      @current_carrier_service ||= ShopifyAPI::CarrierService.find(:all)
+    end
+
+end

data/app/jobs/disco_app/concerns/synchronise_resources_job.rb

@@ -0,0 +1,12 @@
+module DiscoApp::Concerns::SynchroniseResourcesJob
+  extend ActiveSupport::Concern
+
+  def perform(shop, class_name, params)
+    klass = class_name.constantize
+
+    klass::SHOPIFY_API_CLASS.find(:all, params: params).map do |shopify_resource|
+      klass.synchronise(@shop, shopify_resource.serializable_hash)
+    end
+  end
+
+end

data/app/jobs/disco_app/concerns/synchronise_webhooks_job.rb

@@ -0,0 +1,61 @@
+module DiscoApp::Concerns::SynchroniseWebhooksJob
+  extend ActiveSupport::Concern
+
+  # Ensure the webhooks registered with our shop are the same as those listed
+  # in our application configuration.
+  def perform(shop)
+    # Get the full list of expected webhook topics.
+    expected_topics = [:'app/uninstalled', :'shop/update'] + topics
+
+    # Registered any webhooks that haven't been registered yet.
+    (expected_topics - current_topics).each do |topic|
+      ShopifyAPI::Webhook.create(
+        topic: topic,
+        address: webhooks_url,
+        format: 'json'
+      )
+    end
+
+    # Remove any extraneous topics.
+    current_webhooks.each do |webhook|
+      unless expected_topics.include?(webhook.topic.to_sym)
+        ShopifyAPI::Webhook.delete(webhook.id)
+      end
+    end
+
+    # Ensure webhook addresses are current.
+    current_webhooks.each do |webhook|
+      unless webhook.address == webhooks_url
+        webhook.address = webhooks_url
+        webhook.save
+      end
+    end
+  end
+
+  protected
+
+    # Return a list of additional webhook topics to listen for. This method
+    # can be overridden in the application to provide a list of app-specific
+    # webhooks that should be created during synchronisation.
+    def topics
+      []
+    end
+
+  private
+
+    # Return a list of currently registered topics.
+    def current_topics
+      current_webhooks.map(&:topic).map(&:to_sym)
+    end
+
+    # Return a list of current registered webhooks.
+    def current_webhooks
+      @current_webhooks ||= ShopifyAPI::Webhook.find(:all)
+    end
+
+    # Return the absolute URL to the webhooks endpoint.
+    def webhooks_url
+      DiscoApp::Engine.routes.url_helpers.webhooks_url
+    end
+
+end

data/app/jobs/disco_app/render_asset_group_job.rb

@@ -0,0 +1,3 @@
+class DiscoApp::RenderAssetGroupJob < DiscoApp::ShopJob
+  include DiscoApp::Concerns::RenderAssetGroupJob
+end

data/app/jobs/disco_app/shop_job.rb

@@ -0,0 +1,27 @@
+# The base class for all jobs that should be performed in the context of a
+# particular Shop's API session. The first argument to any job inheriting from
+# this class must be the domain of the relevant store, so that the appropriate
+# Shop model can be fetched and the temporary API session created.
+class DiscoApp::ShopJob < ActiveJob::Base
+
+  queue_as :default
+
+  before_perform { |job| find_shop(job) }
+  before_enqueue { |job| find_shop(job) }
+
+  around_enqueue { |job, block| shop_context(job, block) }
+  around_perform { |job, block| shop_context(job, block) }
+
+  private
+
+    def find_shop(job)
+      @shop ||= job.arguments.first.is_a?(DiscoApp::Shop) ? job.arguments.first : DiscoApp::Shop.find_by!(shopify_domain: job.arguments.first)
+    end
+
+    def shop_context(job, block)
+      @shop.temp {
+        block.call(job.arguments)
+      }
+    end
+
+end

data/app/jobs/disco_app/shop_update_job.rb

@@ -0,0 +1,3 @@
+class DiscoApp::ShopUpdateJob < DiscoApp::ShopJob
+  include DiscoApp::Concerns::ShopUpdateJob
+end

data/app/jobs/disco_app/subscription_changed_job.rb

@@ -0,0 +1,3 @@
+class DiscoApp::SubscriptionChangedJob < DiscoApp::ShopJob
+  include DiscoApp::Concerns::SubscriptionChangedJob
+end

data/app/jobs/disco_app/synchronise_carrier_service_job.rb

@@ -0,0 +1,3 @@
+class DiscoApp::SynchroniseCarrierServiceJob < DiscoApp::ShopJob
+  include DiscoApp::Concerns::SynchroniseCarrierServiceJob
+end

data/app/jobs/disco_app/synchronise_resources_job.rb

@@ -0,0 +1,3 @@
+class DiscoApp::SynchroniseResourcesJob < DiscoApp::ShopJob
+  include DiscoApp::Concerns::SynchroniseResourcesJob
+end

data/app/jobs/disco_app/synchronise_webhooks_job.rb

@@ -0,0 +1,3 @@
+class DiscoApp::SynchroniseWebhooksJob < DiscoApp::ShopJob
+  include DiscoApp::Concerns::SynchroniseWebhooksJob
+end

data/app/models/disco_app/app_settings.rb

@@ -0,0 +1,3 @@
+class DiscoApp::AppSettings < ActiveRecord::Base
+  include DiscoApp::Concerns::AppSettings
+end

data/app/models/disco_app/application_charge.rb

@@ -0,0 +1,18 @@
+class DiscoApp::ApplicationCharge < ActiveRecord::Base
+
+  belongs_to :shop
+  belongs_to :subscription
+
+  enum status: [:pending, :accepted, :declined, :expired, :active]
+
+  scope :active, -> { where status: statuses[:active] }
+
+  def recurring?
+    false
+  end
+
+  def activate_url
+    DiscoApp::Engine.routes.url_helpers.activate_subscription_charge_url(subscription, self)
+  end
+
+end

data/app/models/disco_app/concerns/app_settings.rb

@@ -0,0 +1,7 @@
+module DiscoApp::Concerns::AppSettings
+  extend ActiveSupport::Concern
+
+  included do
+    acts_as_singleton
+  end
+end

data/app/models/disco_app/concerns/plan.rb

@@ -0,0 +1,26 @@
+module DiscoApp::Concerns::Plan
+  extend ActiveSupport::Concern
+
+  included do
+
+    has_many :subscriptions
+    has_many :shops, through: :subscriptions
+    has_many :plan_codes, dependent: :destroy
+
+    accepts_nested_attributes_for :plan_codes, allow_destroy: true
+
+    enum status: [:available, :unavailable]
+    enum plan_type: [:recurring, :one_time]
+    enum interval: [:month, :year]
+
+    scope :available, -> { where status: statuses[:available] }
+
+    validates_presence_of :name
+
+  end
+
+  def has_trial?
+    trial_period_days.present? and trial_period_days > 0
+  end
+
+end

data/app/models/disco_app/concerns/plan_code.rb

@@ -0,0 +1,15 @@
+module DiscoApp::Concerns::PlanCode
+  extend ActiveSupport::Concern
+
+  included do
+
+    belongs_to :plan
+
+    enum status: [:available, :unavailable]
+
+    validates_presence_of :code
+    validates_presence_of :amount
+
+  end
+
+end

data/app/models/disco_app/concerns/renders_assets.rb

@@ -0,0 +1,166 @@
+require 'render_anywhere'
+require 'uglifier'
+
+module DiscoApp::Concerns::RendersAssets
+  extend ActiveSupport::Concern
+
+  included do
+    include RenderAnywhere
+    after_commit :queue_render_asset_group_job
+  end
+
+  class_methods do
+
+    # Ruby "macro" that allows the definition of a number of Shopify assets that
+    # should be rendered and uploaded when certain attributes on the including
+    # class change. This assumes that the including class (1) is an ActiveRecord
+    # model that supports an `after_commit` callback; and (2) that the model has
+    # a `shop` method (or attribute) that references the DiscoApp::Shop instance
+    # associated with the current model.
+    #
+    # Options
+    #
+    #   assets:           Required. A list of asset templates to be rendered and
+    #                     uploaded to Shopify. The order of assets matters only
+    #                     in that subsequent asset templates will have access to
+    #                     the public CDN url of earlier-rendered assets through
+    #                     a "@public_urls" context variable.
+    #
+    #   triggered_by:     Optional. A list of attributes that should trigger the
+    #                     re-rendering and upload of the assets defined by the
+    #                     `assets` option, provided as a list of string. If
+    #                     empty or nil, nothing will be triggered.
+    #
+    #   script_tags:      Optional. A list of assets that should have script
+    #                     tags created or updated after being rendered to the
+    #                     storefront.
+    #
+    #   minify:           Optional. Whether Javascript assets should be minified
+    #                     after being rendered. Defaults to true in production
+    #                     environments, false otherwise. Note that stylesheet
+    #                     assets, when uploaded as .scss files, are
+    #                     automatically minified by Shopify, so we don't need to
+    #                     do it on our end.
+    #
+    def renders_assets(*asset_groups)
+      options = asset_groups.last.is_a?(Hash) ? asset_groups.pop : {}
+      options = renders_assets_default_options.merge(options)
+
+      # Ensure assets, triggered by and script tag options are arrays.
+      options[:assets] = options[:assets] ? Array(options[:assets]).map(&:to_sym) : []
+      options[:triggered_by] = options[:triggered_by] ? Array(options[:triggered_by]).map(&:to_s) : []
+      options[:script_tags] = options[:script_tags] ? Array(options[:script_tags]).map(&:to_sym) : []
+
+      asset_groups.each do |asset_group|
+        renderable_asset_groups[asset_group.to_sym] = options
+      end
+    end
+
+    # Return a list of renderable asset groups, along with their options.
+    def renderable_asset_groups
+      @renderable_asset_groups ||= {}
+    end
+
+    # Return the default options for the `renders_assets` macro.
+    def renders_assets_default_options
+      {
+        assets: nil,
+        triggered_by: nil,
+        script_tags: nil,
+        minify: Rails.env.production?
+      }
+    end
+
+  end
+
+  # Callback, triggered after a model save. Iterates through each asset group
+  # defined on the model and queues a render job if any of the changed
+  # attributes are found in the asset group's triggered_by list.
+  def queue_render_asset_group_job
+    renderable_asset_groups.each do |asset_group, options|
+      unless (previous_changes.keys & options[:triggered_by]).empty?
+        DiscoApp::RenderAssetGroupJob.perform_later(shop, self, asset_group.to_s)
+      end
+    end
+  end
+
+  # Copies the class-level hash of assets with symbol asset name as keys and
+  # their corresponding options as values to the instance.
+  def renderable_asset_groups
+    @renderable_asset_groups ||= self.class.renderable_asset_groups.dup
+  end
+
+  # Render the specified asset group and upload the result to Shopify.
+  def render_asset_group(asset_group)
+    options = renderable_asset_groups[asset_group]
+    public_urls = {}
+
+    options[:assets].each do |asset|
+      # Create/replace the asset via the Shopify API.
+      shopify_asset = shop.temp {
+        ShopifyAPI::Asset.create(
+          key: asset,
+          value: render_asset_group_asset(asset, public_urls, options)
+        )
+      }
+
+      # Store the public URL to this asset, so that we're able to use it in
+      # subsequent template renders. Adds a .css suffix to .scss assets, so that
+      # we use the Shopify-compiled version of any SCSS stylesheets.
+      if shopify_asset.public_url.present?
+        public_urls[asset] = shopify_asset.public_url.gsub(/\.scss\?/, '.scss.css?')
+      end
+    end
+
+    # If we specified the creation of any script tags based on newly rendered
+    # assets, do that now.
+    unless options[:script_tags].empty?
+      render_asset_script_tags(options, public_urls)
+    end
+  end
+
+  private
+
+    # Render an individual asset within an asset group.
+    def render_asset_group_asset(asset, public_urls, options)
+      rendered_asset = render_asset_renderer.render_to_string(
+        template: asset,
+        layout: nil,
+        locals: {
+          :"@#{self.class.name.underscore}" => self,
+          :@public_urls => public_urls
+        }
+      )
+
+      if should_be_minified?(asset, options)
+        ::Uglifier.compile(rendered_asset)
+      else
+        rendered_asset
+      end
+    end
+
+    # Return true if the given asset should be minified with Uglifier.
+    def should_be_minified?(asset, options)
+      asset.to_s.end_with?('.js') and options[:minify]
+    end
+
+    def render_asset_renderer
+      @render_asset_renderer ||= self.class.const_get('RenderingController').new
+    end
+
+    # Render any script tags defined by the :script_tags options that we have
+    # a public URL for.
+    def render_asset_script_tags(options, public_urls)
+      # Fetch the current set of script tags for the store.
+      current_script_tags = shop.temp { ShopifyAPI::ScriptTag.find(:all) }
+
+      # Iterate each script tag for which we have a known public URL and create
+      # or update the corresponding script tag resource.
+      public_urls.slice(*options[:script_tags]).each do |asset, public_url|
+        script_tag = current_script_tags.find(lambda { ShopifyAPI::ScriptTag.new(event: 'onload') }) { |script_tag| script_tag.src.include?("#{asset}?") }
+        script_tag.src = public_url
+        shop.temp { script_tag.save }
+      end
+    end
+
+end

data/app/models/disco_app/concerns/shop.rb

@@ -0,0 +1,68 @@
+module DiscoApp::Concerns::Shop
+  extend ActiveSupport::Concern
+
+  included do
+    include ShopifyApp::Shop
+    include ActionView::Helpers::DateHelper
+
+    # Define relationships to plans and subscriptions.
+    has_many :subscriptions
+    has_many :plans, through: :subscriptions
+
+    # Define relationship to sessions.
+    has_many :sessions, class_name: 'DiscoApp::Session', dependent: :destroy
+
+    # Define possible installation statuses as an enum.
+    enum status: [:never_installed, :awaiting_install, :installing, :installed, :awaiting_uninstall, :uninstalling, :uninstalled]
+
+    # Define some useful scopes.
+    scope :status, -> (status) { where status: status }
+    scope :installed, -> { where status: statuses[:installed] }
+    scope :has_active_shopify_plan, -> { where.not(plan_name: [:cancelled, :frozen, :fraudulent]) }
+
+    # Alias 'with_shopify_session' as 'temp', as per our existing conventions.
+    alias_method :temp, :with_shopify_session
+
+    # Return true if the shop is considered as in development mode.
+    def development?
+      ['staff', 'custom'].include?(plan_name)
+    end
+
+    # Convenience method to check if this shop has a current subscription.
+    def current_subscription?
+      current_subscription.present?
+    end
+
+    # Convenience method to get the current subscription for this shop, if any.
+    def current_subscription
+      subscriptions.current.first
+    end
+
+    # Convenience method to get the current plan for this shop, if any.
+    def current_plan
+      current_subscription&.plan
+    end
+
+    # Return the absolute URL to the shop's storefront.
+    def url
+      "#{protocol}://#{domain}"
+    end
+
+    # Return the protocol the shop's storefront uses. This should now always be
+    # https as all Shopify stores have SSL enabled.
+    def protocol
+      'https'
+    end
+
+    # Return the absolute URL to the shop's admin.
+    def admin_url
+      "https://#{shopify_domain}/admin"
+    end
+
+    def installed_duration
+      distance_of_time_in_words_to_now(created_at.time)
+    end
+
+  end
+
+end

data/app/models/disco_app/concerns/subscription.rb

@@ -0,0 +1,60 @@
+module DiscoApp::Concerns::Subscription
+  extend ActiveSupport::Concern
+
+  included do
+
+    belongs_to :shop
+    belongs_to :plan
+    belongs_to :plan_code
+
+    has_many :one_time_charges, class_name: 'DiscoApp::ApplicationCharge', dependent: :destroy
+    has_many :recurring_charges, class_name: 'DiscoApp::RecurringApplicationCharge', dependent: :destroy
+
+    enum status: [:trial, :active, :cancelled]
+    enum subscription_type: [:recurring, :one_time]
+
+    scope :current, -> { where status: [statuses[:trial], statuses[:active]] }
+
+    after_commit :cancel_charge
+
+  end
+
+  # Only require an active charge if the amount to be charged is > 0.
+  def requires_active_charge?
+    amount > 0
+  end
+
+  # Convenience method to check if this subscription has an active charge.
+  def active_charge?
+    active_charge.present?
+  end
+
+  # Convenience method to get the active charge for this subscription.
+  def active_charge
+    charges.active.first
+  end
+
+  # Return the appropriate set of charges for this subscription's type.
+  def charges
+    recurring? ? recurring_charges : one_time_charges
+  end
+
+  def charge_class
+    recurring? ? DiscoApp::RecurringApplicationCharge : DiscoApp::ApplicationCharge
+  end
+
+  def shopify_charge_class
+    recurring? ? ShopifyAPI::RecurringApplicationCharge : ShopifyAPI::ApplicationCharge
+  end
+
+  private
+
+    # If the amount or trial period for this subscription changes, clear any
+    # active charge, as the user will need to re-authorize the charge.
+    def cancel_charge
+      return if (previous_changes.keys & ['amount', 'trial_period_days']).empty?
+      return unless active_charge?
+      active_charge.cancelled!
+    end
+
+end