feat(payment_terms): Dual-write to alias and jsonb

Author: D1353L

app/models/payment_term.rb

@@ -17,6 +17,15 @@ def self.from_h(hash)
     )
   end
 
+  # Backward compatibility for the legacy net_payment_term_field
+  def self.from_net_payment_term(days)
+    if days.nil?
+      nil
+    else
+      new(term_type: "net", days:)
+    end
+  end
+
   def initialize(term_type:, days: nil, day_of_month: nil, month_offset: nil)
     @term_type = term_type.to_s
     @days = days&.to_i

app/services/billing_entities/create_service.rb

@@ -26,6 +26,8 @@ def call
         billing_entity.document_locale = billing_config[:document_locale] if billing_config[:document_locale]
         billing_entity.einvoicing = params[:einvoicing] if params[:einvoicing]
 
+        PaymentTerms::AssignAliasService.call(record: billing_entity, params:)
+
         handle_eu_tax_management if params[:eu_tax_management]
         handle_base64_logo
 

app/services/billing_entities/update_service.rb

@@ -69,6 +69,8 @@ def call
           )
         end
 
+        PaymentTerms::AssignAliasService.call(record: billing_entity, params:)
+
         if params.key?(:tax_codes)
           BillingEntities::Taxes::ManageTaxesService.call!(billing_entity:, tax_codes: params[:tax_codes])
         end

app/services/customers/create_service.rb

@@ -70,6 +70,8 @@ def call
         customer_type: args[:customer_type]
       )
 
+      PaymentTerms::AssignAliasService.call(record: customer, params: args)
+
       if customer&.organization&.revenue_share_enabled?
         customer.account_type = args[:account_type] if args.key?(:account_type)
         customer.exclude_from_dunning_campaign = customer.partner_account?

app/services/customers/update_service.rb

@@ -91,6 +91,8 @@ def call
 
       Customers::UpdateInvoiceIssuingDateSettingsService.call(customer:, params: args)
 
+      PaymentTerms::AssignAliasService.call(record: customer, params: args)
+
       if args.key?(:net_payment_term)
         Customers::UpdateInvoicePaymentDueDateService.call(customer:, net_payment_term: args[:net_payment_term])
       end

app/services/customers/upsert_from_api_service.rb

@@ -71,6 +71,7 @@ def call
         customer.legal_name = params[:legal_name] if params.key?(:legal_name)
         customer.legal_number = params[:legal_number] if params.key?(:legal_number)
         customer.net_payment_term = params[:net_payment_term] if params.key?(:net_payment_term)
+        PaymentTerms::AssignAliasService.call(record: customer, params:)
         customer.external_salesforce_id = params[:external_salesforce_id] if params.key?(:external_salesforce_id)
         customer.finalize_zero_amount_invoice = params[:finalize_zero_amount_invoice] || "inherit" if params.key?(:finalize_zero_amount_invoice)
         customer.firstname = params[:firstname] if params.key?(:firstname)

app/services/payment_terms/assign_alias_service.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PaymentTerms
+  # Dual-write for the legacy net_payment_term alias: a write of the integer with no
+  # explicit payment_term mirrors it into the structured jsonb column as {net, N}.
+  #
+  # When payment_term is sent too, it wins and this service stays out of the way.
+  # NOTE: the payment_term input does not exist yet. Whichever change introduces it
+  #       must also assign it, otherwise the value is dropped here while
+  #       net_payment_term still writes, leaving the two columns diverged.
+  #
+  # Only assigns, the caller is responsible for saving the record.
+  class AssignAliasService < BaseService
+    Result = BaseResult
+
+    def initialize(record:, params:)
+      @record = record
+      @params = params
+      super
+    end
+
+    def call
+      if params.key?(:net_payment_term) && !params.key?(:payment_term)
+        record.payment_term = PaymentTerm.from_net_payment_term(params[:net_payment_term])&.to_h
+      end
+
+      result
+    end
+
+    private
+
+    attr_reader :record, :params
+  end
+end

spec/models/payment_term_spec.rb

@@ -28,6 +28,19 @@
     end
   end
 
+  describe ".from_net_payment_term" do
+    it "builds a net term from the legacy alias" do
+      expect(described_class.from_net_payment_term(0)&.to_h)
+        .to eq("term_type" => "net", "days" => 0)
+      expect(described_class.from_net_payment_term(30)&.to_h)
+        .to eq("term_type" => "net", "days" => 30)
+    end
+
+    it "returns nil when the legacy alias is cleared" do
+      expect(described_class.from_net_payment_term(nil)).to be_nil
+    end
+  end
+
   describe "#to_h" do
     it "serializes only the fields carried by the term type" do
       expect(described_class.from_h(term_type: "due_on_receipt").to_h)

spec/services/billing_entities/create_service_spec.rb

@@ -47,6 +47,12 @@
         before { result }
       end
 
+      it "does not set the structured payment term when net_payment_term is not provided" do
+        expect(result).to be_success
+        expect(result.billing_entity.net_payment_term).to eq(0)
+        expect(result.billing_entity.payment_term).to be_nil
+      end
+
       it "does not set eu_tax_management when not provided" do
         expect(result).to be_success
         expect(result.billing_entity.eu_tax_management).to be false
@@ -177,6 +183,7 @@
           expect(result.billing_entity.legal_name).to eq("Legal Name")
           expect(result.billing_entity.legal_number).to eq("Legal Number")
           expect(result.billing_entity.net_payment_term).to eq(90)
+          expect(result.billing_entity.payment_term).to eq("term_type" => "net", "days" => 90)
           expect(result.billing_entity.state).to eq("State")
           expect(result.billing_entity.tax_identification_number).to eq("EU123456789")
           expect(result.billing_entity.vat_rate).to eq(1)

spec/services/billing_entities/update_service_spec.rb

@@ -181,6 +181,7 @@
         end
 
         before do
+          billing_entity.update!(net_payment_term: 30, payment_term: {"term_type" => "net", "days" => 30})
           allow(BillingEntities::UpdateInvoicePaymentDueDateService).to receive(:call).and_call_original
         end
 
@@ -192,6 +193,7 @@
             expect(result).to be_success
 
             expect(result.billing_entity.net_payment_term).to eq(2)
+            expect(result.billing_entity.payment_term).to eq("term_type" => "net", "days" => 2)
             expect(BillingEntities::UpdateInvoicePaymentDueDateService).to have_received(:call).with(billing_entity:, net_payment_term: 2)
           end
         end