hr_lite 0.58.0 → 0.61.0

data/app/controllers/hr_lite/admin/leave_requests_controller.rb

@@ -65,8 +65,8 @@ module HrLite
           redirect_to admin_leave_request_path(request),
                       alert: "Cannot approve — comp-off credit no longer covers this request."
         end
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_leave_request_path(request), alert: "Only pending requests can be decided."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_leave_request_path(request), alert: reason_for(e, "Only pending requests can be decided.")
       end
 
       # LeaveRequest#cancellable_by? has always allowed an admin to call off
@@ -96,8 +96,8 @@ module HrLite
 
         request.reject!(actor: hr_current_user, note: note)
         redirect_to admin_leave_requests_path, notice: "Leave rejected."
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_leave_request_path(request), alert: "Only pending requests can be decided."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_leave_request_path(request), alert: reason_for(e, "Only pending requests can be decided.")
       end
 
       private

data/app/controllers/hr_lite/admin/overview_controller.rb

@@ -6,6 +6,11 @@ module HrLite
       def index
         @query = OverviewQuery.new(user_ids: hr_access.visible_user_ids("leave.view"))
         @kpis = @query.kpis
+        # Emails, bells and audit rows that failed in the background; the audit trail's own gate.
+        return unless hr_can?("profile.manage", scope: :all)
+
+        failures = AuditLog.recent.where("action LIKE ?", "failure.%").includes(:subject).limit(SECTION_CAP)
+        @failures = hr_superadmin? ? failures : failures.outside_money_tier
       end
     end
   end

data/app/controllers/hr_lite/admin/regularization_requests_controller.rb

@@ -18,8 +18,8 @@ module HrLite
       rescue RegularizationRequest::InvalidMerge => e
         redirect_to admin_regularization_request_path(request),
                     alert: "Cannot apply — #{e.message}. Fix the day manually or reject with a note."
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_regularization_request_path(request), alert: "Only pending tickets can be decided."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_regularization_request_path(request), alert: reason_for(e, "Only pending tickets can be decided.")
       end
 
       def reject
@@ -31,8 +31,8 @@ module HrLite
 
         request.reject!(actor: hr_current_user, note: note)
         redirect_to admin_regularization_requests_path, notice: "Ticket rejected."
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_regularization_request_path(request), alert: "Only pending tickets can be decided."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_regularization_request_path(request), alert: reason_for(e, "Only pending tickets can be decided.")
       end
 
       private

data/app/controllers/hr_lite/admin/resignations_controller.rb

@@ -17,6 +17,10 @@ module HrLite
             "#{hr_display_name(resignation.user)}, so no exit date was recorded — " \
             "create the profile to clip attendance and payroll."
         end
+        if resignation.access_error
+          return redirect_to admin_employees_path,
+                             alert: "#{notice} But access was NOT revoked (#{resignation.access_error}) — revoke the login by hand."
+        end
         redirect_to admin_employees_path, notice: notice
       rescue ActiveRecord::RecordInvalid => e
         # A rejected exit date used to be reported as "not pending", which was

data/app/controllers/hr_lite/admin/tax_declarations_controller.rb

@@ -62,8 +62,8 @@ module HrLite
           declaration.verify!(actor: hr_current_user, note: "Proof accepted")
         end
         redirect_to admin_tax_declarations_path, notice: "Accepted and verified — payroll uses these amounts now."
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_tax_declaration_path(declaration), alert: "Only a submitted declaration can be accepted."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_tax_declaration_path(declaration), alert: reason_for(e, "Only a submitted declaration can be accepted.")
       end
 
       def update

data/app/controllers/hr_lite/admin/wfh_requests_controller.rb

@@ -49,8 +49,8 @@ module HrLite
         request = decidable.find(params[:id])
         request.approve!(actor: hr_current_user, note: params[:decision_note].to_s.strip.presence)
         redirect_to admin_wfh_requests_path, notice: "WFH approved for #{hr_display_name(request.user)}."
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_wfh_request_path(request), alert: "Only pending requests can be decided."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_wfh_request_path(request), alert: reason_for(e, "Only pending requests can be decided.")
       end
 
       def reject
@@ -60,8 +60,8 @@ module HrLite
 
         request.reject!(actor: hr_current_user, note: note)
         redirect_to admin_wfh_requests_path, notice: "WFH rejected."
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_wfh_request_path(request), alert: "Only pending requests can be decided."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_wfh_request_path(request), alert: reason_for(e, "Only pending requests can be decided.")
       end
 
       # HR changes an approved or rejected request: dates (past allowed) and/or decision, with a reason.

data/app/controllers/hr_lite/admin/work_locations_controller.rb

@@ -38,11 +38,11 @@ module HrLite
                                                           body: note, path: "/work_locations",
                                                           bell_to: [ location.user ], email_to: [ location.user ])
         rescue => e
-          Rails.logger.error("[hr_lite] work location notification failed: #{e.class}: #{e.message}")
+          HrLite.record_failure("work_location.#{status}", e, subject: location.user)
         end
         redirect_to admin_work_locations_path, notice: "Location #{status}."
-      rescue ActiveRecord::RecordInvalid
-        redirect_to admin_work_locations_path, alert: "Only pending locations can be decided."
+      rescue ActiveRecord::RecordInvalid => e
+        redirect_to admin_work_locations_path, alert: reason_for(e, "Only pending locations can be decided.")
       end
     end
   end

data/app/controllers/hr_lite/application_controller.rb

@@ -100,6 +100,11 @@ module HrLite
       end
     end
 
+    # The record's own reason when it has one; `fallback` names the usual cause.
+    def reason_for(error, fallback)
+      error.record.errors.full_messages.to_sentence.presence || fallback
+    end
+
     # Strict param parsing: anything that isn't the exact expected format
     # falls back to today (never 500s on a mangled URL).
     def parse_month_param(value)

data/app/controllers/hr_lite/comp_off_requests_controller.rb

@@ -27,8 +27,8 @@ module HrLite
       request = CompOffRequest.where(user_id: hr_current_user.id).find(params[:id])
       request.cancel!(actor: hr_current_user)
       redirect_to comp_off_requests_path, notice: "Request cancelled."
-    rescue ActiveRecord::RecordInvalid
-      redirect_to comp_off_requests_path, alert: "Only pending requests can be cancelled."
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to comp_off_requests_path, alert: reason_for(e, "Only pending requests can be cancelled.")
     end
 
     private

data/app/controllers/hr_lite/hr_requests_controller.rb

@@ -30,8 +30,8 @@ module HrLite
       request = own.find(params[:id])
       request.cancel!(actor: hr_current_user)
       redirect_to hr_requests_path, notice: "Request withdrawn."
-    rescue ActiveRecord::RecordInvalid
-      redirect_to hr_requests_path, alert: "That request has already been answered."
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to hr_requests_path, alert: reason_for(e, "That request has already been answered.")
     end
 
     private

data/app/controllers/hr_lite/regularization_requests_controller.rb

@@ -23,8 +23,8 @@ module HrLite
       request = RegularizationRequest.where(user_id: hr_current_user.id).find(params[:id])
       request.cancel!(actor: hr_current_user)
       redirect_to regularization_requests_path, notice: "Day fix cancelled."
-    rescue ActiveRecord::RecordInvalid
-      redirect_to regularization_requests_path, alert: "Only pending day fixes can be cancelled."
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to regularization_requests_path, alert: reason_for(e, "Only pending day fixes can be cancelled.")
     end
 
     private

data/app/controllers/hr_lite/tax_declarations_controller.rb

@@ -54,8 +54,8 @@ module HrLite
 
       @declaration.submit!(actor: hr_current_user)
       redirect_to tax_declaration_path, notice: "Submitted — HR will check the proof."
-    rescue ActiveRecord::RecordInvalid
-      redirect_to tax_declaration_path, alert: "Only a draft can be submitted."
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to tax_declaration_path, alert: reason_for(e, "Only a draft can be submitted.")
     end
 
     private

data/app/controllers/hr_lite/wfh_requests_controller.rb

@@ -26,8 +26,8 @@ module HrLite
     def cancel
       WfhRequest.where(user_id: hr_current_user.id).find(params[:id]).cancel!(actor: hr_current_user)
       redirect_to wfh_requests_path, notice: "WFH request cancelled."
-    rescue ActiveRecord::RecordInvalid
-      redirect_to wfh_requests_path, alert: "Only pending requests can be cancelled."
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to wfh_requests_path, alert: reason_for(e, "Only pending requests can be cancelled.")
     end
 
     private

data/app/controllers/hr_lite/work_locations_controller.rb

@@ -50,7 +50,7 @@ module HrLite
     def notify(event, title, path, to)
       Notifications.publish(event, title: title, path: path, bell_to: to)
     rescue => e
-      Rails.logger.error("[hr_lite] work location notification failed: #{e.class}: #{e.message}")
+      HrLite.record_failure(event, e, subject: hr_current_user)
     end
   end
 end

data/app/helpers/hr_lite/application_helper.rb

@@ -88,6 +88,10 @@ module HrLite
         { label: "Help desk", path: :admin_hr_requests_path, match: [ "/admin/hr_requests" ], if: -> { hr_can?("hr_request.manage", scope: :all) } },
         { label: "Manage policies", path: :admin_policies_path, match: [ "/admin/policies" ], if: -> { hr_can?("policy.manage", scope: :all) } }
       ] },
+      { label: "Hiring", tabs: [
+        { label: "Campaigns", path: :admin_hiring_campaigns_path, match: [ "/admin/hiring_campaigns", "/admin/hiring_candidates" ], if: -> { hr_can?("hiring.manage", scope: :all) } },
+        { label: "Email templates", path: :admin_hiring_templates_path, match: [ "/admin/hiring_templates" ], if: -> { hr_can?("hiring.manage", scope: :all) } }
+      ] },
       { label: "Admin", divider: true, tabs: [
         { label: "Settings", path: :admin_leave_types_path, match: [ "/admin/leave_types", "/admin/office_locations", "/admin/holidays", "/admin/expense_categories" ], if: LEAD },
         { label: "HR settings", path: :edit_admin_setting_path, match: [ "/admin/setting" ], if: LEAD },
@@ -194,6 +198,7 @@ module HrLite
       "People" => '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.9M16 3.1a4 4 0 0 1 0 7.8"/>',
       "Me" => '<circle cx="12" cy="8" r="4"/><path d="M4 21a8 8 0 0 1 16 0"/>',
       "Help" => '<circle cx="12" cy="12" r="9"/><path d="M9.1 9a3 3 0 0 1 5.8 1c0 2-3 3-3 3M12 17h.01"/>',
+      "Hiring" => '<rect x="2" y="7" width="20" height="14" rx="2"/><path d="M16 21V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16"/>',
       "Admin" => '<path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/>',
       "More" => '<circle cx="5" cy="12" r="1.5"/><circle cx="12" cy="12" r="1.5"/><circle cx="19" cy="12" r="1.5"/>',
       "Search" => '<circle cx="11" cy="11" r="7"/><path d="m20 20-3.5-3.5"/>'
@@ -253,6 +258,39 @@ module HrLite
       hr_lite.public_send(helper, approval.subject_id)
     end
 
+    HIRING_BADGES = { "imported" => "muted", "invited" => "info", "interested" => "ok", "not_interested" => "bad",
+                      "interview" => "warn", "selected" => "ok", "rejected" => "bad", "on_hold" => "muted" }.freeze
+
+    def hrl_hiring_badge(candidate)
+      modifier = HIRING_BADGES.fetch(candidate.stage)
+      tag.span(candidate.stage_label, class: [ "hrl-badge", ("hrl-badge--#{modifier}" unless modifier == "info") ])
+    end
+
+    # The five steps of the candidate stepper: [label, :done|:now|:todo].
+    HIRING_STEPS = %w[Imported Invited Interested Interview Decision].freeze
+    HIRING_STEP_OF = { "imported" => 0, "invited" => 1, "interested" => 2, "not_interested" => 2, "interview" => 3,
+                       "selected" => 4, "rejected" => 4, "on_hold" => 4 }.freeze
+
+    def hrl_hiring_steps(candidate)
+      at = HIRING_STEP_OF.fetch(candidate.stage)
+      HIRING_STEPS.each_with_index.map do |label, i|
+        label = candidate.stage_label if i == at && %w[not_interested interview selected rejected on_hold].include?(candidate.stage)
+        [ label, i < at ? :done : (i == at ? :now : :todo) ]
+      end
+    end
+
+    # One line per hiring timeline row, from the whitelisted changes it stored.
+    def hrl_hiring_event(log)
+      c = log.audited_changes.to_h
+      at = c["starts_at"] && Time.zone.parse(c["starts_at"]).strftime("%-d %b %Y, %-l:%M %p")
+      case log.action.delete_prefix("hiring.")
+      when "stage" then [ "Moved to #{c['to'].to_s.humanize}", c["reason"] ].compact.join(": ")
+      when /\Aemail_(\w+)\z/ then "Email #{Regexp.last_match(1)}: #{c['template']}"
+      when /\Ainterview_(\w+)\z/ then [ "Round #{c['round']} #{Regexp.last_match(1).tr('_', ' ')}", at ].compact.join(" for ")
+      else log.action.delete_prefix("hiring.").humanize
+      end
+    end
+
     def hrl_pagination
       render "hr_lite/shared/pagination"
     end

data/app/jobs/hr_lite/calendar_meeting_sync_job.rb

@@ -33,7 +33,7 @@ module HrLite
                                       .select { |m| m[:id].present? && m[:starts_at] && m[:ends_at] }
                                       .each { |m| m[:id] = m[:id].to_s }
     rescue => e
-      Rails.logger.warn("[hr_lite] calendar read failed for user #{user.id}: #{e.class}: #{e.message}")
+      HrLite.record_failure("calendar_read", e, subject: user)
       nil
     end
 

data/app/jobs/hr_lite/hiring_send_job.rb

@@ -0,0 +1,42 @@
+module HrLite
+  # Sends one queued hiring email through the host's mail adapter. The first
+  # step claims the row, so a redelivered or parallel job finds it taken and
+  # stops: a send is attempted at most once. A crash after the claim leaves
+  # "sending", which the screens show as "check Gmail", never as "send again".
+  # Adapter errors must not quote the recipient: their text is stored.
+  class HiringSendJob < ApplicationJob
+    queue_as :default
+
+    def perform(message_id)
+      return unless HiringMessage.where(id: message_id, status: "queued").update_all(status: "sending", updated_at: Time.current) == 1
+
+      message = HiringMessage.find(message_id)
+      HrLite::Current.set(actor: message.sent_by) { deliver(message) }
+    end
+
+    private
+
+    def deliver(message)
+      candidate = message.candidate
+      adapter = HrLite.config.hiring
+      sender = adapter&.sender
+      return finish(message, "failed", error: "No sender mailbox is connected") unless sender&.dig(:ready)
+
+      mail = HiringMerge.new(candidate, sender_name: sender[:name]).render(message.template)
+      return finish(message, "failed", error: "Missing #{mail.missing.join(', ')}") if mail.missing.any?
+
+      ids = adapter.send_email(to: candidate.email, subject: mail.subject, body: mail.body)
+      finish(message, "sent", sent_at: Time.current, gmail_message_id: ids[:message_id], gmail_thread_id: ids[:thread_id])
+      candidate.move_to!("invited") if candidate.stage == "imported"
+    rescue HrLite::HiringDeliveryUnknown => e
+      finish(message, "unknown", error: e.message.to_s.truncate(200))
+    rescue HrLite::HiringDeliveryFailed => e
+      finish(message, "failed", error: e.message.to_s.truncate(200))
+    end
+
+    def finish(message, status, **attributes)
+      message.update!(status: status, **attributes)
+      message.candidate.log!("email_#{status}", template: message.template.name)
+    end
+  end
+end

data/app/models/concerns/hr_lite/audited.rb

@@ -37,8 +37,8 @@ module HrLite
       hr_lite_publish_policy_change(log)
     rescue => e
       # The trail is best-effort by design: an audit hiccup must never roll
-      # back the domain write it describes. Logged loudly instead.
-      Rails.logger.error("[hr_lite] audit failed: #{e.class}: #{e.message}")
+      # back the domain write it describes. Shown to HR admins instead.
+      HrLite.record_failure("audit.#{action}", e, subject: self)
     end
 
     def hr_lite_audited_changes(action)

data/app/models/hr_lite/designation_change.rb

@@ -17,6 +17,9 @@ module HrLite
     after_create :apply_to_profile
     after_create :notify
 
+    # Why the host's on_designation_change hook failed, for the screen to say so.
+    attr_reader :hook_error
+
     def readonly?
       persisted? && !destroyed?
     end
@@ -45,6 +48,7 @@ module HrLite
         HrLite.config.on_designation_change.call(user, to_designation)
       rescue => e
         Rails.logger.error("[hr_lite] on_designation_change failed: #{e.class}: #{e.message}")
+        @hook_error = e.message.truncate(120)
       end
     end
 

data/app/models/hr_lite/employee_profile.rb

@@ -234,7 +234,7 @@ module HrLite
       ChecklistItem.open_for!(user, kind: "onboarding", anchor_date: date_of_joining)
     rescue => e
       # A checklist must never be the reason an employee cannot be created.
-      Rails.logger.error("[hr_lite] onboarding checklist failed: #{e.class}: #{e.message}")
+      HrLite.record_failure("onboarding_checklist", e, subject: user)
     end
   end
 end

data/app/models/hr_lite/hiring_campaign.rb

@@ -0,0 +1,21 @@
+module HrLite
+  # One hiring drive for one opening. Its fields fill the @placeholders in
+  # every email, so the offer lives here, never in template copy.
+  class HiringCampaign < ApplicationRecord
+    has_many :candidates, class_name: "HrLite::HiringCandidate", foreign_key: :campaign_id,
+                          inverse_of: :campaign, dependent: :restrict_with_error
+
+    validates :title, :position, presence: true
+    validates :status, inclusion: { in: %w[open closed] }
+
+    scope :newest_first, -> { order(created_at: :desc) }
+
+    # The pipeline list and "select all" on it are the same filter.
+    def pipeline(stage: nil, campus: nil)
+      scope = candidates
+      scope = scope.where(stage: stage) if stage.presence_in(HiringCandidate::STAGES)
+      scope = scope.where(campus: campus) if campus.present?
+      scope.order(:name, :id)
+    end
+  end
+end

data/app/models/hr_lite/hiring_candidate.rb

@@ -0,0 +1,52 @@
+module HrLite
+  # A person from a university's sheet, moving through one campaign. Every
+  # change goes on their timeline (AuditLog rows whose subject is them).
+  class HiringCandidate < ApplicationRecord
+    STAGES = %w[imported invited interested not_interested interview selected rejected on_hold].freeze
+    # Where a stage may go next. Sending moves imported → invited; scheduling moves to interview.
+    MOVES = {
+      "imported" => %w[invited interested not_interested],
+      "invited" => %w[interested not_interested],
+      "interested" => %w[interview not_interested on_hold rejected],
+      "not_interested" => %w[interested],
+      "interview" => %w[interview selected rejected on_hold],
+      "on_hold" => %w[interview selected rejected],
+      "selected" => [], "rejected" => []
+    }.freeze
+    REJECTION_REASONS = [ "Communication skills", "Not available for 6 months", "Location / relocation",
+                          "Stipend not acceptable", "Did not attend interview", "Other" ].freeze
+
+    belongs_to :campaign, class_name: "HrLite::HiringCampaign", inverse_of: :candidates
+    has_many :messages, class_name: "HrLite::HiringMessage", foreign_key: :candidate_id, dependent: :restrict_with_error
+    has_many :interviews, class_name: "HrLite::HiringInterview", foreign_key: :candidate_id, dependent: :restrict_with_error
+
+    encrypts :phone, :date_of_birth
+    normalizes :email, with: ->(email) { email.to_s.strip.downcase }
+
+    validates :name, presence: true
+    validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }, uniqueness: { scope: :campaign_id }
+    validates :stage, inclusion: { in: STAGES }
+
+    def first_name = name.to_s.split.first
+    def stage_label = stage == "interview" ? "Interview · round #{round}" : stage.humanize
+    def timeline = AuditLog.where(subject_type: self.class.name, subject_id: id).includes(:actor).order(created_at: :desc, id: :desc)
+
+    # The one door for a stage change: refuses a move the pipeline does not
+    # allow, needs a listed reason to reject, and writes the timeline row.
+    def move_to!(to, reason: nil, note: nil, round: self.round)
+      raise ArgumentError, "#{stage_label} cannot move to #{to.humanize}." unless MOVES.fetch(stage).include?(to)
+      raise ArgumentError, "Pick a rejection reason." if to == "rejected" && !REJECTION_REASONS.include?(reason)
+      raise ArgumentError, "Write a note for “Other”." if reason == "Other" && note.blank?
+
+      transaction do
+        from = stage
+        update!(stage: to, round: round, rejection_reason: (to == "rejected" ? [ reason, note.presence ].compact.join(": ") : rejection_reason))
+        log!("stage", from: from, to: to, reason: (reason if to == "rejected"))
+      end
+    end
+
+    def log!(action, actor: HrLite::Current.actor, **changes)
+      AuditLog.record!(action: "hiring.#{action}", subject: self, actor: actor, changes: changes.compact)
+    end
+  end
+end

data/app/models/hr_lite/hiring_interview.rb

@@ -0,0 +1,13 @@
+module HrLite
+  # One interview round on the sender's Google Calendar. A new round is a new
+  # row, so earlier rounds keep their own history.
+  class HiringInterview < ApplicationRecord
+    STATUSES = %w[unknown scheduled failed cancelled].freeze
+
+    belongs_to :candidate, class_name: "HrLite::HiringCandidate"
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :round, numericality: { greater_than: 0 }
+    validates :starts_at, :ends_at, presence: true
+  end
+end

data/app/models/hr_lite/hiring_message.rb

@@ -0,0 +1,14 @@
+module HrLite
+  # One template sent (or being sent) to one candidate. The unique index on
+  # candidate + template is what makes a repeated click or job a no-op.
+  # "sending" left behind by a crash, and "unknown", both mean: look in Gmail.
+  class HiringMessage < ApplicationRecord
+    STATUSES = %w[queued sending sent failed unknown].freeze
+
+    belongs_to :candidate, class_name: "HrLite::HiringCandidate"
+    belongs_to :template, class_name: "HrLite::HiringTemplate"
+    belongs_to :sent_by, class_name: HrLite.config.user_class, optional: true
+
+    validates :status, inclusion: { in: STATUSES }
+  end
+end

data/app/models/hr_lite/hiring_template.rb

@@ -0,0 +1,11 @@
+module HrLite
+  # An email HR writes once and sends to many. @placeholders are filled per
+  # candidate by HiringMerge at send time.
+  class HiringTemplate < ApplicationRecord
+    has_many :messages, class_name: "HrLite::HiringMessage", foreign_key: :template_id, dependent: :restrict_with_error
+
+    validates :name, :subject, :body, presence: true
+
+    scope :alphabetical, -> { order(:name) }
+  end
+end

data/app/models/hr_lite/resignation.rb

@@ -68,6 +68,9 @@ module HrLite
     end
 
     # False when the person had no employee profile to stamp — see accept!.
+    # Why the host could not revoke access, for the screen to say so.
+    attr_reader :access_error
+
     def exit_date_recorded?
       @exit_date_recorded
     end
@@ -82,6 +85,7 @@ module HrLite
       HrLite.config.offboard_user.call(user)
     rescue => e
       Rails.logger.error("[hr_lite] offboard_user failed: #{e.class}: #{e.message}")
+      @access_error = e.message.truncate(120)
     end
 
     def notify_submitted

data/app/models/hr_lite/wfh_request.rb

@@ -96,7 +96,7 @@ module HrLite
       Notifications.publish(event, title: title, body: body.presence, path: path, bell_to: to,
                                    email_to: event == "wfh.requested" ? [] : to)
     rescue => e
-      Rails.logger.error("[hr_lite] wfh notification failed: #{e.class}: #{e.message}")
+      HrLite.record_failure(event, e, subject: user)
     end
 
     def dates_in_window

data/app/services/hr_lite/hiring_import.rb

@@ -0,0 +1,106 @@
+module HrLite
+  # Reads a university's candidate sheet into a preview, then imports it.
+  # Headers match an alias list after case-folding and dropping punctuation
+  # and spaces. A column nobody recognises is kept in `extra`, never dropped;
+  # two columns claiming one field wait for HR to pick one.
+  class HiringImport
+    ALIASES = {
+      "name" => %w[studentname name candidatename fullname],
+      "email" => %w[emailid email emailaddress mailid],
+      "phone" => %w[contactno contactnumber phone phoneno mobile mobileno],
+      "date_of_birth" => %w[dob dobddmmyyyy dateofbirth],
+      "campus" => %w[campus college],
+      "course" => %w[coursepursuing course programme program],
+      "branch" => %w[branchspecialization branch specialization],
+      "cv_url" => %w[linkforcv cv cvlink resume resumelink]
+    }.freeze
+
+    Column = Data.define(:index, :header, :field, :extra_key)
+    Row = Data.define(:number, :attributes, :extra, :outcome, :reason)
+
+    def self.normalize(header) = header.to_s.downcase.gsub(/[^a-z0-9]/, "")
+
+    # Cell values arrive as the sheet stored them: never evaluated, never fetched.
+    def self.text(value)
+      case value
+      when nil then ""
+      when Float then value == value.floor ? value.to_i.to_s : value.to_s
+      when Date, Time then value.strftime("%d/%m/%Y")
+      else value.to_s.strip
+      end
+    end
+
+    attr_reader :columns, :conflicts, :rows
+
+    # rows: arrays of cell values, headers first. picks: { "phone" => "3" }
+    # names the column that wins a field two columns claim.
+    def initialize(campaign, rows, picks: {})
+      @campaign = campaign
+      header, *body = rows
+      map_columns(Array(header), picks.to_h.transform_values(&:to_i))
+      @rows = classify(body)
+    end
+
+    def counts = %w[create update skip].index_with { |outcome| rows.count { |row| row.outcome == outcome } }
+
+    def import!
+      return false if conflicts.any?
+
+      HiringCandidate.transaction do
+        rows.reject { |row| row.outcome == "skip" }.each do |row|
+          candidate = @campaign.candidates.find_or_initialize_by(email: row.attributes["email"])
+          created = candidate.new_record?
+          candidate.assign_attributes(row.attributes.merge("extra" => candidate.extra.to_h.merge(row.extra)))
+          candidate.save!
+          candidate.log!(created ? "imported" : "reimported") if created || candidate.saved_changes.any?
+        end
+      end
+      true
+    end
+
+    private
+
+    def map_columns(header, picks)
+      @columns = header.each_with_index.map do |cell, index|
+        field = ALIASES.find { |_, names| names.include?(self.class.normalize(cell)) }&.first
+        Column.new(index:, header: cell.to_s.strip, field:, extra_key: nil)
+      end
+      claimed = @columns.select(&:field).group_by(&:field)
+      @conflicts = claimed.select { |field, cols| cols.size > 1 && cols.none? { |c| c.index == picks[field] } }
+      # A column that lost its field (or is unknown) keeps its data in `extra`.
+      taken = HiringMerge::RESERVED + ALIASES.keys
+      @columns = @columns.map do |col|
+        loses = col.field && claimed[col.field].size > 1 && picks[col.field] != col.index
+        next col if col.field && !loses
+
+        key = col.header.parameterize(separator: "_").presence || "column_#{col.index + 1}"
+        key = "sheet_#{key}" if taken.include?(key) || !key.match?(/\A[a-z]/) # @placeholders start with a letter
+        taken << key
+        col.with(field: nil, extra_key: key)
+      end
+    end
+
+    def classify(body)
+      seen = {}
+      existing = @campaign.candidates.pluck(:email).to_set
+      body.each_with_index.filter_map do |cells, i|
+        number = i + 2 # sheet row, counting the header
+        values = @columns.to_h { |col| [ col, self.class.text(Array(cells)[col.index]) ] }
+        next if values.values.all?(&:blank?) # an empty row in the sheet is not a candidate
+
+        attributes = values.select { |col, _| col.field }.to_h { |col, v| [ col.field, v.presence ] }
+        attributes["email"] = attributes["email"].to_s.strip.downcase.presence
+        extra = values.select { |col, v| col.extra_key && v.present? }.to_h { |col, v| [ col.extra_key, v ] }
+        outcome, reason =
+          if attributes["name"].blank? then [ "skip", "no name" ]
+          elsif attributes["email"].blank? then [ "skip", "no email address" ]
+          elsif !attributes["email"].match?(URI::MailTo::EMAIL_REGEXP) then [ "skip", "email address looks wrong" ]
+          elsif seen[attributes["email"]] then [ "skip", "same email as row #{seen[attributes['email']]}" ]
+          else [ existing.include?(attributes["email"]) ? "update" : "create", nil ]
+          end
+        seen[attributes["email"]] ||= number if attributes["email"]
+        Row.new(number:, attributes:, extra:, outcome:, reason:)
+      end
+    end
+  end
+end