kaui 2.1.0 → 2.2.1

data/app/models/kaui/application_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kaui
   class ApplicationRecord < ActiveRecord::Base
     self.abstract_class = true

data/app/models/kaui/audit_log.rb

@@ -1,7 +1,10 @@
-class Kaui::AuditLog
+# frozen_string_literal: true
+
+module Kaui
+  class AuditLog
+    def self.description(log)
+      return unless log.changed_by.present?
 
-  def self.description(log)
-    if log.changed_by.present?
       changed_str = "#{log.change_type} by #{log.changed_by.strip}"
       if log.reason_code.blank? && log.comments.blank?
         changed_str

data/app/models/kaui/base.rb

@@ -1,10 +1,16 @@
-class Kaui::Base
+# frozen_string_literal: true
 
-  def self.to_money(amount, currency)
-    begin
-      return Money.from_amount(amount.to_f, currency)
-    rescue => _
-    end if currency.present?
-    Money.from_amount(amount.to_f, 'USD')
+module Kaui
+  class Base
+    def self.to_money(amount, currency)
+      if currency.present?
+        begin
+          return Money.from_amount(amount.to_f, currency)
+        rescue StandardError => _e
+          # Pass through
+        end
+      end
+      Money.from_amount(amount.to_f, 'USD')
+    end
   end
 end

data/app/models/kaui/bundle.rb

@@ -1,34 +1,39 @@
-class Kaui::Bundle < KillBillClient::Model::Bundle
+# frozen_string_literal: true
+
+module Kaui
+  class Bundle < KillBillClient::Model::Bundle
+    def self.find_by_id_or_key(bundle_id_or_key, options = {})
+      if bundle_id_or_key =~ /[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}/
+        bundle = begin
+          find_by_id(bundle_id_or_key, options)
+        rescue StandardError
+          nil
+        end
+        return bundle unless bundle.nil?
+      end
 
-  def self.find_by_id_or_key(bundle_id_or_key, options = {})
-    if bundle_id_or_key =~ /[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}/
-      bundle = find_by_id(bundle_id_or_key, options) rescue nil
-      return bundle unless bundle.nil?
+      # Return the active one
+      find_by_external_key(bundle_id_or_key, false, options)
     end
 
-    # Return the active one
-    find_by_external_key(bundle_id_or_key, false, options)
-  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
 
-  private
+    def self.get_active_bundle_or_latest_created(bundles, time_zone = nil)
+      return nil if bundles.empty?
 
-  def self.get_active_bundle_or_latest_created(bundles, time_zone=nil)
-    return nil if bundles.empty?
+      latest_start_date = nil
+      latest_bundle     = nil
 
-    latest_start_date = nil
-    latest_bundle     = nil
+      bundles.each do |b|
+        b.subscriptions.each do |s|
+          next unless s.product_category != 'ADD_ON'
 
-    bundles.each do |b|
-      b.subscriptions.each do |s|
-        if s.product_category != 'ADD_ON'
           if latest_start_date.nil? || latest_start_date < s.start_date
             latest_start_date = s.start_date
             latest_bundle     = b
@@ -37,8 +42,20 @@ class Kaui::Bundle < KillBillClient::Model::Bundle
           return b if s.cancelled_date.nil? || s.cancelled_date > ActionController::Base.helpers.current_time(time_zone)
         end
       end
+
+      latest_bundle
     end
 
-    latest_bundle
+    def self.list_transfer_policy_params
+      @policy_params = [
+        [I18n.translate('start_of_term'), 'START_OF_TERM'],
+        [I18n.translate('end_of_term'), 'END_OF_TERM'],
+        [I18n.translate('immediate'), 'IMMEDIATE']
+      ]
+    end
+
+    def self.list_transfer_policy_params_keys
+      @policy_params = %w[START_OF_TERM END_OF_TERM IMMEDIATE]
+    end
   end
 end

data/app/models/kaui/catalog.rb

@@ -1,145 +1,150 @@
-require 'nokogiri'
-
-class Kaui::Catalog < KillBillClient::Model::Catalog
-
-  class << self
-
-    def get_account_catalog_json(account_id, requested_date = nil, options = {})
-      params = {}
-      params[:accountId] = account_id
-      params[:requestedDate] = requested_date if requested_date
+# frozen_string_literal: true
 
-      get KillBillClient::Model::Catalog::KILLBILL_API_CATALOG_PREFIX,
-          params,
-          {
-              :head => {'Accept' => "application/json"},
-              :content_type => "application/json",
+require 'nokogiri'
 
-          }.merge(options)
-    end
+module Kaui
+  class Catalog < KillBillClient::Model::Catalog
+    class << self
+      def get_account_catalog_json(account_id, requested_date = nil, options = {})
+        params = {}
+        params[:accountId] = account_id
+        params[:requestedDate] = requested_date if requested_date
+
+        get KillBillClient::Model::Catalog::KILLBILL_API_CATALOG_PREFIX,
+            params,
+            {
+              head: { 'Accept' => 'application/json' },
+              content_type: 'application/json'
+            }.merge(options)
+      end
 
-    def get_tenant_catalog_json(requested_date = nil, options = {})
-      super
-    rescue ::KillBillClient::API::InternalServerError => e
-      if !e.response.nil? && !e.response.body.nil?
-        error_message = JSON.parse(e.response.body) rescue nil
-        raise e if error_message.nil? || error_message['message'].nil?
+      def get_tenant_catalog_json(requested_date = nil, account_id = nil, options = {})
+        super
+      rescue ::KillBillClient::API::InternalServerError => e
+        if !e.response.nil? && !e.response.body.nil?
+          error_message = begin
+            JSON.parse(e.response.body)
+          rescue StandardError
+            nil
+          end
+          raise e if error_message.nil? || error_message['message'].nil?
 
-        # Hack for lack of proper Kill Bill messaging (see https://github.com/killbill/killbill-admin-ui/issues/265)
-        return [] if error_message['message'].starts_with?('No existing versions')
+          # Hack for lack of proper Kill Bill messaging (see https://github.com/killbill/killbill-admin-ui/issues/265)
+          return [] if error_message['message'].starts_with?('No existing versions')
+        end
+        raise e
       end
-      raise e
-    end
 
-    def get_catalog_json(latest, requested_date, options)
-      catalogs = get_tenant_catalog_json(requested_date, options)
-      return catalogs.length > 0 ? catalogs[catalogs.length - 1] : nil if latest
+      def get_catalog_json(latest, requested_date, options)
+        catalogs = get_tenant_catalog_json(requested_date, nil, options)
+        return catalogs.length.positive? ? catalogs[catalogs.length - 1] : nil if latest
 
-      # Order by latest
-      result = []
-      catalogs.sort! { |l, r| r.effective_date <=> l.effective_date }
+        # Order by latest
+        result = []
+        catalogs.sort! { |l, r| r.effective_date <=> l.effective_date }
 
-      catalogs.each_with_index do |current_catalog, idx|
-        result << {:version => idx,
-                   :version_date => current_catalog.effective_date,
-                   :currencies => current_catalog.currencies,
-                   :plans => build_existing_simple_plans(current_catalog)}
+        catalogs.each_with_index do |current_catalog, idx|
+          result << { version: idx,
+                      version_date: current_catalog.effective_date,
+                      currencies: current_catalog.currencies,
+                      plans: build_existing_simple_plans(current_catalog) }
+        end
+        result
       end
-      result
-    end
 
-    def build_ao_mapping(catalog)
-      tmp = {}
-      catalog.products.each do |p|
-        p.available.each do |ap|
-          if !tmp.has_key?(ap)
-            tmp[ap] = []
+      def build_ao_mapping(catalog)
+        tmp = {}
+        catalog&.products&.each do |p|
+          p.available.each do |ap|
+            tmp[ap] = [] unless tmp.key?(ap)
+            tmp[ap] << p.name
           end
-          tmp[ap] << p.name
         end
-      end unless catalog.nil?
-      tmp.map { |e,v| "#{e}:#{v.join(",")}" }.join(";")
-    end
-
-
-    def get_catalog_xml(requested_date, options)
+        tmp.map { |e, v| "#{e}:#{v.join(',')}" }.join(';')
+      end
 
-      catalog_xml = KillBillClient::Model::Catalog.get_tenant_catalog_xml(requested_date, options)
+      def get_catalog_xml(requested_date, options)
+        catalog_xml = KillBillClient::Model::Catalog.get_tenant_catalog_xml(requested_date, nil, options)
 
-      parsed_catalog = parse_catalog_xml(catalog_xml)
+        parsed_catalog = parse_catalog_xml(catalog_xml)
 
-      result = []
-      parsed_catalog.keys.each_with_index do |version_date, i|
-        entry = {}
-        entry[:version] = i
-        entry[:version_date] = version_date
-        entry[:xml] = parsed_catalog[version_date]
-        result << entry
+        result = []
+        parsed_catalog.keys.each_with_index do |version_date, i|
+          entry = {}
+          entry[:version] = i
+          entry[:version_date] = version_date
+          entry[:xml] = parsed_catalog[version_date]
+          result << entry
+        end
+        result
       end
-      result
-    end
-
-    private
 
-    def build_existing_simple_plans(catalog)
+      private
 
-      tmp = catalog.products.map do |p|
-        p.plans.each do |plan|
-          class << plan
-            attr_accessor :product_name
-            attr_accessor :product_category
+      def build_existing_simple_plans(catalog)
+        tmp = catalog.products.map do |p|
+          p.plans.each do |plan|
+            class << plan
+              attr_accessor :product_name, :product_category
+            end
+            plan.product_name = p.name
+            plan.product_category = p.type
           end
-          plan.product_name = p.name
-          plan.product_category = p.type
-        end
-      end.flatten!
+        end.flatten!
 
-      selected = tmp.select { |p| p.phases.length.to_i <= 2 && p.phases[p.phases.length - 1].type == "EVERGREEN" }
+        selected = tmp.select { |p| p.phases.length.to_i <= 2 }
 
-      currencies = catalog.currencies
+        currencies = catalog.currencies
 
-      result = []
-      selected.each do |plan|
-        has_trial = plan.phases[0].type == 'TRIAL'
+        result = []
+        selected.each do |plan|
+          has_trial = plan.phases[0].type == 'TRIAL'
 
-        simple_plan = KillBillClient::Model::SimplePlanAttributes.new
+          simple_plan = KillBillClient::Model::SimplePlanAttributes.new
 
-        # Embellish SimplePlanAttributes to contain a map currency -> amount (required in the view)
-        class << simple_plan
-          attr_accessor :prices
+          # Embellish SimplePlanAttributes to contain a map currency -> amount (required in the view)
+          class << simple_plan
+            attr_accessor :prices, :final_phase_duration
+          end
+          simple_plan.prices = plan.phases[-1].prices.each_with_object({}) do |e, r|
+            r[e.currency] = e.value
+          end
+
+          simple_plan.plan_id = plan.name
+          simple_plan.product_name = plan.product_name
+          simple_plan.product_category = plan.product_category
+          simple_plan.currency = currencies[0]
+          simple_plan.amount = simple_plan.prices[currencies[0]]
+          simple_plan.billing_period = plan.billing_period
+          simple_plan.trial_length = has_trial ? plan.phases[0].duration.number : 0
+          simple_plan.trial_time_unit = has_trial ? plan.phases[0].duration.unit : 'N/A'
+          last_phase_duration = plan.phases.last.duration
+          simple_plan.final_phase_duration = if last_phase_duration.number.positive?
+                                               "#{last_phase_duration.number} #{last_phase_duration.unit.downcase}"
+                                             else
+                                               last_phase_duration.unit
+                                             end
+
+          result << simple_plan
         end
-        simple_plan.prices = plan.phases[-1].prices.inject({}) { |r, e| r[e.currency] = e.value; r }
-
-        simple_plan.plan_id = plan.name
-        simple_plan.product_name = plan.product_name
-        simple_plan.product_category = plan.product_category
-        simple_plan.currency = currencies[0]
-        simple_plan.amount = simple_plan.prices[currencies[0]]
-        simple_plan.billing_period = plan.billing_period
-        simple_plan.trial_length = has_trial ? plan.phases[0].duration.number : 0
-        simple_plan.trial_time_unit = has_trial ? plan.phases[0].duration.unit : "N/A"
-
-        result << simple_plan
+        result
       end
-      result
-    end
-
-    def parse_catalog_xml(input_xml)
-      doc = Nokogiri::XML(input_xml) { |x| x.noblanks }
-      doc_versions = doc.xpath("//version")
 
-      doc_versions.inject({}) do |hsh, v|
+      def parse_catalog_xml(input_xml)
+        doc = Nokogiri::XML(input_xml, &:noblanks)
+        doc_versions = doc.xpath('//version')
 
-        # Replace node 'version' with 'catalog' and add the attributes
-        v.name = 'catalog'
-        v['xmlns:xsi'] = "http://www.w3.org/2001/XMLSchema-instance"
-        v['xsi:noNamespaceSchemaLocation'] = "CatalogSchema.xsd"
-        # Extract version
-        version = v.search("effectiveDate").text
+        doc_versions.each_with_object({}) do |v, hsh|
+          # Replace node 'version' with 'catalog' and add the attributes
+          v.name = 'catalog'
+          v['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
+          v['xsi:noNamespaceSchemaLocation'] = 'CatalogSchema.xsd'
+          # Extract version
+          version = v.search('effectiveDate').text
 
-        # Add entry
-        hsh[version] = '<?xml version="1.0" encoding="utf-8"?>' + v.to_xml(:indent => 4)
-        hsh
+          # Add entry
+          hsh[version] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>#{v.to_xml(indent: 4)}"
+        end
       end
     end
   end

data/app/models/kaui/chargeback.rb

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

data/app/models/kaui/credit.rb

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

data/app/models/kaui/custom_field.rb

@@ -1,10 +1,13 @@
-class Kaui::CustomField < KillBillClient::Model::CustomField
+# 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 CustomField < KillBillClient::Model::CustomField
+    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
 end

data/app/models/kaui/invoice.rb

@@ -1,32 +1,35 @@
-class Kaui::Invoice < KillBillClient::Model::Invoice
+# frozen_string_literal: true
 
-  def self.build_from_raw_invoice(raw_invoice)
-    result = Kaui::Invoice.new
-    KillBillClient::Model::InvoiceAttributes.instance_variable_get('@json_attributes').each do |attr|
-      result.send("#{attr}=", raw_invoice.send(attr))
+module Kaui
+  class Invoice < KillBillClient::Model::Invoice
+    def self.build_from_raw_invoice(raw_invoice)
+      result = Kaui::Invoice.new
+      KillBillClient::Model::InvoiceAttributes.instance_variable_get('@json_attributes').each do |attr|
+        result.send("#{attr}=", raw_invoice.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
 
-  [:amount, :balance, :credits].each do |type|
-    define_method "#{type}_to_money" do
-      Kaui::Base.to_money(send(type), currency)
+    %i[amount balance credits].each do |type|
+      define_method "#{type}_to_money" do
+        Kaui::Base.to_money(send(type), currency)
+      end
     end
-  end
 
-  def refund_adjustment_to_money
-    Kaui::Base.to_money(refund_adj, currency)
-  end
+    def refund_adjustment_to_money
+      Kaui::Base.to_money(refund_adj, currency)
+    end
 
-  def credit_adjustment_to_money
-    Kaui::Base.to_money(credit_adj, currency)
+    def credit_adjustment_to_money
+      Kaui::Base.to_money(credit_adj, currency)
+    end
   end
 end

data/app/models/kaui/invoice_item.rb

@@ -1,10 +1,13 @@
-class Kaui::InvoiceItem < KillBillClient::Model::InvoiceItem
+# frozen_string_literal: true
 
-  def amount_to_money
-    Kaui::Base.to_money(amount, currency)
-  end
+module Kaui
+  class InvoiceItem < KillBillClient::Model::InvoiceItem
+    def amount_to_money
+      Kaui::Base.to_money(amount, currency)
+    end
 
-  def self.amount_to_money(invoice_item)
-    self.new(:amount => invoice_item.amount, :currency => invoice_item.currency).amount_to_money
+    def self.amount_to_money(invoice_item)
+      new(amount: invoice_item.amount, currency: invoice_item.currency).amount_to_money
+    end
   end
 end

data/app/models/kaui/invoice_payment.rb

@@ -1,67 +1,62 @@
-class Kaui::InvoicePayment < KillBillClient::Model::InvoicePayment
-
-  include Kaui::PaymentState
-
-  class << self
-
-    def find_safely_by_id(id, options = {})
-      Kaui::InvoicePayment.find_by_id(id, true, true, options)
-    rescue => e
-      # Maybe the plugin is not registered or the plugin threw an exception
-      Rails.logger.warn(e)
-      Kaui::InvoicePayment.find_by_id(id, false, true, options)
-    end
-
-    def build_from_raw_payment(raw_payment)
+# frozen_string_literal: true
+
+module Kaui
+  class InvoicePayment < KillBillClient::Model::InvoicePayment
+    include Kaui::PaymentState
+
+    class << self
+      def find_safely_by_id(id, options = {})
+        Kaui::InvoicePayment.find_by_id(id, true, true, options)
+      rescue StandardError => e
+        # Maybe the plugin is not registered or the plugin threw an exception
+        Rails.logger.warn(e)
+        Kaui::InvoicePayment.find_by_id(id, false, true, options)
+      end
 
-      return nil if raw_payment.nil?
+      def build_from_raw_payment(raw_payment)
+        return nil if raw_payment.nil?
 
-      result = Kaui::InvoicePayment.new
-      KillBillClient::Model::InvoicePaymentAttributes.instance_variable_get('@json_attributes').each do |attr|
-        result.send("#{attr}=", raw_payment.send(attr))
-      end
-      # Use  Kaui::Transaction to benefit from additional fields (e.g next_retry_date)
-      original_transactions = (result.transactions || [])
-      result.transactions = []
-      original_transactions.each do |transaction|
-        new_transaction = Kaui::Transaction.new
-        KillBillClient::Model::PaymentTransactionAttributes.instance_variable_get('@json_attributes').each do |attr|
-          new_transaction.send("#{attr}=", transaction.send(attr))
+        result = Kaui::InvoicePayment.new
+        KillBillClient::Model::InvoicePaymentAttributes.instance_variable_get('@json_attributes').each do |attr|
+          result.send("#{attr}=", raw_payment.send(attr))
         end
-        result.transactions << new_transaction
+        # Use  Kaui::Transaction to benefit from additional fields (e.g next_retry_date)
+        original_transactions = (result.transactions || [])
+        result.transactions = []
+        original_transactions.each do |transaction|
+          new_transaction = Kaui::Transaction.new
+          KillBillClient::Model::PaymentTransactionAttributes.instance_variable_get('@json_attributes').each do |attr|
+            new_transaction.send("#{attr}=", transaction.send(attr))
+          end
+          result.transactions << new_transaction
+        end
+        result.build_transactions_next_retry_date!
+        result
       end
-      result.build_transactions_next_retry_date!
-      result
-    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)
     end
-  end
-
-  # For each payment transaction, compute next_retry date by joining with payment attempts
-  def build_transactions_next_retry_date!
 
-    # Filter scheduled attempts: We could have several in parallel when multiple independent transactions occur at the same time
-    # (They would have different transaction_external_key)
-    scheduled_attempts = (payment_attempts || []).select do |a|
-      a.state_name == 'SCHEDULED'
+    %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
 
-    # Look for latest transaction associated with each such scheduled attempt and set retry date accordingly
-    scheduled_attempts.each do |a|
+    # For each payment transaction, compute next_retry date by joining with payment attempts
+    def build_transactions_next_retry_date!
+      # Filter scheduled attempts: We could have several in parallel when multiple independent transactions occur at the same time
+      # (They would have different transaction_external_key)
+      scheduled_attempts = (payment_attempts || []).select do |a|
+        a.state_name == 'SCHEDULED'
+      end
 
-      last_transaction_for_attempt = (transactions || []).select do |t|
-        t.transaction_external_key == a.transaction_external_key
-      end.sort_by do |t|
-        t.effective_date
-      end.last
+      # Look for latest transaction associated with each such scheduled attempt and set retry date accordingly
+      scheduled_attempts.each do |a|
+        last_transaction_for_attempt = (transactions || []).select do |t|
+          t.transaction_external_key == a.transaction_external_key
+        end.max_by(&:effective_date)
 
-      last_transaction_for_attempt.next_retry_date = a.effective_date if last_transaction_for_attempt
+        last_transaction_for_attempt.next_retry_date = a.effective_date if last_transaction_for_attempt
+      end
     end
-
   end
 end