disco_app 0.12.5

data/app/helpers/disco_app/application_helper.rb

@@ -0,0 +1,68 @@
+module DiscoApp::ApplicationHelper
+
+  # Generates a link pointing to an object (such as an order or customer) inside
+  # the given shop's Shopify admin. This helper makes it easy to  create links
+  # to objects within the admin that support both right-clicking and opening in
+  # a new tab as well as capturing a left click and redirecting to the relevant
+  # object using `ShopifyApp.redirect()`.
+  def link_to_shopify_admin(shop, name, admin_path, options = {})
+    options[:onclick] = "ShopifyApp.redirect('#{admin_path}'); return false;"
+    options[:'data-no-turbolink'] = true
+    link_to(name, "https://#{shop.shopify_domain}/admin/#{admin_path}", options)
+  end
+
+  # Generate a link that will open its href in an embedded Shopify modal.
+  def link_to_modal(name, path, options = {})
+    modal_options = {
+      src: path,
+      title: options.delete(:modal_title),
+      width: options.delete(:modal_width),
+      height: options.delete(:modal_height),
+      buttons: options.delete(:modal_buttons),
+    }
+    options[:onclick] = "ShopifyApp.Modal.open(#{modal_options.to_json}); return false;"
+    options[:onclick].gsub!(/"function(.*?)"/, 'function\1')
+    link_to(name, path, options)
+  end
+
+  # Render a React component with inner HTML content.
+  # Thanks to https://github.com/reactjs/react-rails/pull/166#issuecomment-86178980
+  def react_component_with_content(name, args = {}, options = {}, &block)
+    args[:__html] = capture(&block) if block.present?
+    react_component(name, args, options)
+  end
+
+  # Provide link to dynamically add a new nested fields association 
+  def link_to_add_fields(name, f, association)
+    new_object = f.object.send(association).klass.new
+    id = new_object.object_id
+    fields = f.fields_for(association, new_object, child_index: id) do |builder|
+      render(association.to_s.singularize + "_fields", f: builder)
+    end
+    link_to(name, '#', class: "add_fields", data: {id: id, fields: fields.gsub("\n", "")})
+  end
+
+  # Return the props required to instantiate a React ModelForm component for the
+  # given model instance.
+  def model_form_props(model)
+    {
+      model: model,
+      modelTitle: model.persisted? ? model.to_s : "New #{model.model_name.human.downcase}",
+      modelName: model.model_name.singular,
+      modelUrl: model.persisted? ? send("#{model.model_name.singular}_path", model) : nil,
+      modelsUrl: send("#{model.model_name.plural}_path"),
+      authenticityToken: form_authenticity_token,
+      errors: errors_to_react(model)
+    }.as_json
+  end
+
+  # Helper method that provides detailed error information from an active record as JSON
+  def errors_to_react(model)
+    {
+      type: model.model_name.human.downcase,
+      errors: model.errors.keys,
+      messages: model.errors.full_messages
+    }.as_json
+  end
+
+end

data/app/jobs/disco_app/app_installed_job.rb

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

data/app/jobs/disco_app/app_uninstalled_job.rb

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

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,21 @@
+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(shop, shop_data)
+    DiscoApp::ChargesService.cancel_recurring_charges(@shop)
+    DiscoApp::SendSubscriptionJob.perform_later(@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,8 @@
+module DiscoApp::Concerns::SubscriptionChangedJob
+  extend ActiveSupport::Concern
+
+  def perform(shop, subscription)
+    DiscoApp::SendSubscriptionJob.perform_later(@shop)
+  end
+
+end

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

@@ -0,0 +1,55 @@
+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
+      @callback_url ||= begin
+        callback_url = DiscoApp.configuration.carrier_service_callback_url
+        callback_url.respond_to?('call') ? callback_url.call : callback_url
+      end
+    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,52 @@
+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'] + (DiscoApp.configuration.webhook_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
+
+  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/send_subscription_job.rb

@@ -0,0 +1,7 @@
+class DiscoApp::SendSubscriptionJob < DiscoApp::ShopJob
+
+  def perform(shop)
+    @shop.disco_api_client.create_app_subscription
+  end
+
+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.with_api_context {
+        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/can_be_liquified.rb

@@ -0,0 +1,45 @@
+module DiscoApp::Concerns::CanBeLiquified
+  extend ActiveSupport::Concern
+
+  SPLIT_ARRAY_SEPARATOR = '@!@'
+
+  included do
+
+    # Return this model as an array of Liquid {% assign %} statements.
+    def as_liquid
+      as_json.map { |k, v| "{% assign #{liquid_model_name}_#{k} = #{as_liquid_value(k, v)} %}" }
+    end
+
+    # Render this model as a series of concatenated Liquid {% assign %} statements.
+    def to_liquid
+      as_liquid.join("\n")
+    end
+
+    # Method to allow override of the model name in Liquid. Useful for models
+    # residing in namespaces that would otherwise have very long prefixes.
+    def liquid_model_name
+      model_name.param_key
+    end
+
+    private
+
+      # Return given value as a string expression that will be evaluated in Liquid to result in the correct value type.
+      def as_liquid_value(key, value)
+        if value.is_a? Numeric or (!!value == value)
+          return value.to_s
+        end
+        if value.nil?
+          return 'nil'
+        end
+        if value.is_a? Array
+          return "'#{value.map { |e| (e.is_a? String) ? CGI::escapeHTML(e) : e }.join(SPLIT_ARRAY_SEPARATOR)}' | split: '#{SPLIT_ARRAY_SEPARATOR}'"
+        end
+        if value.is_a? String and key.end_with? '_html'
+          return "'#{value.to_s.gsub("'", "'")}'"
+        end
+        "'#{CGI::escapeHTML(value.to_s)}'"
+      end
+
+  end
+
+end

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

@@ -0,0 +1,48 @@
+module DiscoApp::Concerns::HasMetafields
+  extend ActiveSupport::Concern
+
+  included do
+
+    # Write multiple metafields for this object in a single call.
+    #
+    # Expects an argument in a nested hash structure with :namespace => :key =>
+    # :value, eg:
+    #
+    #   Product.write_metafields(myapp: {
+    #      key1: 'value1',
+    #      key2: 'value2'
+    #   })
+    #
+    # This method assumes that it is being called within a valid Shopify API
+    # session context, eg @shop.with_api_context { ... }.
+    #
+    # It also assumes that the including class has defined the appropriate value
+    # for SHOPIFY_API_CLASS and that calling the `id` method on the instance
+    # will return the relevant object's Shopify ID.
+    #
+    # Returns true on success, false otherwise.
+    def write_metafields(metafields)
+      self.class::SHOPIFY_API_CLASS.new(
+        id: id,
+        metafields: build_metafields(metafields)
+      ).save
+    end
+
+    # Give a nested hash of metafields in the format described above, return
+    # an array of corresponding ShopifyAPI::Metafield instances.
+    def build_metafields(metafields)
+      metafields.map do |namespace, keys|
+        keys.map do |key, value|
+          ShopifyAPI::Metafield.new(
+            namespace: namespace,
+            key: key,
+            value: value,
+            value_type: value.is_a?(Integer) ? :integer : :string
+          )
+        end
+      end.flatten
+    end
+
+  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