disco_app 0.15.2 → 0.18.1

data/app/resources/disco_app/admin/resources/concerns/shop_resource.rb

@@ -1,10 +1,10 @@
 require 'jsonapi/resource'
 
 module DiscoApp::Admin::Resources::Concerns::ShopResource
+
   extend ActiveSupport::Concern
 
   included do
-
     attributes :domain, :status, :created_at
     attributes :email, :country_name, :currency, :plan_display_name
     attributes :current_subscription_id, :current_subscription_display_amount, :current_subscription_display_plan, :current_subscription_display_plan_code, :current_subscription_source
@@ -15,33 +15,33 @@ module DiscoApp::Admin::Resources::Concerns::ShopResource
     filters :query, :status
 
     # Adjust the base records method to ensure only models for the authenticated domain are retrieved.
-    def self.records(options = {})
+    def self.records(_options = {})
       records = DiscoApp::Shop.order(created_at: :desc)
       records
     end
 
     # Apply filters.
-    def self.apply_filter(records, filter, value, options)
+    def self.apply_filter(records, filter, value, _options)
       return records if value.blank?
 
       # Perform appropriate filtering.
       case filter
-        when :query
-          return records.where('name LIKE ? OR shopify_domain LIKE ? OR domain LIKE ?', "%#{value.first}%", "%#{value.first}%", "%#{value.first}%")
-        when :status
-          return records.where(status: value.map { |v| DiscoApp::Shop.statuses[v.to_sym] } )
-        else
-          return super(records, filter, value)
+      when :query
+        return records.where('name LIKE ? OR shopify_domain LIKE ? OR domain LIKE ?', "%#{value.first}%", "%#{value.first}%", "%#{value.first}%")
+      when :status
+        return records.where(status: value.map { |v| DiscoApp::Shop.statuses[v.to_sym] })
+      else
+        return super(records, filter, value)
       end
     end
 
     # Don't allow the update of any fields via the API.
-    def self.updatable_fields(context)
+    def self.updatable_fields(_context)
       []
     end
 
     # Don't allow the creation of any fields via the API.
-    def self.creatable_fields(context)
+    def self.creatable_fields(_context)
       []
     end
 
@@ -62,9 +62,7 @@ module DiscoApp::Admin::Resources::Concerns::ShopResource
     end
 
     def current_subscription_id
-      if @model.current_subscription?
-        @model.current_subscription.id
-      end
+      @model.current_subscription.id if @model.current_subscription?
     end
 
     def current_subscription_display_amount
@@ -94,7 +92,6 @@ module DiscoApp::Admin::Resources::Concerns::ShopResource
         '-'
       end
     end
-
   end
 
 end

data/app/resources/disco_app/admin/resources/shop_resource.rb

@@ -1,4 +1,5 @@
 class DiscoApp::Admin::Resources::ShopResource < JSONAPI::Resource
+
   include DiscoApp::Admin::Resources::Concerns::ShopResource
 
 end

data/app/services/disco_app/carrier_request_service.rb

@@ -2,13 +2,13 @@ class DiscoApp::CarrierRequestService
 
   # Return true iff the provided hmac_to_verify matches that calculated from the
   # given data and secret.
-  def self.is_valid_hmac?(body, secret, hmac_to_verify)
-    ActiveSupport::SecurityUtils.secure_compare(self.calculated_hmac(body, secret), hmac_to_verify.to_s)
+  def self.valid_hmac?(body, secret, hmac_to_verify)
+    ActiveSupport::SecurityUtils.secure_compare(calculated_hmac(body, secret), hmac_to_verify.to_s)
   end
 
   # Calculate the HMAC for the given data and secret.
   def self.calculated_hmac(body, secret)
-    digest  = OpenSSL::Digest.new('sha256')
+    digest = OpenSSL::Digest.new('sha256')
     Base64.encode64(OpenSSL::HMAC.digest(digest, secret, body)).strip
   end
 

data/app/services/disco_app/charges_service.rb

@@ -6,24 +6,22 @@ class DiscoApp::ChargesService
     # Create the charge object locally first.
     charge = subscription.charge_class.create!(
       shop: shop,
-      subscription: subscription,
+      subscription: subscription
     )
 
     # Create the charge object on Shopify.
-    shopify_charge = shop.with_api_context {
+    shopify_charge = shop.with_api_context do
       subscription.shopify_charge_class.create(
         name: subscription.plan.name,
-        price: '%.2f' % (subscription.amount.to_f / 100.0),
+        price: format('%.2f', (subscription.amount.to_f / 100.0)),
         trial_days: subscription.plan.has_trial? ? subscription.trial_period_days : nil,
         return_url: charge.activate_url,
         test: !DiscoApp.configuration.real_charges?
       )
-    }
+    end
 
     # If we couldn't create the charge on Shopify, return nil.
-    if shopify_charge.nil?
-      return nil
-    end
+    return nil if shopify_charge.nil?
 
     # Update the local record of the charge from Shopify's created charge, then
     # return it.
@@ -37,45 +35,39 @@ class DiscoApp::ChargesService
   # Attempt to activate the given Shopify charge for the given Shop using the
   # Shopify API. Returns true on successful activation, false otherwise.
   def self.activate(shop, charge)
-    begin
-      # Start by fetching the Shopify charge to check that it was accepted.
-      shopify_charge = shop.with_api_context {
-        charge.subscription.shopify_charge_class.find(charge.shopify_id)
-      }
+    # Start by fetching the Shopify charge to check that it was accepted.
+    shopify_charge = shop.with_api_context do
+      charge.subscription.shopify_charge_class.find(charge.shopify_id)
+    end
 
-      # Update the status of the local charge based on the Shopify charge.
-      charge.send("#{shopify_charge.status}!") if charge.respond_to? "#{shopify_charge.status}!"
+    # Update the status of the local charge based on the Shopify charge.
+    charge.send("#{shopify_charge.status}!") if charge.respond_to? "#{shopify_charge.status}!"
 
-      # If the charge wasn't accepted, fail and return.
-      return false unless charge.accepted?
+    # If the charge wasn't accepted, fail and return.
+    return false unless charge.accepted?
 
-      # If the charge was indeed accepted, activate it via Shopify.
-      charge.shop.with_api_context {
-        shopify_charge.activate
-      }
+    # If the charge was indeed accepted, activate it via Shopify.
+    charge.shop.with_api_context do
+      shopify_charge.activate
+    end
 
-      # If the charge was recurring, make sure that all other local recurring
-      # charges are marked inactive.
-      if charge.recurring?
-        self.cancel_recurring_charges(shop, charge)
-      end
+    # If the charge was recurring, make sure that all other local recurring
+    # charges are marked inactive.
+    cancel_recurring_charges(shop, charge) if charge.recurring?
 
-      charge.active!
+    charge.active!
 
-      true
-    rescue
-      false
-    end
+    true
+  rescue StandardError
+    false
   end
 
   # Cancel all recurring charges for the given shop. If the optional charge
   # parameter is given, it will be excluded from the cancellation.
   def self.cancel_recurring_charges(shop, charge = nil)
     charges = DiscoApp::RecurringApplicationCharge.where(shop: shop)
-    if charge.present?
-      charges = charges.where.not(id: charge)
-    end
-    charges.update_all(status: DiscoApp::RecurringApplicationCharge.statuses[:cancelled])
+    charges = charges.where.not(id: charge) if charge.present?
+    charges.update_all(status: DiscoApp::RecurringApplicationCharge.statuses[:cancelled]) # rubocop:disable Rails/SkipsModelValidations
   end
 
 end

data/app/services/disco_app/flow/create_action.rb

@@ -0,0 +1,35 @@
+require 'interactor'
+
+module DiscoApp
+  module Flow
+    class CreateAction
+
+      include Interactor
+
+      delegate :shop, :action_id, :action_run_id, :properties, to: :context
+      delegate :action, to: :context
+
+      def call
+        create_action
+        enqueue_process_action_job
+      end
+
+      private
+
+        def create_action
+          context.action = shop.flow_actions.create!(
+            action_id: action_id,
+            action_run_id: action_run_id,
+            properties: properties
+          )
+        rescue ActiveRecord::RecordNotUnique, PG::UniqueViolation
+          context.fail!
+        end
+
+        def enqueue_process_action_job
+          ProcessActionJob.perform_later(shop, action)
+        end
+
+    end
+  end
+end

data/app/services/disco_app/flow/create_trigger.rb

@@ -0,0 +1,34 @@
+require 'interactor'
+
+module DiscoApp
+  module Flow
+    class CreateTrigger
+
+      include Interactor
+
+      delegate :shop, :title, :resource_name, :resource_url, :properties, to: :context
+      delegate :trigger, to: :context
+
+      def call
+        create_trigger
+        enqueue_process_trigger_job
+      end
+
+      private
+
+        def create_trigger
+          context.trigger = shop.flow_triggers.create!(
+            title: title,
+            resource_name: resource_name,
+            resource_url: resource_url,
+            properties: properties
+          )
+        end
+
+        def enqueue_process_trigger_job
+          ProcessTriggerJob.perform_later(shop, trigger)
+        end
+
+    end
+  end
+end

data/app/services/disco_app/flow/process_action.rb

@@ -0,0 +1,50 @@
+require 'interactor'
+
+module DiscoApp
+  module Flow
+    class ProcessAction
+
+      include Interactor
+
+      delegate :action, to: :context
+      delegate :action_service_class, to: :context
+
+      def call
+        validate_action
+        find_action_service_class
+        execute_action_service_class
+      end
+
+      private
+
+        def validate_action
+          context.fail! unless action.pending?
+        end
+
+        def find_action_service_class
+          context.action_service_class =
+            action.action_id.classify.safe_constantize ||
+            %(Flow::Actions::#{action.action_id.to_s.classify}).safe_constantize
+
+          return unless action_service_class.nil?
+
+          update_action(false, ["Could not find service class for #{action.action_id}"])
+          context.fail!
+        end
+
+        def execute_action_service_class
+          result = action_service_class.call(shop: action.shop, properties: action.properties)
+          update_action(result.success?, result.errors)
+        end
+
+        def update_action(success, errors)
+          action.update!(
+            status: success ? Action.statuses[:succeeded] : Action.statuses[:failed],
+            processing_errors: success ? [] : errors,
+            processed_at: Time.current
+          )
+        end
+
+    end
+  end
+end

data/app/services/disco_app/flow/process_trigger.rb

@@ -0,0 +1,72 @@
+require 'interactor'
+
+module DiscoApp
+  module Flow
+    class ProcessTrigger
+
+      include Interactor
+
+      delegate :trigger, to: :context
+      delegate :api_success, :api_errors, to: :context
+
+      def call
+        validate_trigger
+        make_api_request unless trigger_not_in_use?
+        update_trigger
+        fail_if_errors_present
+      end
+
+      private
+
+        def validate_trigger
+          context.fail! unless trigger.pending?
+        end
+
+        def make_api_request
+          context.api_success, context.api_errors = api_client.create_flow_trigger(
+            trigger.title,
+            trigger.resource_name,
+            trigger.resource_url,
+            trigger.properties
+          )
+        end
+
+        def update_trigger
+          trigger.update!(
+            status: trigger_status,
+            processing_errors: processing_errors,
+            processed_at: Time.current
+          )
+        end
+
+        def trigger_status
+          return Trigger.statuses[:skipped] if trigger_not_in_use?
+
+          api_success ? Trigger.statuses[:succeeded] : Trigger.statuses[:failed]
+        end
+
+        def processing_errors
+          return [] if trigger_not_in_use?
+          return [] if api_success
+          api_errors
+        end
+
+        def fail_if_errors_present
+          context.fail! unless trigger_not_in_use? || api_success
+        end
+
+        def api_client
+          @api_client ||= DiscoApp::GraphqlClient.new(trigger.shop)
+        end
+
+        def trigger_not_in_use?
+          trigger_usage.present? && !trigger_usage.has_enabled_flow?
+        end
+
+        def trigger_usage
+          @trigger_usage ||= TriggerUsage.find_by(shop: trigger.shop, flow_trigger_definition_id: trigger.title)
+        end
+
+    end
+  end
+end

data/app/services/disco_app/flow/update_trigger_usage.rb

@@ -0,0 +1,42 @@
+require 'interactor'
+
+module DiscoApp
+  module Flow
+    class UpdateTriggerUsage
+
+      include Interactor
+
+      delegate :shop, :flow_trigger_definition_id, :has_enabled_flow, :timestamp, to: :context
+      delegate :trigger_usage, to: :context
+
+      def call
+        find_or_create_trigger_usage
+        update_trigger_usage
+      end
+
+      private
+
+        def find_or_create_trigger_usage
+          context.trigger_usage = shop.flow_trigger_usages.create_or_find_by!(
+            flow_trigger_definition_id: flow_trigger_definition_id
+          )
+        rescue ActiveRecord::RecordNotUnique, PG::UniqueViolation
+          context.fail!
+        end
+
+        def update_trigger_usage
+          return if existing_timestamp_is_newer?
+
+          trigger_usage.update(
+            has_enabled_flow: has_enabled_flow,
+            timestamp: timestamp
+          )
+        end
+
+        def existing_timestamp_is_newer?
+          trigger_usage.timestamp.present? && timestamp < trigger_usage.timestamp
+        end
+
+    end
+  end
+end

data/app/services/disco_app/partner_app_service.rb

@@ -79,7 +79,7 @@ module DiscoApp
           form['create_form[application_url]'] = @app_url
 
           # Accept TOS
-          unless form['create_form[accepted]'].blank?
+          if form['create_form[accepted]'].present?
             form['create_form[accepted]'] = '1'
             form.hiddens.last.value = 1
           end

data/app/services/disco_app/proxy_service.rb

@@ -5,12 +5,12 @@ class DiscoApp::ProxyService
   def self.proxy_signature_is_valid?(query_string, secret)
     query_hash = Rack::Utils.parse_query(query_string)
     signature = query_hash.delete('signature').to_s
-    ActiveSupport::SecurityUtils.secure_compare(self.calculated_signature(query_hash, secret), signature)
+    ActiveSupport::SecurityUtils.secure_compare(calculated_signature(query_hash, secret), signature)
   end
 
   # Return the calculated signature for the given query hash and secret.
   def self.calculated_signature(query_hash, secret)
-    sorted_params = query_hash.collect{ |k, v| "#{k}=#{Array(v).join(',')}" }.sort.join
+    sorted_params = query_hash.map{ |k, v| "#{k}=#{Array(v).join(',')}" }.sort.join
     OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), secret, sorted_params)
   end
 

data/app/services/disco_app/request_validation_service.rb

@@ -3,12 +3,12 @@ class DiscoApp::RequestValidationService
   def self.hmac_valid?(query_string, secret)
     query_hash = Rack::Utils.parse_query(query_string)
     hmac = query_hash.delete('hmac').to_s
-    ActiveSupport::SecurityUtils.secure_compare(self.calculated_hmac(query_hash, secret), hmac)
+    ActiveSupport::SecurityUtils.secure_compare(calculated_hmac(query_hash, secret), hmac)
   end
 
   # Return the calculated hmac for the given query hash and secret.
   def self.calculated_hmac(query_hash, secret)
-    sorted_params = query_hash.collect{ |k, v| "#{k}=#{Array(v).join(',')}" }.sort.join('&')
+    sorted_params = query_hash.map{ |k, v| "#{k}=#{Array(v).join(',')}" }.sort.join('&')
     OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), secret, sorted_params)
   end
 

data/app/services/disco_app/subscription_service.rb

@@ -3,50 +3,78 @@ class DiscoApp::SubscriptionService
   # Subscribe the given shop to the given plan, optionally using the given plan
   # code and optionally tracking the subscription source.
   def self.subscribe(shop, plan, plan_code = nil, source_name = nil)
+    new(shop, plan, plan_code, source_name).subscribe
+  end
+
+  attr_reader :shop, :plan, :plan_code, :source_name
+
+  def initialize(shop, plan, plan_code = nil, source_name = nil)
+    @shop = shop
+    @plan = plan
+    @plan_code = plan_code
+    @source_name = source_name
+  end
+
+  def subscribe
+    cancel_existing_subscriptions
+
+    # Create the new subscription.
+    new_subscription = create_new_subscription
+
+    # Enqueue the subscription changed background job.
+    DiscoApp::SubscriptionChangedJob.perform_later(shop, new_subscription)
+
+    # Return the new subscription.
+    new_subscription
+  end
+
+  private
 
     # If a plan code was provided, fetch it for the given plan.
-    plan_code_instance = nil
-    if plan_code.present?
-      plan_code_instance = DiscoApp::PlanCode.available.find_by(plan: plan, code: plan_code)
+    def plan_code_instance
+      return if plan_code.blank?
+
+      @plan_code_instance ||= DiscoApp::PlanCode.available.find_by(plan: plan, code: plan_code)
     end
 
     # If a source name has been provided, fetch or create it
-    source_instance = nil
-    if source_name.present?
-      source_instance = DiscoApp::Source.find_or_create_by(source: source_name)
+    def source_instance
+      return if source_name.blank?
+
+      @source_instance ||= DiscoApp::Source.find_or_create_by(source: source_name)
     end
 
     # Cancel any existing current subscriptions.
-    shop.subscriptions.current.update_all(
-      status: DiscoApp::Subscription.statuses[:cancelled],
-      cancelled_at: Time.now
-    )
+    def cancel_existing_subscriptions
+      shop.subscriptions.current.update_all( # rubocop:disable Rails/SkipsModelValidations
+        status: DiscoApp::Subscription.statuses[:cancelled],
+        cancelled_at: Time.zone.now
+      )
+    end
 
     # Get the amount that should be charged for the subscription.
-    subscription_amount = plan_code_instance.present? ? plan_code_instance.amount : plan.amount
+    def subscription_amount
+      plan_code_instance.present? ? plan_code_instance.amount : plan.amount
+    end
 
     # Get the date the subscription trial should end.
-    subscription_trial_period_days = plan_code_instance.present? ? plan_code_instance.trial_period_days : plan.trial_period_days
-
-    # Create the new subscription.
-    new_subscription = DiscoApp::Subscription.create!(
-      shop: shop,
-      plan: plan,
-      plan_code: plan_code_instance,
-      status: DiscoApp::Subscription.statuses[plan.has_trial? ? :trial : :active],
-      subscription_type: plan.plan_type,
-      amount: subscription_amount,
-      trial_period_days: plan.has_trial? ? subscription_trial_period_days : nil,
-      trial_start_at: plan.has_trial? ? Time.now : nil,
-      trial_end_at: plan.has_trial? ? subscription_trial_period_days.days.from_now : nil,
-      source: source_instance
-    )
-
-    # Enqueue the subscription changed background job.
-    DiscoApp::SubscriptionChangedJob.perform_later(shop, new_subscription)
+    def subscription_trial_period_days
+      plan_code_instance.present? ? plan_code_instance.trial_period_days : plan.trial_period_days
+    end
 
-    # Return the new subscription.
-    new_subscription
-  end
+    def create_new_subscription
+      DiscoApp::Subscription.create!(
+        shop: shop,
+        plan: plan,
+        plan_code: plan_code_instance,
+        status: DiscoApp::Subscription.statuses[plan.has_trial? ? :trial : :active],
+        subscription_type: plan.plan_type,
+        amount: subscription_amount,
+        trial_period_days: plan.has_trial? ? subscription_trial_period_days : nil,
+        trial_start_at: plan.has_trial? ? Time.zone.now : nil,
+        trial_end_at: plan.has_trial? ? subscription_trial_period_days.days.from_now : nil,
+        source: source_instance
+      )
+    end
 
 end

data/app/services/disco_app/webhook_service.rb

@@ -2,28 +2,26 @@ class DiscoApp::WebhookService
 
   # Return true iff the provided hmac_to_verify matches that calculated from the
   # given data and secret.
-  def self.is_valid_hmac?(body, secret, hmac_to_verify)
-    ActiveSupport::SecurityUtils.secure_compare(self.calculated_hmac(body, secret), hmac_to_verify.to_s)
+  def self.valid_hmac?(body, secret, hmac_to_verify)
+    ActiveSupport::SecurityUtils.secure_compare(calculated_hmac(body, secret), hmac_to_verify.to_s)
   end
 
   # Calculate the HMAC for the given data and secret.
   def self.calculated_hmac(body, secret)
-    digest  = OpenSSL::Digest.new('sha256')
+    digest = OpenSSL::Digest.new('sha256')
     Base64.encode64(OpenSSL::HMAC.digest(digest, secret, body)).strip
   end
 
   # Try to find a job class for the given webhook topic.
   def self.find_job_class(topic)
+    # First try to find a top-level matching job class.
+    "#{topic}_job".tr('/', '_').classify.constantize
+  rescue NameError
+    # If that fails, try to find a DiscoApp:: prefixed job class.
     begin
-      # First try to find a top-level matching job class.
-      "#{topic}_job".gsub('/', '_').classify.constantize
+      %(DiscoApp::#{"#{topic}_job".tr('/', '_').classify}).constantize
     rescue NameError
-      # If that fails, try to find a DiscoApp:: prefixed job class.
-      begin
-        %Q{DiscoApp::#{"#{topic}_job".gsub('/', '_').classify}}.constantize
-      rescue NameError
-        nil
-      end
+      nil
     end
   end
 

data/app/views/layouts/admin.html.erb

@@ -3,8 +3,7 @@
 <head>
   <title><%= yield(:title) %></title>
   <%= stylesheet_link_tag 'disco_app/admin', media: 'all', 'data-turbolinks-track' => true %>
-  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
-
+  <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
   <%= csrf_meta_tags %>
 </head>
 <body class="next-ui">

data/app/views/layouts/application.html.erb

@@ -4,7 +4,7 @@
   <title><%= yield(:title) %></title>
 
   <%= stylesheet_link_tag 'application', media: 'all', 'data-turbolinks-track' => true %>
-
+  <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
   <%= csrf_meta_tags %>
 
   <%= yield :extra_head %>
@@ -13,6 +13,5 @@
 
   <%= yield %>
 
-  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
 </body>
 </html>