Class: OutgoingPaymentsController

Inherits:
CrmController show all
Includes:
Controllers::Destroyable, Controllers::RequireTurboFrame, Controllers::Showable, Controllers::Workflowable
Defined in:
app/controllers/outgoing_payments_controller.rb

Overview

== Schema Information

Table name: payments

id :integer not null, primary key
category :string(255)
company_id :integer
supplier_id :integer
reference_number :string(255)
amount :decimal(10, 2)
payment_date :date
currency :string(255)
bank_account_id :integer
exchange_rate :float
state :string(255)
remark :text
creator_id :integer
updater_id :integer
created_at :datetime
updated_at :datetime
check_state :string(255)
job_id :string(255)
reversal_date :date

Constant Summary collapse

TAB_ACTIONS =

Tab fragments never render standalone — non-frame hits redirect to show ?tab=.

%i[tab_payment_items tab_checks tab_account_ledger].freeze

Constants included from Controllers::ReferenceFindable

Controllers::ReferenceFindable::ID_EMBEDDED_PATTERNS

Constants included from Controllers::AnalyticsEvents

Controllers::AnalyticsEvents::MAX_QUEUED_EVENTS, Controllers::AnalyticsEvents::SESSION_KEY

Constants included from Controllers::ErrorRendering

Controllers::ErrorRendering::NON_CONTENT_PATH_PREFIXES

Instance Method Summary collapse

Methods included from Controllers::Workflowable

#render_workflow_error_stream, #render_workflow_success_stream, #workflow_action, #workflow_action_complete

Methods included from Controllers::Showable

#perform_show, #show

Methods included from Controllers::RequireTurboFrame

require_in_pane_tab_frames, require_turbo_frame

Methods included from Controllers::Destroyable

#destroy, #perform_destroy

Methods inherited from CrmController

#access_denied, #context_id, #context_object, #crm_home_path, #current_ability, #default_url_options, #download_temp, #get_tempfile_path_for_download, #init_status_job_collector, #initialize_crm_lazy_chunks, #persist_enqueued_status_jobs, #record_not_found, #redirect_to_job_or_fallback, #render_edit_action, #set_context, #set_download_path, #stash_file_for_temp_download, #sync_admin_presence_cookie, #touch_employee_last_seen

Methods inherited from ApplicationController

#account_impersonated?, #add_to_flash, #after_sign_in_path_for, #bypass_forgery_protection?, #chat_enabled?, #cloudflare_cleared?, #default_catalog, #default_url_options, #enable_turbo_frames, #find_publication, #fix_invalid_accept_header, #init_js_utils, #is_globals_call?, #layout_by_resource, #locale_store, #redirect_to, #require_employee_for_crm, #set_base_host, #set_real_ip, #set_report_errors_for, #should_render_layout?, #skip_layout_for_turbo_frame?, #stamp_impersonation_context, #tab_frame_breakout_request?, #warmlyyours_canada_ip?, #warmlyyours_ip?, #y

Methods included from Controllers::ReturnPathHandling

#check_for_return_path, #redirect_to_return_path_or_default

Methods included from Controllers::AnalyticsEvents

#consume_queued_analytics_events, #registration_lead_type, #track_event

Methods included from Controllers::DeviceDetection

#device_detector, #is_ie?

Methods included from Controllers::SubdomainDetection

#is_crm_request?, #is_www_request?, #json_request?

Methods included from Controllers::TurboSafeRedirect

#redirect_to

Methods included from Controllers::TrackingDetection

#bot_request?, #gdpr_country?, #gdpr_country_data, #prevent_bots, #set_tracking_cookie, #track_visitor?

Methods included from Controllers::AcceleratedFileSending

#send_file_accelerated, #send_upload_accelerated

Methods included from Controllers::ErrorRendering

#excp_string, #mail_to_for_error_reporting, #render_400, #render_404, #render_406, #render_410, #render_500, #render_invalid_authenticity_token, #render_ip_spoof_error, #render_unpermitted_parameters, #safe_referer_or_fallback

Methods included from Controllers::TurnstileVerification

#load_turnstile_script_tag, #turnstile_lazy_widget, #turnstile_script_tag, #turnstile_widget, #validate_turnstile!

Methods included from Controllers::CloudflareCaching

edge_cached, #edge_cached_action?, #reset_cloudflare_cache, #set_cloudflare_cache, #skip_edge_cache!, #skip_session

Methods included from Controllers::Webpackable

#preload_webpack_fonts, #webpack_css_include, #webpack_css_url, #webpack_js_include, #wpd_is_running?

Methods included from Controllers::Localizable

#cloudflare_country_locale, #determine_request_locale, #geocoder_locale, #guest_user_locale_check, #locale_optional_www_auth_path?, #param_locale, #set_locale, #set_request_locale, #skip_localization?, #warmlyyours_ip_locale

Methods included from Controllers::Authenticable

#access_denied, #authenticate_account, #authenticate_account!, #authenticate_account_from_login_token!, #check_is_a_manager, #check_is_a_sales_manager, #check_is_an_admin, #check_is_an_employee, #check_party, #clear_mismatched_guest_user, #create_guest_user, #credentials?, #current_or_guest_user, #current_or_guest_user_id_read_only, #current_user, #devise_mapping, #fully_logged_in?, #generate_bot_id, #guest_user, #identifiable?, #init_current_user, #initialize_guest, #load_context_user, #logging_in, #resource, #resource_name, #restrict_access_for_non_employees, #scrubbed_request_path, #user_object, #warn_on_session_guest_id_leak

Methods included from UrlsHelper

#catalog_breadcrumb_links, #catalog_link, #catalog_link_for_product_line, #catalog_link_for_sku, #cms_link, #delocalized_path, #path_to_sales_product_sku, #path_to_sales_product_sku_for_product_line, #path_to_sales_product_sku_for_product_line_slug, #product_line_from_catalog_link, #protocol_neutral_url, #sanitize_external_url, #valid_external_url?

Instance Method Details

#approve_check ⇒ Object

POST /outgoing_payments/:id/approve_check — fire the cheque-
approval state transition.



278
279
280
281
282
 
# File 'app/controllers/outgoing_payments_controller.rb', line 278

def approve_check
  @outgoing_payment = OutgoingPayment.find(params[:id])
  @outgoing_payment.trigger_check_approved
  redirect_to @outgoing_payment
end

#checks ⇒ Object

GET /outgoing_payments/checks — the cheque-print queue: applied
check-category payments filtered to queued/generated cheques by
default, but overrideable via the search params. Searching by
explicit check number short-circuits the state filter.



246
247
248
249
250
251
252
253
254
255
256
 
# File 'app/controllers/outgoing_payments_controller.rb', line 246

def checks
  params[:q] ||= { check_state_in: %w[queued generated] }
  if params.dig(:q, :checks_check_number_eq).present?
    params[:q].delete(:check_state_in) # check number always overrides state checks
  end
  # qp = params[:q] || {}
  # qp.reverse_merge!({ check_state_in: ['queued','generated'] }) unless params[:show_printed].to_b
  @q = OutgoingPayment.where(category: 'check', state: 'applied').ransack(params[:q])
  @q.sorts = 'reference_number DESC' if @q.sorts.blank?
  @pagy, @outgoing_payments = pagy(@q.result.includes(:company, :supplier, :checks, { bank_account: :bank }), limit: 200)
end

#create ⇒ Object

POST /outgoing_payments — persist the new payment and route the
user straight into #pay_items so they can apply it against
vouchers / credit memos / receipts.



81
82
83
84
85
86
87
88
89
90
 
# File 'app/controllers/outgoing_payments_controller.rb', line 81

def create
  @outgoing_payment = OutgoingPayment.new(params[:outgoing_payment])

  if @outgoing_payment.save
    redirect_to(pay_items_outgoing_payment_path(@outgoing_payment, credit_memo_id: @outgoing_payment.credit_memo_id))
  else
    # voucher.voucher_items.build if @voucher.voucher_items.empty?
    render action: 'new', status: :unprocessable_content
  end
end

#do_import_from_excel ⇒ Object

POST /outgoing_payments/do_import_from_excel — parse the uploaded
Payments sheet from a Roo-readable spreadsheet, create one
OutgoingPayment per row, and surface per-row validation errors
without aborting the rest of the import.



341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
 
# File 'app/controllers/outgoing_payments_controller.rb', line 341

def do_import_from_excel
  errors = []
  payments = []

  imported_file = params.dig(:upload, :imported_outgoing_payments_excel)
  unless imported_file
    flash.now[:error] = 'No file was uploaded'
    render(:import_from_excel, status: :unprocessable_content) and return
  end

  require 'roo'
  xlsx = Roo::Spreadsheet.open(imported_file.tempfile.path.to_s)
  unless xlsx.sheets.include?('Payments')
    flash.now[:error] = "Sheet 'Payments' not found in the uploaded file. Available sheets: #{xlsx.sheets.join(', ')}. Please use the provided template."
    render(:import_from_excel, status: :unprocessable_content) and return
  end
  payments_sheet = xlsx.sheet('Payments')
  payment_ref = 0
  @outgoing_payment = nil
  payment_errors = []
  consecutive_empty_rows = 0

  flush_current_payment = lambda do
    @outgoing_payment.errors.full_messages.each { |e| payment_errors << "-<b> Payment on row #{payment_ref}:</b> #{e}. <br>" } unless @outgoing_payment.valid?
    payment_errors << "-<b> Payment on row #{payment_ref}:</b> At least one Voucher with an 'Amount to pay' is required. <br>" if @outgoing_payment.outgoing_payment_items.empty?

    if @outgoing_payment.outgoing_payment_items.any? && @outgoing_payment.amount.present?
      vouchers_total = @outgoing_payment.outgoing_payment_items.sum { |item| item.amount.to_d }
      payment_amount = @outgoing_payment.amount.to_d
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Sum of voucher 'Amount to pay' (#{vouchers_total}) does not match payment 'Amount' (#{payment_amount}). <br>" if vouchers_total != payment_amount
    end

    if payment_errors.empty?
      payments << @outgoing_payment
    else
      errors.concat(payment_errors)
    end
    @outgoing_payment = nil
    payment_errors = []
  end

  payments_sheet.parse(headers: true, clean: true).each_with_index do |row, index|
    next if index.zero?

    if row.values.uniq.compact.blank?
      consecutive_empty_rows += 1
      if consecutive_empty_rows == 1
        if @outgoing_payment.present?
          flush_current_payment.call
        elsif payment_errors.any?
          errors.concat(payment_errors)
          payment_errors = []
        end
      end
      break if consecutive_empty_rows >= 5

      next
    end

    consecutive_empty_rows = 0

    if row['Company'].present?
      if @outgoing_payment.present?
        flush_current_payment.call
      elsif payment_errors.any?
        errors.concat(payment_errors)
        payment_errors = []
      end
      payment_ref = index + 1
      payment_errors = []

      company = Company.find_by(id: row['Company'].to_i)
      if company.nil?
        payment_errors << "-<b> Payment on row #{payment_ref}:</b> Company with id #{row['Company']} not found. <br>"
        @outgoing_payment = nil
        next
      end

      supplier = Party.find_by(id: row['Supplier id/ Payee'].to_i) if row['Supplier id/ Payee'].present?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Column 'Supplier id/ Payee' can't be blank. <br>" if row['Supplier id/ Payee'].blank?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Supplier with id #{row['Supplier id/ Payee']} not found. <br>" if row['Supplier id/ Payee'].present? && supplier.nil?

       = BankAccount.joins(:bank).where("CONCAT(banks.name, ' ', bank_accounts.name) = ?", row['Bank Account']).first if row['Bank Account'].present?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Column 'Bank Account' can't be blank. <br>" if row['Bank Account'].blank?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Bank account '#{row['Bank Account']}' not found. <br>" if row['Bank Account'].present? && .nil?

      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Column 'Payment Type' can't be blank. <br>" if row['Payment Type'].blank?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Column 'Payment Date' can't be blank. <br>" if row['Payment Date'].blank?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Column 'Amount' can't be blank. <br>" if row['Amount'].blank?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Column 'Currency' can't be blank. <br>" if row['Currency'].blank?

      payment_date = parse_excel_date(row['Payment Date']) { payment_errors << "-<b> Payment on row #{payment_ref}:</b> Column 'Payment Date' has an invalid date format (#{row['Payment Date'].inspect}). <br>" }

      mailing_address = resolve_mailing_address(row['Mailing Address'].to_s.strip, supplier, payment_errors, payment_ref) if row['Mailing Address'].present? && supplier.present?
      mailing_address ||= nil

      @outgoing_payment = OutgoingPayment.new(
        company: company,
        supplier: supplier,
        bank_account: ,
        category: row['Payment Type'],
        payment_date: payment_date,
        amount: row['Amount'],
        currency: row['Currency'].to_s.upcase,
        exchange_rate: row['Exchange Rate'],
        remark: row['Remark'],
        address: mailing_address,
        state: 'draft'
      )
    end

    next if @outgoing_payment.blank?

    next if row['Voucher'].blank?

    voucher_ref = row['Voucher'].is_a?(Numeric) ? row['Voucher'].to_i.to_s : row['Voucher'].to_s.strip
    amount_to_pay = row['Amount to pay']

    if amount_to_pay.blank?
      payment_errors << "-<b> Payment on row #{payment_ref}:</b> Voucher #{voucher_ref} is missing 'Amount to pay'. <br>"
    else
      voucher = Voucher.find_by(reference_number: voucher_ref)
      if voucher.nil?
        payment_errors << "-<b> Payment on row #{payment_ref}:</b> Voucher #{voucher_ref} not found. <br>"
      elsif voucher.currency.present? && @outgoing_payment.currency.present? && voucher.currency.upcase != @outgoing_payment.currency.upcase
        payment_errors << "-<b> Payment on row #{payment_ref}:</b> Currency mismatch — payment currency is #{@outgoing_payment.currency} but voucher #{voucher_ref} currency is #{voucher.currency}. Payment and voucher currencies must match. <br>"
      else
        already_used_ids = @outgoing_payment.outgoing_payment_items.map(&:voucher_item_id)
        available_items = voucher.voucher_items.available_to_apply.where.not(id: already_used_ids)
        if available_items.none?
          payment_errors << "-<b> Payment on row #{payment_ref}:</b> Voucher #{voucher_ref} has no available items to apply. <br>"
        else
          matching_item = available_items.find { |vi| vi.balance >= amount_to_pay.to_d }
          if matching_item
            @outgoing_payment.outgoing_payment_items.build(voucher_item: matching_item, amount: amount_to_pay)
          else
            payment_errors << "-<b> Payment on row #{payment_ref}:</b> Voucher #{voucher_ref} has no available item with sufficient balance for amount #{amount_to_pay}. <br>"
          end
        end
      end
    end
  end

  if @outgoing_payment.present?
    flush_current_payment.call
  elsif payment_errors.any?
    errors.concat(payment_errors)
  end

  if errors.any?
    flash.now[:error] = errors.uniq.join
    render :import_from_excel, status: :unprocessable_content
  else
    begin
      OutgoingPayment.transaction do
        payment_ids = payments.map do |p|
          p.save!
          p.payments_applied!
          p.id
        end
        redirect_to imported_outgoing_payments_path(payment_ids: payment_ids)
      end
    rescue StandardError => e
      flash.now[:error] = "Unable to import payments: #{e}."
      render :import_from_excel, status: :unprocessable_content
    end
  end
end

#do_reversal ⇒ Object

POST /outgoing_payments/:id/do_reversal — execute the reversal
using params[:reversal_date] as the GL post date. Refuses
double-reversals and re-renders the form on missing / invalid
dates.



223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'app/controllers/outgoing_payments_controller.rb', line 223

def do_reversal
  @outgoing_payment = OutgoingPayment.find(params[:id])

  if @outgoing_payment.reversal_date.present? && @outgoing_payment.voided?
    redirect_to @outgoing_payment, flash: { error: 'OutgoingPayment has already been reversed.' }
  elsif params[:reversal_date].blank?
    flash.now[:error] = 'You must specify a reversal date.'
    render :reverse, status: :unprocessable_content
  else
    begin
      @outgoing_payment.reverse(params[:reversal_date])
      redirect_to @outgoing_payment, info: 'OutgoingPayment successfully reversed.'
    rescue StandardError => e
      flash.now[:error] = "Unable to reverse payment, message : #{e}."
      render :reverse, status: :unprocessable_content
    end
  end
end

#download_sample_excel ⇒ Object

GET /outgoing_payments/download_sample_excel — serve the canonical
template spreadsheet for the bulk-import flow so users start from
the right column layout.



519
520
521
522
 
# File 'app/controllers/outgoing_payments_controller.rb', line 519

def download_sample_excel
  file_path = Rails.root.join('data/import_templates/outgoing_payments/outgoing_payments_import_template.xlsx')
  send_file_accelerated(file_path, download: true, preserve_source: true)
end

#edit ⇒ Object

GET /outgoing_payments/:id/edit — render the edit form. Editing
an applied payment is gated upstream by the OutgoingPayment
state machine, not here.



74
75
76
 
# File 'app/controllers/outgoing_payments_controller.rb', line 74

def edit
  @outgoing_payment = OutgoingPayment.find(params[:id])
end

#import_from_excel ⇒ Object

GET /outgoing_payments/import_from_excel — render the spreadsheet-
upload form for batch-creating outgoing payments.



335
 
# File 'app/controllers/outgoing_payments_controller.rb', line 335

def import_from_excel; end

#imported ⇒ Object

GET /outgoing_payments/imported — landing page after a successful
Excel import, listing the just-created payments by their ids.



512
513
514
 
# File 'app/controllers/outgoing_payments_controller.rb', line 512

def imported
  @outgoing_payments_just_imported = OutgoingPayment.where(id: params[:payment_ids].presence || [])
end

#index ⇒ Object

GET /outgoing_payments — paginated, ransack-filtered list of all
accounts-payable outgoing payments (cheques, wires, ACH).
Eager-loads company + supplier for the per-row display.



47
48
49
50
51
 
# File 'app/controllers/outgoing_payments_controller.rb', line 47

def index
  @q = OutgoingPayment.includes(:company, :supplier).ransack(params[:q])
  @q.sorts = 'reference_number DESC' if @q.sorts.blank?
  @pagy, @outgoing_payments = pagy(@q.result)
end

#lookup_address ⇒ Object

GET /outgoing_payments/lookup_address — JSON typeahead endpoint
that returns the party's addresses formatted for the address-
picker dropdown. Resolves contacts up to their parent customer
so a dealer's contact-level dropdown still shows the dealer's
billing addresses.



289
290
291
292
293
294
295
296
297
298
 
# File 'app/controllers/outgoing_payments_controller.rb', line 289

def lookup_address
  if (party_id = params[:party_id])
    Party.find_by(id: party_id)&.type == 'Contact' ? party_id = Party.find_by(id: party_id)&.customer&.id : party_id
    @addresses = Address.where(party_id: party_id).map(&:address_dropdown_format)
  else
    @addresses = []
  end
  res = { results: @addresses.uniq, pagination: { total: @addresses.count, more: false } }
  render json: res
end

#new ⇒ Object

GET /outgoing_payments/new — render the new-payment form,
honouring optional supplier_id, amount, currency,
company_id, credit_memo_id query params so the form can be
pre-filled from the supplier or credit-memo show pages. The
supplier's default payment method and the per-company
default bank account drive sane defaults.



59
60
61
62
63
64
65
66
67
68
69
 
# File 'app/controllers/outgoing_payments_controller.rb', line 59

def new
  @outgoing_payment = OutgoingPayment.new
  @outgoing_payment.supplier_id = params[:supplier_id] if params[:supplier_id].present?
  @outgoing_payment.amount = params[:amount] if params[:amount].present?
  @outgoing_payment.currency = params[:currency] if params[:currency].present?
  @outgoing_payment.company_id = params[:company_id] if params[:company_id].present?
  @outgoing_payment.credit_memo_id = params[:credit_memo_id] if params[:credit_memo_id].present?
  @outgoing_payment.category = @outgoing_payment.supplier.default_payment_method if @outgoing_payment.supplier
  @outgoing_payment. = OutgoingPayment::DEFAULT_BANK_ACCOUNTS[@outgoing_payment.company_id][@outgoing_payment.supplier.default_payment_method] if @outgoing_payment.company && @outgoing_payment.supplier
  # voucher.voucher_items.build
end

#pay_items ⇒ Object

GET /outgoing_payments/:id/pay_items — render the apply-payment
form: lists every available voucher item, billing credit memo,
and receipt for the supplier on this payment's company so the
user can tick what to apply against.



111
112
113
114
115
116
117
118
119
120
 
# File 'app/controllers/outgoing_payments_controller.rb', line 111

def pay_items
  @outgoing_payment = OutgoingPayment.find(params[:id])
  redirect_to(@outgoing_payment, error: 'OutgoingPayment has already been applied.') and return if @outgoing_payment.applied?

  @credit_memo_id = params[:credit_memo_id]&.to_i
  @supplier = @outgoing_payment.supplier
  @voucher_items = @supplier.voucher_items.for_company_id(@outgoing_payment.company_id).available_to_apply
  @credit_memos = @supplier.billing_credit_memos.for_company_id(@outgoing_payment.company_id).available_to_apply
  @receipts = @supplier.receipts.for_company_id(@outgoing_payment.company_id).available_to_apply
end

#post_pay_items ⇒ Object

POST /outgoing_payments/:id/post_pay_items — apply the user's
selected voucher items / credit memos / receipts against this
payment. Builds OutgoingPaymentItem rows in a transaction and
fires payments_applied! on the payment to advance its state
machine. Re-renders the form on validation or apply failure.



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'app/controllers/outgoing_payments_controller.rb', line 127

def post_pay_items
  @outgoing_payment = OutgoingPayment.find(params[:id])
  redirect_to(@outgoing_payment, error: 'OutgoingPayment has already been applied.') and return if @outgoing_payment.applied?

  @supplier = @outgoing_payment.supplier
  @voucher_items = @supplier.voucher_items.for_company_id(@outgoing_payment.company_id).available_to_apply
  @credit_memos = @supplier.billing_credit_memos.for_company_id(@outgoing_payment.company_id).available_to_apply
  @receipts = @supplier.receipts.for_company_id(@outgoing_payment.company_id).available_to_apply

  @selected_voucher_items = begin
    params[:voucher_items].select { |_k, v| v['select'] == '1' }
  rescue StandardError
    {}
  end
  @selected_credit_memos = begin
    params[:credit_memos].select { |_k, v| v['select'] == '1' }
  rescue StandardError
    {}
  end
  @selected_receipts = begin
    params[:receipts].select { |_k, v| v['select'] == '1' }
  rescue StandardError
    {}
  end

  @outgoing_payment.build_outgoing_payment_items(@selected_voucher_items, @selected_credit_memos, @selected_receipts)

  OutgoingPayment.transaction do
    if @outgoing_payment.save
      begin
        @outgoing_payment.payments_applied!
        redirect_to(@outgoing_payment)
      rescue StandardError => e
        flash.now[:error] = "Unable to apply payments, message: #{e}"
        render :pay_items, status: :unprocessable_content
      end
    else
      render :pay_items, status: :unprocessable_content
    end
  end
end

#print_all_checks ⇒ Object

POST /outgoing_payments/print_all_checks — bulk cheque-printing.
Refuses to launch when any selected payment already has a
background job in flight (we don't want overlapping prints
producing duplicate cheque numbers). Spawns
PrintAllChecksWorker and lands on the job-status page.



263
264
265
266
267
268
269
270
271
272
273
274
 
# File 'app/controllers/outgoing_payments_controller.rb', line 263

def print_all_checks
  payment_ids = params[:payments]
  redirect_to(checks_outgoing_payments_path, error: 'No payments were selected.') and return if payment_ids.blank?

  payment_ids.each do |payment_id|
    p = OutgoingPayment.find(payment_id)
    redirect_to(checks_outgoing_payments_path, error: 'You must wait for any existing jobs to finish before starting a new one.') and return if p.has_active_background_job?
  end
  job_id = PrintAllChecksWorker.perform_async('payment_ids' => payment_ids, 'current_user_id' => @context_user.id)
  OutgoingPayment.where(id: payment_ids).update_all(job_id: job_id)
  redirect_to_job_or_fallback(job_id, checks_outgoing_payments_path)
end

#print_check ⇒ Object

GET /outgoing_payments/:id/print_check — render or redirect to
the cheque PDF for a check-category payment. With check_id we
serve a single specific cheque's stored upload; without one we
generate a fresh combined cheque PDF (or redirect to it if the
generator returns an Upload). Refuses for non-check payments.



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'app/controllers/outgoing_payments_controller.rb', line 174

def print_check
  @outgoing_payment = OutgoingPayment.find(params[:id])
  redirect_to(@outgoing_payment, error: 'OutgoingPayment is not a check.') and return if @outgoing_payment.category != 'check'

  if params[:check_id]
    check = @outgoing_payment.checks.find(params[:check_id])
    redirect_to(@outgoing_payment, error: 'Unable to print check.') and return if check.uploads.empty?

    upload = check.print_check(@context_user)
    redirect_to(upload)
  elsif @outgoing_payment.checks.any? && @outgoing_payment.checks.all? { |c| c.uploads.empty? }
    redirect_to(@outgoing_payment, error: 'Unable to print check.') and return
  else
    file_path = @outgoing_payment.print_check(@context_user)
    if file_path.is_a?(Upload)
      redirect_to(file_path)
    else
      send_file_accelerated(file_path)
    end
  end
end

#reverse ⇒ Object

GET /outgoing_payments/:id/reverse — render the reversal form
(the user picks the GL date to post the reversing entry on).
Submission posts to #do_reversal.



215
216
217
 
# File 'app/controllers/outgoing_payments_controller.rb', line 215

def reverse
  @outgoing_payment = OutgoingPayment.find(params[:id])
end

#tab_account_ledger ⇒ Object

GET /outgoing_payments/:id/tab_account_ledger — turbo-frame body
for the GL view of this payment's LedgerEntry postings.



324
325
326
327
328
329
330
331
 
# File 'app/controllers/outgoing_payments_controller.rb', line 324

def 
  @outgoing_payment = OutgoingPayment.find(params[:id])
  authorize!(:read, @outgoing_payment)
  respond_to do |format|
    format.html { render layout: should_render_layout? }
    format.turbo_stream
  end
end

#tab_checks ⇒ Object

GET /outgoing_payments/:id/tab_checks — turbo-frame body for the
cheques tab (one or more Check records per payment).



313
314
315
316
317
318
319
320
 
# File 'app/controllers/outgoing_payments_controller.rb', line 313

def tab_checks
  @outgoing_payment = OutgoingPayment.find(params[:id])
  authorize!(:read, @outgoing_payment)
  respond_to do |format|
    format.html { render layout: should_render_layout? }
    format.turbo_stream
  end
end

#tab_payment_items ⇒ Object

GET /outgoing_payments/:id/tab_payment_items — turbo-frame body
showing the OutgoingPaymentItem rows that make up this payment.



302
303
304
305
306
307
308
309
 
# File 'app/controllers/outgoing_payments_controller.rb', line 302

def tab_payment_items
  @outgoing_payment = OutgoingPayment.find(params[:id])
  authorize!(:read, @outgoing_payment)
  respond_to do |format|
    format.html { render layout: should_render_layout? }
    format.turbo_stream
  end
end

#update ⇒ Object

PATCH/PUT /outgoing_payments/:id — update a payment's fields and
transition the cheque-state machine if the category changed
(check → fires trigger_check_pending_review; non-check while
queued → fires trigger_no_check).



96
97
98
99
100
101
102
103
104
105
 
# File 'app/controllers/outgoing_payments_controller.rb', line 96

def update
  @outgoing_payment = OutgoingPayment.find(params[:id])
  if @outgoing_payment.update(params[:outgoing_payment])
    @outgoing_payment.trigger_check_pending_review if (@outgoing_payment.category == 'check') && @outgoing_payment.no_check?
    @outgoing_payment.trigger_no_check if (@outgoing_payment.category != 'check') && @outgoing_payment.queued?
    redirect_to(@outgoing_payment, info: 'OutgoingPayment was successfully updated.')
  else
    render action: 'edit', status: :unprocessable_content
  end
end

#void ⇒ Object

POST /outgoing_payments/:id/void — fire the state-machine void
event. Suggests a reversal (which preserves history) when the
void is rejected — typically because the payment has already
posted to the GL and accounting policy requires a reversal entry
rather than a soft delete.



201
202
203
204
205
206
207
208
209
210
 
# File 'app/controllers/outgoing_payments_controller.rb', line 201

def void
  @outgoing_payment = OutgoingPayment.find(params[:id])
  begin
    @outgoing_payment.state_event = 'void'
    @outgoing_payment.save!
  rescue StandardError => e
    flash[:error] = "Unable to void payment, message : #{e}. Try reversing instead."
  end
  redirect_to @outgoing_payment
end