disco_app 0.12.7.pre.puma.pre.3 → 0.18.4

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,56 +15,54 @@ 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
 
     def email
-      @model.data['email']
+      @model.data[:email]
     end
 
     def country_name
-      @model.data['country_name']
+      @model.data[:country_name]
     end
 
     def currency
-      @model.data['currency']
+      @model.data[:currency]
     end
 
     def plan_display_name
-      @model.data['plan_display_name']
+      @model.data[:plan_display_name]
     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.
@@ -34,48 +32,40 @@ class DiscoApp::ChargesService
     charge
   end
 
-  # Attempt to activate the given Shopify charge for the given Shop using the
-  # Shopify API. Returns true on successful activation, false otherwise.
+  # Synchronises the status of a given charge from the Shopify API and returns
+  # true if it's active (and false otherwise).
+  #
+  # Previously, the activation of a charge also required updating Shopify via the
+  # API, but that requirement has been removed.
+  #
+  # See https://shopify.dev/changelog/auto-activation-of-charges-and-subscriptions
   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)
-      }
-
-      # 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?
+    # 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
 
-      # If the charge was indeed accepted, activate it via Shopify.
-      charge.shop.with_api_context {
-        shopify_charge.activate
-      }
+    # 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 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 isn't active, fail and return.
+    return false unless charge.active?
 
-      charge.active!
+    # If the charge was recurring, make sure that all other local recurring
+    # charges are marked inactive.
+    cancel_recurring_charges(shop, charge) if charge.recurring?
 
-      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

@@ -0,0 +1,151 @@
+module DiscoApp
+  class PartnerAppService
+
+    def initialize(params)
+      @email = params[:email]
+      @password = params[:password]
+      @app_name = params[:app_name]
+      @app_url = params[:app_url]
+      @organization = params[:organization]
+
+      @agent = Mechanize.new do |a|
+        a.user_agent_alias = 'Mac Safari'
+        a.follow_meta_refresh = true
+        a.keep_alive = false
+        a.pre_connect_hooks << lambda do |_agent, request|
+          request['Accept'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
+        end
+      end
+    end
+
+    def generate_partner_app
+      begin
+        # Login to Shopify Partners
+        login
+        # Access Partner dashboard
+        org_link = organizations
+        dashboard = dashboard_page(org_link)
+        # Create App
+        apps_page = refresh_page(dashboard)
+        create_partner_app(apps_page)
+        # Configure newly created app with embedded app use
+        apps_page = refresh_page(dashboard)
+        embedded_admin_app(apps_page)
+        # Add Disco App icon
+        apps_page = refresh_page(dashboard)
+        add_disco_icon(apps_page)
+        # Fetch API credentials
+        apps_page = refresh_page(dashboard)
+        api_key, secret = api_credentials(apps_page)
+      rescue Mechanize::Error => e
+        puts 'Error while trying to create partner app'
+        puts "Error #{e}, message : #{e.message}"
+        return
+      end
+      # Add them to .env.local file
+      append_credentials(api_key, secret)
+      puts '#' * 80
+      puts 'New Partner App successfully created!'
+      puts 'API Credentials have been pasted to your .env.local file'
+      puts '#' * 80
+    end
+
+    private
+
+      def login
+        @agent.get('https://accounts.shopify.com/login') do |page|
+          page.form do |form|
+            form['account[email]'] = @email
+            form['account[password]'] = @password
+          end.submit
+        end
+      end
+
+      def organizations
+        organizations = @agent.get('https://partners.shopify.com/organizations/')
+        organizations.links.select { |link| link.text[/#{@organization}/] }.first.href
+      end
+
+      def dashboard_page(org_link)
+        @agent.get('https://partners.shopify.com' + org_link)
+      end
+
+      def create_partner_app(apps_page)
+        apps_page.form do |form|
+          # App name
+          form['create_form[title]'] = @app_name
+
+          # App URL
+          form['create_form[application_url]'] = @app_url
+
+          # Accept TOS
+          if form['create_form[accepted]'].present?
+            form['create_form[accepted]'] = '1'
+            form.hiddens.last.value = 1
+          end
+        end.submit
+      end
+
+      def api_credentials(apps_page)
+        app = apps_page.link_with(text: @app_name).click
+        app_info = app.link_with(text: 'App info').click
+        add_whitelist_url(app_info)
+        api_key = app_info.search('#api_key').first.values[3]
+        secret = app_info.search('#settings_form_secrets').first.values[3]
+        [api_key, secret]
+      end
+
+      def embedded_admin_app(apps_page)
+        app = apps_page.link_with(text: @app_name).click
+        extensions = app.link_with(text: 'Extensions').click
+        extensions.form do |form|
+          form['extensions_form[embedded]'] = '1'
+        end.submit
+      end
+
+      def add_disco_icon(apps_page)
+        app = apps_page.link_with(text: @app_name).click
+        app_info = app.link_with(text: 'App info').click
+        logo = DiscoApp::Engine.root.join('app', 'assets', 'images', 'disco_app', 'logo.png').to_s
+        app_info.form do |form|
+          form.file_uploads.first.file_name = logo
+        end.submit
+      end
+
+      # Write credentials of newly created app to .env.local file
+      def append_credentials(api_key, secret)
+        original_file = '.env.local'
+        new_file = original_file + '.new'
+        File.open(new_file, 'w') do |file|
+          File.foreach(original_file) do |line|
+            if line.include?('SHOPIFY_APP_API_KEY')
+              file.puts "SHOPIFY_APP_API_KEY=#{api_key}"
+            elsif line.include?('SHOPIFY_APP_SECRET')
+              file.puts "SHOPIFY_APP_SECRET=#{secret}"
+            else
+              file.puts line
+            end
+          end
+        end
+        File.delete(original_file)
+        File.rename(new_file, original_file)
+      end
+
+      def add_whitelist_url(app_info)
+        app_info.form do |form|
+          form['info_form[redirect_url_whitelist]'] = callback_url
+        end.submit
+      end
+
+      # Access the "Apps" section of the dashboard, also used to reload the dashboard
+      # When an action has been taken
+      def refresh_page(dashboard)
+        dashboard.link_with(text: '  Apps').click
+      end
+
+      def callback_url
+        [@app_url + '/auth/shopify/callback', @app_url + '/auth/shopify_user/callback'].join("\n")
+      end
+
+  end
+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.variable_size_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.variable_size_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