kaui 2.0.4 → 2.2.1

data/app/models/kaui/killbill_authenticatable.rb

@@ -1,33 +1,39 @@
+# frozen_string_literal: true
+
 require 'killbill_client'
 
+# Hack for Zeitwerk
+module Kaui
+  module KillbillAuthenticatable; end
+end
+
 module Devise
   module Models
     module KillbillAuthenticatable
       extend ActiveSupport::Concern
 
-      def valid_killbill_password?(kb_username, kb_password)
+      def valid_killbill_password?(creds)
         # Simply try to look-up the permissions for that user - this will
         # Take care of the auth part
-        response = Kaui::User.find_permissions(kb_username, kb_password)
+        response = Kaui::User.find_permissions(creds)
         # Auth was successful, update the session id
         self.kb_session_id = response.session_id
         true
-      rescue KillBillClient::API::Unauthorized => _
+      rescue KillBillClient::API::Unauthorized => _e
         false
       end
 
       def after_killbill_authentication
-        self.save(:validate => false)
+        save(validate: false)
       end
 
       module ClassMethods
-
         # Invoked by the KillbillAuthenticatable strategy to lookup the user
         # before attempting authentication
         def find_for_killbill_authentication(kb_username)
-          find_for_authentication(:kb_username => kb_username) ||
-          new(:kb_username => kb_username)
-        rescue KillBillClient::API::Unauthorized => _
+          find_for_authentication(kb_username: kb_username) ||
+            new(kb_username: kb_username)
+        rescue KillBillClient::API::Unauthorized => _e
           # Multi-Tenancy was enabled, but the tenant_id couldn't be retrieved because of bad credentials
           nil
         end

data/app/models/kaui/killbill_registerable.rb

@@ -1,3 +1,10 @@
+# frozen_string_literal: true
+
+# Hack for Zeitwerk
+module Kaui
+  module KillbillRegisterable; end
+end
+
 module Devise
   module Models
     module KillbillRegisterable

data/app/models/kaui/overdue.rb

@@ -1,89 +1,88 @@
-class Kaui::Overdue < KillBillClient::Model::Overdue
+# frozen_string_literal: true
 
-  class << self
-
-
-    def from_overdue_form_model(view_form_model)
-      result = KillBillClient::Model::Overdue.new
-      result.initial_reevaluation_interval = nil # TODO
-      result.overdue_states = []
-      view_form_model["states"].each do |state_model|
-
-        state = KillBillClient::Model::OverdueStateConfig.new
-        state.name = state_model["name"]
-        state.auto_reevaluation_interval_days = nil
-        state.external_message = state_model["external_message"]
-        state.is_clear_state = state_model["is_clear_state"].nil? ? false : state_model["is_clear_state"]
-        state.is_block_changes = state_model["is_block_changes"]
-        if state_model["subscription_cancellation_policy"] == :NONE.to_s
-          state.is_disable_entitlement = false
-          state.subscription_cancellation_policy = nil
-        else
-          state.is_disable_entitlement = true
-          state.subscription_cancellation_policy = state_model["subscription_cancellation_policy"].blank? ? :NONE : state_model["subscription_cancellation_policy"].to_s.gsub!(/POLICY_/, '')
-        end
+module Kaui
+  class Overdue < KillBillClient::Model::Overdue
+    class << self
+      def from_overdue_form_model(view_form_model)
+        result = KillBillClient::Model::Overdue.new
+        result.initial_reevaluation_interval = nil # TODO
+        result.overdue_states = []
+        view_form_model['states'].each do |state_model|
+          state = KillBillClient::Model::OverdueStateConfig.new
+          state.name = state_model['name']
+          state.auto_reevaluation_interval_days = nil
+          state.external_message = state_model['external_message']
+          state.is_clear_state = state_model['is_clear_state'].nil? ? false : state_model['is_clear_state']
+          state.is_block_changes = state_model['is_block_changes']
+          if state_model['subscription_cancellation_policy'] == :NONE.to_s
+            state.is_disable_entitlement = false
+            state.subscription_cancellation_policy = nil
+          else
+            state.is_disable_entitlement = true
+            state.subscription_cancellation_policy = state_model['subscription_cancellation_policy'].blank? ? :NONE : state_model['subscription_cancellation_policy'].to_s.gsub!(/POLICY_/, '')
+          end
 
-        if state_model["condition"]
-          state.condition = KillBillClient::Model::OverdueCondition.new
-          if state_model["condition"]["time_since_earliest_unpaid_invoice_equals_or_exceeds"]
-            state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds = KillBillClient::Model::DurationAttributes.new
-            state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds.unit = "DAYS"
-            state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds.number = state_model["condition"]["time_since_earliest_unpaid_invoice_equals_or_exceeds"]
+          if state_model['condition']
+            state.condition = KillBillClient::Model::OverdueCondition.new
+            if state_model['condition']['time_since_earliest_unpaid_invoice_equals_or_exceeds']
+              state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds = KillBillClient::Model::DurationAttributes.new
+              state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds.unit = 'DAYS'
+              state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds.number = state_model['condition']['time_since_earliest_unpaid_invoice_equals_or_exceeds']
+            end
+            state.condition.number_of_unpaid_invoices_equals_or_exceeds = state_model['condition']['number_of_unpaid_invoices_equals_or_exceeds']
+            state.condition.total_unpaid_invoice_balance_equals_or_exceeds = state_model['condition']['total_unpaid_invoice_balance_equals_or_exceeds']
+            state.condition.control_tag_inclusion = format_tag_condition(state_model['condition']['control_tag_inclusion'])
+            state.condition.control_tag_exclusion = format_tag_condition(state_model['condition']['control_tag_exclusion'])
           end
-          state.condition.number_of_unpaid_invoices_equals_or_exceeds = state_model["condition"]["number_of_unpaid_invoices_equals_or_exceeds"]
-          state.condition.total_unpaid_invoice_balance_equals_or_exceeds = state_model["condition"]["total_unpaid_invoice_balance_equals_or_exceeds"]
-          state.condition.control_tag_inclusion = format_tag_condition(state_model["condition"]["control_tag_inclusion"])
-          state.condition.control_tag_exclusion = format_tag_condition(state_model["condition"]["control_tag_exclusion"])
+
+          result.overdue_states << state
         end
+        # We reversed them to display on the form , so we have to reverse them back before uploading new config
+        result.overdue_states.reverse!
 
-        result.overdue_states << state
+        result
       end
-      # We reversed them to display on the form , so we have to reverse them back before uploading new config
-      result.overdue_states.reverse!
 
-      result
-    end
-
-    def get_overdue_json(options)
-      result = KillBillClient::Model::Overdue.get_tenant_overdue_config_json(options)
-      class << result
-        attr_accessor :has_states
+      def get_tenant_overdue_config(options)
+        overdue_xml = KillBillClient::Model::Overdue.get_tenant_overdue_config_xml(options)
+        Nokogiri::XML(overdue_xml, &:noblanks)
       end
-      result.has_states = result.overdue_states.size > 0 && result.overdue_states[0].is_clear_state
 
-      result.overdue_states.each do |state|
-        class << state
-          attr_accessor :subscription_cancellation
-        end
-        if state.is_disable_entitlement
-          state.subscription_cancellation = state.subscription_cancellation_policy ? "POLICY_#{state.subscription_cancellation_policy}".to_sym : :NONE
-        else
-          state.subscription_cancellation = :NONE
+      def get_overdue_json(options)
+        result = KillBillClient::Model::Overdue.get_tenant_overdue_config_json(options)
+        class << result
+          attr_accessor :has_states
         end
-        if state.condition.nil?
+        result.has_states = result.overdue_states.size.positive? && result.overdue_states[0].is_clear_state
+
+        result.overdue_states.each do |state|
+          class << state
+            attr_accessor :subscription_cancellation
+          end
+          state.subscription_cancellation = if state.is_disable_entitlement
+                                              state.subscription_cancellation_policy ? "POLICY_#{state.subscription_cancellation_policy}".to_sym : :NONE
+                                            else
+                                              :NONE
+                                            end
+          next unless state.condition.nil?
+
           state.condition = KillBillClient::Model::OverdueCondition.new
           state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds = KillBillClient::Model::DurationAttributes.new
-          state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds.unit = "DAYS"
+          state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds.unit = 'DAYS'
           state.condition.time_since_earliest_unpaid_invoice_equals_or_exceeds.number = 0
           state.condition.number_of_unpaid_invoices_equals_or_exceeds = 0
           state.condition.total_unpaid_invoice_balance_equals_or_exceeds = 0
           state.condition.control_tag_inclusion = :NONE
           state.condition.control_tag_exclusion = :NONE
         end
+        result
       end
-      result
-    end
 
-    def format_tag_condition(control_tag)
-      if control_tag.blank? || control_tag == :NONE.to_s
-        return nil
-      else
-        return control_tag
+      def format_tag_condition(control_tag)
+        return nil if control_tag.blank? || control_tag == :NONE.to_s
+
+        control_tag
       end
     end
-
-
   end
-
 end
-

data/app/models/kaui/payment.rb

@@ -1,30 +1,33 @@
-class Kaui::Payment < KillBillClient::Model::Payment
+# frozen_string_literal: true
 
-  include Kaui::PaymentState
+module Kaui
+  class Payment < KillBillClient::Model::Payment
+    include Kaui::PaymentState
 
-  attr_accessor :payment_date, :target_invoice_id
+    attr_accessor :payment_date, :target_invoice_id
 
-  TRANSACTION_STATUSES = %w(SUCCESS PENDING PAYMENT_FAILURE PLUGIN_FAILURE UNKNOWN)
+    TRANSACTION_STATUSES = %w[SUCCESS PENDING PAYMENT_FAILURE PLUGIN_FAILURE UNKNOWN].freeze
 
-  def self.build_from_raw_payment(raw_payment)
-    result = Kaui::Payment.new
-    KillBillClient::Model::PaymentAttributes.instance_variable_get('@json_attributes').each do |attr|
-      result.send("#{attr}=", raw_payment.send(attr))
+    def self.build_from_raw_payment(raw_payment)
+      result = Kaui::Payment.new
+      KillBillClient::Model::PaymentAttributes.instance_variable_get('@json_attributes').each do |attr|
+        result.send("#{attr}=", raw_payment.send(attr))
+      end
+      result
     end
-    result
-  end
 
-  def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
-    if search_key.present?
-      find_in_batches_by_search_key(search_key, offset, limit, options)
-    else
-      find_in_batches(offset, limit, options)
+    def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
+      if search_key.present?
+        find_in_batches_by_search_key(search_key, offset, limit, options)
+      else
+        find_in_batches(offset, limit, options)
+      end
     end
-  end
 
-  [:auth, :captured, :purchased, :refunded, :credited].each do |type|
-    define_method "#{type}_amount_to_money" do
-      Kaui::Base.to_money(send("#{type}_amount"), currency)
+    %i[auth captured purchased refunded credited].each do |type|
+      define_method "#{type}_amount_to_money" do
+        Kaui::Base.to_money(send("#{type}_amount"), currency)
+      end
     end
   end
 end

data/app/models/kaui/payment_method.rb

@@ -1,58 +1,67 @@
-class Kaui::PaymentMethod < KillBillClient::Model::PaymentMethod
+# frozen_string_literal: true
 
-  def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
-    if search_key.present?
-      find_in_batches_by_search_key(search_key, offset, limit, options)
-    else
-      find_in_batches(offset, limit, options)
+module Kaui
+  class PaymentMethod < KillBillClient::Model::PaymentMethod
+    def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
+      if search_key.present?
+        find_in_batches_by_search_key(search_key, offset, limit, options)
+      else
+        find_in_batches(offset, limit, options)
+      end
     end
-  end
 
-  def self.find_safely_by_id(id, options = {})
-    Kaui::PaymentMethod.find_by_id(id, true, options)
-  rescue => e
-    # Maybe the plugin is not registered or the plugin threw an exception
-    Rails.logger.warn(e)
-    Kaui::PaymentMethod.find_by_id(id, false, options) rescue nil # deleted pm?
-  end
+    def self.find_safely_by_id(id, options = {})
+      Kaui::PaymentMethod.find_by_id(id, true, options)
+    rescue StandardError => e
+      # Maybe the plugin is not registered or the plugin threw an exception
+      Rails.logger.warn(e)
+      begin
+        Kaui::PaymentMethod.find_by_id(id, false, options)
+      rescue StandardError
+        nil
+      end
+    end
 
-  def self.find_all_safely_by_account_id(account_id, options = {})
-    pms = Kaui::PaymentMethod.find_all_by_account_id(account_id, false, options)
+    def self.find_all_safely_by_account_id(account_id, options = {})
+      pms = Kaui::PaymentMethod.find_all_by_account_id(account_id, false, options)
 
-    pms.each_with_index do |pm, i|
-      begin
+      pms.each_with_index do |pm, i|
         pms[i] = Kaui::PaymentMethod.find_by_id(pm.payment_method_id, true, options)
-      rescue => e
+      rescue StandardError => e
         # Maybe the plugin is not registered or the plugin threw an exception
         Rails.logger.warn(e)
       end
+      pms
     end
-    pms
-  end
 
-  def self.find_non_external_by_account_id(account_id, with_plugin_info = false, options = {})
-    payment_methods = find_all_by_account_id(account_id, with_plugin_info, options)
-    payment_methods.reject { |x| x.plugin_name == '__EXTERNAL_PAYMENT__' }
-  end
+    def self.find_non_external_by_account_id(account_id, with_plugin_info, options = {})
+      payment_methods = find_all_by_account_id(account_id, with_plugin_info, options)
+      payment_methods.reject { |x| x.plugin_name == '__EXTERNAL_PAYMENT__' }
+    end
 
-  def self.payment_methods_for_payments(payments = [], options = {})
-    payment_method_per_payment = {}
-    payment_methods_cache      = {}
-    deleted_payment_methods    = Set.new
+    def self.payment_methods_for_payments(payments = [], options = {})
+      payment_method_per_payment = {}
+      payment_methods_cache      = {}
+      deleted_payment_methods    = Set.new
 
-    payments.each do |payment|
-      next if deleted_payment_methods.include?(payment.payment_method_id)
+      payments.each do |payment|
+        next if deleted_payment_methods.include?(payment.payment_method_id)
 
-      # The payment method may have been deleted
-      payment_methods_cache[payment.payment_method_id] ||= Kaui::PaymentMethod.find_by_id(payment.payment_method_id, true, options) rescue nil
+        # The payment method may have been deleted
+        payment_methods_cache[payment.payment_method_id] ||= begin
+          Kaui::PaymentMethod.find_by_id(payment.payment_method_id, true, options)
+        rescue StandardError
+          nil
+        end
 
-      if payment_methods_cache[payment.payment_method_id].nil?
-        deleted_payment_methods.add(payment.payment_method_id)
-      else
-        payment_method_per_payment[payment.payment_id] = payment_methods_cache[payment.payment_method_id]
+        if payment_methods_cache[payment.payment_method_id].nil?
+          deleted_payment_methods.add(payment.payment_method_id)
+        else
+          payment_method_per_payment[payment.payment_id] = payment_methods_cache[payment.payment_method_id]
+        end
       end
-    end
 
-    payment_method_per_payment
+      payment_method_per_payment
+    end
   end
 end

data/app/models/kaui/payment_state.rb

@@ -1,56 +1,59 @@
-module Kaui::PaymentState
+# frozen_string_literal: true
 
-  def refundable?
-    transactions.each do |transaction|
-      return true if transaction.status == 'SUCCESS' && %w(CAPTURE PURCHASE).include?(transaction.transaction_type)
+module Kaui
+  module PaymentState
+    def refundable?
+      transactions.each do |transaction|
+        return true if transaction.status == 'SUCCESS' && %w[CAPTURE PURCHASE].include?(transaction.transaction_type)
+      end
+      false
     end
-    false
-  end
 
-  def amount_refundable
-    captured_amount + purchased_amount - refunded_amount
-  end
+    def amount_refundable
+      captured_amount + purchased_amount - refunded_amount
+    end
 
-  def amount_capturable
-    auth_amount - captured_amount
-  end
+    def amount_capturable
+      auth_amount - captured_amount
+    end
 
-  def capturable?
-    maybe = false
-    transactions.each do |transaction|
-      if transaction.status == 'SUCCESS'
+    def capturable?
+      maybe = false
+      transactions.each do |transaction|
+        next unless transaction.status == 'SUCCESS'
         return false if transaction.transaction_type == 'VOID'
+
         maybe = true if transaction.transaction_type == 'AUTHORIZE'
       end
+      maybe && refunded_amount.zero?
     end
-    maybe && refunded_amount == 0
-  end
 
-  def voidable?
-    transactions.each do |transaction|
-      return false if transaction.status == 'SUCCESS' && transaction.transaction_type == 'VOID'
+    def voidable?
+      transactions.each do |transaction|
+        return false if transaction.status == 'SUCCESS' && transaction.transaction_type == 'VOID'
+      end
+      capturable? && captured_amount.zero?
     end
-    capturable? && captured_amount == 0
-  end
 
-  def chargebackable?
-    refundable?
-  end
+    def chargebackable?
+      refundable?
+    end
 
-  def total_authed_amount_to_money
-    auth_amount_to_money + purchased_amount_to_money
-  end
+    def total_authed_amount_to_money
+      auth_amount_to_money + purchased_amount_to_money
+    end
 
-  def paid_amount_to_money
-    captured_amount_to_money + purchased_amount_to_money
-  end
+    def paid_amount_to_money
+      captured_amount_to_money + purchased_amount_to_money
+    end
 
-  # TODO Better name?
-  def returned_amount_to_money
-    refunded_amount_to_money + credited_amount_to_money
-  end
+    # TODO: Better name?
+    def returned_amount_to_money
+      refunded_amount_to_money + credited_amount_to_money
+    end
 
-  def is_fully_refunded?
-    refunded_amount == captured_amount || refunded_amount == purchased_amount
+    def fully_refunded?
+      refunded_amount == captured_amount || refunded_amount == purchased_amount
+    end
   end
 end

data/app/models/kaui/rails_methods.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Kaui
   module RailsMethods
-
     def self.included(base_class)
       base_class.class_eval do
         # Required to build urls in views
@@ -10,7 +11,7 @@ module Kaui
         include ActiveModel::Conversion
 
         def ==(other)
-          !other.nil? && self.class == other.class && self.to_hash == other.to_hash
+          !other.nil? && self.class == other.class && to_hash == other.to_hash
         end
 
         def persisted?
@@ -36,7 +37,7 @@ module Kaui
           false
         end
 
-        def update_attributes(tag_definition)
+        def update_attributes(_tag_definition)
           @errors.add(:update, 'Updating this object is not yet supported')
           false
         end
@@ -45,11 +46,10 @@ module Kaui
           @errors.add(:destroy, 'Destroying this object is not yet supported')
           false
         end
-
-      end # end instance methods
+      end
 
       base_class.instance_eval do
-        def self.human_attribute_name(attr, options = {})
+        def self.human_attribute_name(attr, _options = {})
           attr
         end
 
@@ -65,10 +65,10 @@ module Kaui
           all.count
         end
 
-        def self.find(id)
+        def self.find(_id)
           nil
         end
-      end # end class methods
-    end # end def included
+      end
+    end
   end
 end

data/app/models/kaui/refund.rb

@@ -1,2 +1,8 @@
-class Kaui::Refund
+# frozen_string_literal: true
+
+module Kaui
+  # rubocop:disable Lint/EmptyClass
+  class Refund
+  end
+  # rubocop:enable Lint/EmptyClass
 end

data/app/models/kaui/role_definition.rb

@@ -1,2 +1,6 @@
-class Kaui::RoleDefinition < KillBillClient::Model::RoleDefinition
+# frozen_string_literal: true
+
+module Kaui
+  class RoleDefinition < KillBillClient::Model::RoleDefinition
+  end
 end

data/app/models/kaui/simple_plan.rb

@@ -1,4 +1,6 @@
-class Kaui::SimplePlan < KillBillClient::Model::SimplePlanAttributes
-end
-
+# frozen_string_literal: true
 
+module Kaui
+  class SimplePlan < KillBillClient::Model::SimplePlanAttributes
+  end
+end

data/app/models/kaui/subscription.rb

@@ -1,10 +1,13 @@
-class Kaui::Subscription < KillBillClient::Model::Subscription
+# frozen_string_literal: true
 
-  def cancel_entitlement_immediately(user = nil, reason = nil, comment = nil, options = {})
-    requested_date                 = nil
-    entitlement_policy             = 'IMMEDIATE'
-    billing_policy                 = nil
-    use_requested_date_for_billing = true
-    cancel(user, reason, comment, requested_date, entitlement_policy, billing_policy, use_requested_date_for_billing, options)
+module Kaui
+  class Subscription < KillBillClient::Model::Subscription
+    def cancel_entitlement_immediately(user = nil, reason = nil, comment = nil, options = {})
+      requested_date                 = nil
+      entitlement_policy             = 'IMMEDIATE'
+      billing_policy                 = nil
+      use_requested_date_for_billing = true
+      cancel(user, reason, comment, requested_date, entitlement_policy, billing_policy, use_requested_date_for_billing, options)
+    end
   end
 end

data/app/models/kaui/tag.rb

@@ -1,32 +1,35 @@
-class Kaui::Tag < KillBillClient::Model::Tag
+# frozen_string_literal: true
 
-  def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
-    if search_key.present?
-      find_in_batches_by_search_key(search_key, offset, limit, options)
-    else
-      find_in_batches(offset, limit, options)
+module Kaui
+  class Tag < KillBillClient::Model::Tag
+    def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
+      if search_key.present?
+        find_in_batches_by_search_key(search_key, offset, limit, options)
+      else
+        find_in_batches(offset, limit, options)
+      end
     end
-  end
 
-  class << self
-    [:account, :bundle, :subscription].each do |model|
-      define_method "all_for_#{model.to_s}" do |model_id, included_deleted, audit, options|
-        instance = Kaui.const_get(model.to_s.camelize).new("#{model.to_s}_id".to_sym => model_id)
-        instance.tags(included_deleted, audit, options)
-      end
+    class << self
+      %i[account bundle subscription invoice].each do |model|
+        define_method "all_for_#{model}" do |model_id, included_deleted, audit, options|
+          instance = Kaui.const_get(model.to_s.camelize).new("#{model}_id".to_sym => model_id)
+          instance.tags(included_deleted, audit, options)
+        end
 
-      define_method "set_for_#{model.to_s}" do |model_id, tags, user, reason, comment, options|
-        instance = Kaui.const_get(model.to_s.camelize).new("#{model.to_s}_id".to_sym => model_id)
-        instance.set_tags(tags, user, reason, comment, options)
+        define_method "set_for_#{model}" do |model_id, tags, user, reason, comment, options|
+          instance = Kaui.const_get(model.to_s.camelize).new("#{model}_id".to_sym => model_id)
+          instance.set_tags(tags, user, reason, comment, options)
+        end
       end
     end
-  end
 
-  def is_system_tag?
-    Kaui::TagDefinition(:id => tag_definition_id).is_system_tag?
-  end
+    def system_tag?
+      Kaui::TagDefinition(id: tag_definition_id).system_tag?
+    end
 
-  def <=>(tag)
-    tag_definition_name.downcase <=> tag.tag_definition_name.downcase
+    def <=>(other)
+      tag_definition_name.downcase <=> other.tag_definition_name.downcase
+    end
   end
 end