hr_lite 0.54.0 → 0.55.0

data/app/helpers/hr_lite/application_helper.rb

@@ -41,7 +41,7 @@ module HrLite
           queue: -> { hrl_queue(HrLite::LeaveRequest.where(status: "pending"), "leave.approve") } },
         { label: "Comp-off", path: :admin_comp_off_requests_path, match: [ "/admin/comp_off_requests" ], if: OPS,
           queue: -> { hrl_queue(HrLite::CompOffRequest.pending, "leave.approve") } },
-        { label: "Attendance fixes", path: :admin_regularization_requests_path, match: [ "/admin/regularization_requests" ], if: OPS,
+        { label: "Day fixes", path: :admin_regularization_requests_path, match: [ "/admin/regularization_requests" ], if: OPS,
           queue: -> { hrl_queue(HrLite::RegularizationRequest.pending, "attendance.manage") } },
         { label: "WFH", path: :admin_wfh_requests_path, match: [ "/admin/wfh_requests" ], if: OPS,
           queue: -> { hrl_queue(HrLite::WfhRequest.pending.overlapping(Date.current, Date.current + HrLite::WfhRequest::MAX_DAYS_AHEAD), "attendance.manage") } },
@@ -49,6 +49,8 @@ module HrLite
           queue: -> { hrl_queue(HrLite::WorkLocation.pending, "attendance.manage") } },
         { label: "Claims", path: :admin_expenses_path, match: [ "/admin/expenses" ], if: -> { hr_can?("expense.approve", scope: :team) },
           queue: -> { hrl_queue(HrLite::Expense.where(status: "submitted"), "expense.approve") } },
+        { label: "Resignations", path: :admin_employees_path, match: [ "/admin/resignations" ], if: LEAD,
+          queue: -> { hrl_queue(HrLite::Resignation.pending, "profile.manage") } },
         { label: "Documents to verify", path: :admin_documents_path, match: [ "/admin/documents" ], if: LEAD,
           queue: -> { hrl_queue(HrLite::Document.where(verification: "pending"), "document.view") } },
         { label: "CA review", path: :admin_ca_reviews_path, match: [ "/admin/ca_reviews" ],
@@ -69,11 +71,11 @@ module HrLite
         { label: "Team benefits", path: :admin_benefits_path, match: [ "/admin/benefits" ], if: MANAGE }
       ] },
       { label: "People", match: [ "/people" ], tabs: [
-        { label: "My team", path: :team_path, match: [ "/team" ] },
+        { label: "Team board", path: :team_path, match: [ "/team" ] },
         { label: "Org chart", path: :org_path, match: [ "/org" ] },
         { label: "Kudos", path: :kudos_path, match: [ "/kudos" ] },
         { label: "Employees", path: :admin_employees_path, match: [ "/admin/employees" ], if: LEAD },
-        { label: "Joining & exits", path: :admin_checklists_path, match: [ "/admin/checklists" ], if: MANAGE },
+        { label: "Joining & exits", path: :admin_checklists_path, match: [ "/admin/checklists" ], if: -> { hr_can?("checklist.manage", scope: :all) } },
         { label: "Awards", path: :admin_awards_path, match: [ "/admin/awards" ], if: LEAD },
         { label: "PIPs", path: :admin_performance_plans_path, match: [ "/admin/performance_plans" ], if: SUPER }
       ] },
@@ -87,7 +89,7 @@ module HrLite
       { label: "Help", tabs: [
         { label: "Policies", path: :policies_path, match: [ "/policies" ], if: -> { hr_can?("policy.view", scope: :all) } },
         { label: "Ask HR", path: :hr_requests_path, match: [ "/hr_requests" ], if: -> { hr_can?("hr_request.raise") } },
-        { label: "Help desk", path: :admin_hr_requests_path, match: [ "/admin/hr_requests" ], if: MANAGE },
+        { 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: "Admin", divider: true, tabs: [
@@ -96,7 +98,7 @@ module HrLite
         { label: "Roles", path: :admin_roles_path, match: [ "/admin/roles" ], if: -> { hr_can?("role.manage", scope: :all) } },
         { label: "Statutory rates", path: :admin_statutory_rate_cards_path, match: [ "/admin/statutory_rate_cards" ], if: SUPER },
         { label: "Reports", path: :admin_reports_path, match: [ "/admin/reports" ], if: -> { hr_can?("expense.approve", scope: :all) || %w[leave.view attendance.view profile.view].any? { |key| hr_can?(key, scope: :team) } } },
-        { label: "Assets", path: :admin_assets_path, match: [ "/admin/assets" ], if: MANAGE },
+        { label: "Assets", path: :admin_assets_path, match: [ "/admin/assets" ], if: -> { hr_can?("asset.manage", scope: :all) } },
         { label: "Audit trail", path: :admin_audit_logs_path, match: [ "/admin/audit_logs" ], if: LEAD }
       ] }
     ].freeze
@@ -164,8 +166,12 @@ module HrLite
       when HrLite::LeaveRequest
         [ "#{record.leave_type.name}, #{record.date_range_label} · #{pluralize(hrl_days(record.days_count), 'day')}", hr_lite.admin_leave_request_path(record) ]
       when HrLite::CompOffRequest then [ "Comp-off for #{record.date_worked.strftime('%a %-d %b')}", hr_lite.admin_comp_off_request_path(record) ]
-      when HrLite::RegularizationRequest then [ "Attendance fix, #{record.date.strftime('%a %-d %b')}", hr_lite.admin_regularization_request_path(record) ]
+      when HrLite::RegularizationRequest then [ "Day fix, #{record.date.strftime('%a %-d %b')}", hr_lite.admin_regularization_request_path(record) ]
       when HrLite::WfhRequest then [ "WFH, #{record.dates_label}", hr_lite.admin_wfh_request_path(record) ]
+      when HrLite::Expense then [ "Claim: #{record.category.name}, #{hrl_money(record.amount)}, #{record.spent_on.strftime('%a %-d %b')}", hr_lite.admin_expenses_path ]
+      when HrLite::Resignation
+        profile = HrLite::EmployeeProfile.find_by(user_id: record.user_id)
+        [ "Resignation, last day #{record.proposed_last_day.strftime('%-d %b %Y')}", profile ? hr_lite.admin_employee_path(profile) : hr_lite.admin_employees_path ]
       else [ tab[:label], hr_lite.public_send(tab[:path]) ]
       end
     end
@@ -300,8 +306,8 @@ module HrLite
     # Status pill for a request lifecycle string — one colour map for every
     # list and show screen.
     def hrl_request_status_badge(status)
-      css = { "approved" => "hrl-badge--ok", "rejected" => "hrl-badge--bad",
-              "cancelled" => "hrl-badge--muted" }[status]
+      css = { "approved" => "hrl-badge--ok", "reimbursed" => "hrl-badge--ok", "verified" => "hrl-badge--ok",
+              "rejected" => "hrl-badge--bad", "cancelled" => "hrl-badge--muted", "draft" => "hrl-badge--muted" }[status]
       content_tag(:span, status.humanize, class: "hrl-badge #{css}")
     end
 

data/app/jobs/hr_lite/attendance_close_job.rb

@@ -58,7 +58,7 @@ module HrLite
         "Fix it yourself by #{(date + rule[:within_days]).strftime('%d %b')} (up to #{rule[:per_week]} a week), " \
           "or raise a ticket for HR."
       else
-        "Raise a regularization ticket to get it fixed."
+        "Use Fix a day to get it fixed."
       end
       Notifications.publish(event, title: title, body: body, path: "/regularization_requests/new?date=#{date.iso8601}",
                                    bell_to: [ user ], email_to: [ user ])

data/app/jobs/hr_lite/payroll_compute_job.rb

@@ -0,0 +1,12 @@
+module HrLite
+  # Compute off the request (PayrollRun#compute_later!). A failure restores
+  # the run's status and lands as a run warning instead of a 500.
+  class PayrollComputeJob < ApplicationJob
+    def perform(run, from, actor)
+      run.compute!(actor: actor, from: from)
+    rescue => e
+      Rails.error.report(e)
+      run.reload.update_columns(warnings: run.warnings | [ "Compute failed (#{e.message.truncate(150)}) — nothing changed; try again." ]) # rubocop:disable Rails/SkipsModelValidations
+    end
+  end
+end

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

@@ -8,6 +8,8 @@ module HrLite
 
     SKIPPED_ATTRIBUTES = %w[updated_at created_at].freeze
     REDACTED = "[changed]".freeze
+    # Personal text stored in the clear: the trail says it changed, never to what.
+    PII_COLUMNS = { "HrLite::EmployeeProfile" => %w[date_of_birth], "HrLite::HrRequest" => %w[subject body] }.freeze
 
     # *_commit, not *_create/_update/_destroy: these callbacks write an audit
     # row and email leadership a diff. Fired inside the transaction they
@@ -40,7 +42,7 @@ module HrLite
     end
 
     def hr_lite_audited_changes(action)
-      encrypted = self.class.try(:encrypted_attributes)&.map(&:to_s) || []
+      encrypted = (self.class.try(:encrypted_attributes)&.map(&:to_s) || []) + PII_COLUMNS.fetch(self.class.name, [])
 
       case action
       when "destroy"

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

@@ -8,6 +8,10 @@ module HrLite
   module EncryptedMoney
     extend ActiveSupport::Concern
 
+    included do
+      validate { @unreadable_money&.each { |attribute| errors.add(attribute, "is not a number") } }
+    end
+
     class_methods do
       def encrypted_money(*attributes)
         attributes.each do |attribute|
@@ -19,11 +23,10 @@ module HrLite
           end
 
           define_method("#{attribute}=") do |value|
-            if value.nil? || (value.respond_to?(:blank?) && value.blank?)
-              super(nil)
-            else
-              super(BigDecimal(value.to_s).round(2).to_s("F"))
-            end
+            digits = value.to_s.gsub(/[,₹\s]/, "") # "1,50,000" and "₹ 1200" are how people type money
+            super(digits.empty? ? nil : BigDecimal(digits).round(2).to_s("F"))
+          rescue ArgumentError
+            (@unreadable_money ||= []) << attribute
           end
         end
       end

data/app/models/hr_lite/attendance_record.rb

@@ -35,6 +35,7 @@ module HrLite
     validates :status, inclusion: { in: STATUSES }
     validates :half_day_part, inclusion: { in: %w[first second] }, allow_blank: true
     validate :check_out_after_check_in
+    validate :times_on_the_day, if: -> { will_save_change_to_date? || will_save_change_to_check_in_at? || will_save_change_to_check_out_at? }
 
     scope :for_date, ->(date) { where(date: date) }
     scope :for_month, ->(month) { where(date: month.beginning_of_month..month.end_of_month) }
@@ -118,5 +119,18 @@ module HrLite
 
       errors.add(:check_out_at, "must be after check-in")
     end
+
+    # No future days; check-out may run into the next morning (night shift).
+    # Only the fields being changed, in the company's zone, so re-saving an old row never fails.
+    def times_on_the_day
+      return unless date
+
+      day = ->(time) { time.in_time_zone(HrLite.config.time_zone).to_date }
+      errors.add(:date, "can't be in the future") if will_save_change_to_date? && date > day.(Time.current)
+      errors.add(:check_in_at, "must be on #{date.strftime('%d %b')}") if will_save_change_to_check_in_at? && check_in_at && day.(check_in_at) != date
+      if will_save_change_to_check_out_at? && check_out_at && !(date..date + 1).cover?(day.(check_out_at))
+        errors.add(:check_out_at, "must be on #{date.strftime('%d %b')} or the next morning")
+      end
+    end
   end
 end

data/app/models/hr_lite/comp_off_request.rb

@@ -50,6 +50,8 @@ module HrLite
         # (A duplicate live request for the same date cannot exist — the
         # partial unique index on [user_id, date_worked] guarantees it.)
         credit_balance!(type)
+        AuditLog.record!(action: "comp_off.approved", subject: self, actor: actor,
+                         changes: { "date_worked" => date_worked.to_s, "days" => credit_days.to_s("F") })
       end
 
       Notifications.publish(

data/app/models/hr_lite/document.rb

@@ -79,7 +79,7 @@ module HrLite
     def default_visibility_from_category
       return if visibility.present?
 
-      self.visibility = SENSITIVE_CATEGORIES.include?(category.to_s) ? "money" : "hr"
+      self.visibility = SENSITIVE_CATEGORIES.include?(category.to_s.downcase.strip) ? "money" : "hr"
     end
 
     def file_is_an_allowed_kind

data/app/models/hr_lite/expense.rb

@@ -39,6 +39,7 @@ module HrLite
     end
 
     def approve!(actor:, note: nil)
+      raise ActiveRecord::RecordInvalid.new(self), "not submitted" unless submitted?
       return record_routed!(actor, note, :approved) if awaiting?(actor)
 
       settle!("approved", actor, note)
@@ -46,6 +47,7 @@ module HrLite
 
     def reject!(actor:, note:)
       raise ArgumentError, "a rejection needs a reason" if note.blank?
+      raise ActiveRecord::RecordInvalid.new(self), "not submitted" unless submitted?
       return record_routed!(actor, note, :rejected) if awaiting?(actor)
 
       settle!("rejected", actor, note)
@@ -90,6 +92,7 @@ module HrLite
 
     def settle!(new_status, actor, note)
       update!(status: new_status, decision_note: note.presence)
+      approval_route.cancel_all! # decided outside the flow: nobody is left waiting to be asked
       Notifications.publish(
         new_status == "approved" ? "expense.approved" : "expense.rejected",
         title: "Your #{category.name} claim was #{new_status}",

data/app/models/hr_lite/hr_request.rb

@@ -30,6 +30,7 @@ module HrLite
     def category_label = self.class.category_label(category)
 
     def assign!(actor:, assignee:)
+      raise ActiveRecord::RecordInvalid.new(self), "already settled" unless open? || in_progress?
       update!(assigned_to_id: assignee.id, status: "in_progress")
       Notifications.publish(
         "hr_request.assigned",
@@ -41,6 +42,7 @@ module HrLite
     end
 
     def resolve!(actor:, resolution:)
+      raise ActiveRecord::RecordInvalid.new(self), "already settled" unless open? || in_progress?
       raise ArgumentError, "a resolution needs an answer" if resolution.blank?
 
       update!(status: "resolved", resolution: resolution, resolved_at: Time.current,

data/app/models/hr_lite/kudo.rb

@@ -33,10 +33,10 @@ module HrLite
       BADGES[badge]
     end
 
-    # Creates mention rows from the message markers (existing users only,
+    # Creates mention rows from the message markers (employees only,
     # giver excluded) and notifies them. Called once, right after create.
     def register_mentions!
-      ids = HrLite::MentionParser.user_ids(message) - [ giver_id ]
+      ids = (HrLite::MentionParser.user_ids(message) - [ giver_id ]) & HrLite.employees.map(&:id)
       users = HrLite.user_klass.where(id: ids)
       users.each { |u| kudo_mentions.create!(user_id: u.id) }
 

data/app/models/hr_lite/leave_request.rb

@@ -5,12 +5,15 @@ module HrLite
     STATUSES = %w[pending approved rejected cancelled].freeze
 
     belongs_to :user, class_name: HrLite.config.user_class
-    belongs_to :leave_type
+    belongs_to :leave_type, optional: true # required below, in words ("must exist" is fixed)
     belongs_to :decided_by, class_name: HrLite.config.user_class, optional: true
     # Set when HR records leave the employee forgot to apply for.
     belongs_to :created_by, class_name: HrLite.config.user_class, optional: true
 
-    validates :start_date, :end_date, presence: true
+    validates :leave_type, presence: { message: "is missing — pick one" }
+    validates :start_date, presence: { message: "is missing — pick the first day" }
+    # With no start the start error says it all (a blank end means one day).
+    validates :end_date, presence: { message: "is missing — pick the last day" }, if: :start_date
     validates :status, inclusion: { in: STATUSES }
     validates :half_day_part, inclusion: { in: %w[first second] }, allow_blank: true
 
@@ -50,7 +53,10 @@ module HrLite
       return 0 if leave_type.unlimited?
       return paid_days ? LeaveDayCounter.count(self) - paid_days : 0 if approved?
 
-      [ LeaveDayCounter.count(self) - covered_by(balance.available(as_of: start_date)), 0 ].max
+      # Pending requests of this type and leave year filed first draw on the same balance (warning only).
+      queued = self.class.pending.where(user_id: user_id, leave_type_id: leave_type_id, id: ...id,
+                                        start_date: LeaveYear.range(LeaveYear.key_for(start_date))).sum(:days_count)
+      [ LeaveDayCounter.count(self) - covered_by(balance.available(as_of: start_date) - queued), 0 ].max
     end
 
     # Unpaid share (0, 0.5 or 1) of `date`: the balance covered the leave's
@@ -113,6 +119,7 @@ module HrLite
         # And nobody should still be asked to decide a request that has been
         # called off — it would sit in their inbox for ever.
         approval_route.cancel_all!
+        flag_computed_runs! if was_approved
       end
 
       Notifications.publish(
@@ -229,6 +236,15 @@ module HrLite
         self.decision_note = note
         save!
         audit!(new_status, actor, note)
+        approval_route.cancel_all! # decided outside the flow too: nobody else is still asked
+        flag_computed_runs! if approved?
+      end
+    end
+
+    # A slip computed before this still pays the old days; a recompute clears the note.
+    def flag_computed_runs!
+      PayrollRun.where(status: "review", period_month: start_date.beginning_of_month..end_date).find_each do |run|
+        run.update!(warnings: run.warnings + [ "#{HrLite.display_name(user)}'s leave (#{date_range_label}) changed after compute — recompute" ])
       end
     end
 
@@ -270,8 +286,8 @@ module HrLite
 
     # Everyone should know a colleague will be away, the moment they apply —
     # bell + email to the whole team (matrix row "leave.team_notice"; hosts can mute either
-    # channel). Deliberately excludes the reason: dates are team-relevant,
-    # the why is not.
+    # channel). Deliberately excludes the reason and the type: dates are
+    # team-relevant, the why is not.
     def notify_team
       return if end_date < Date.current # nobody needs to hear who was out
 
@@ -280,7 +296,7 @@ module HrLite
 
       Notifications.publish(
         "leave.team_notice",
-        title: "#{HrLite.display_name(user)} is on leave — #{leave_type.name} (#{date_range_label})",
+        title: "#{HrLite.display_name(user)} is on leave (#{date_range_label})",
         path: "/team",
         bell_to: team,
         email_to: team
@@ -336,6 +352,9 @@ module HrLite
       clash = self.class.where(user_id: user_id, status: %w[pending approved])
                   .where.not(id: id)
                   .overlapping_range(start_date, end_date)
+      # A first half and a second half of the same day do not overlap.
+      opposite = { "first" => "second", "second" => "first" }[half_day_part]
+      clash = clash.where.not(half_day_part: opposite).or(clash.where(half_day_part: nil)) if opposite
       errors.add(:base, "Leave already overlaps these dates") if clash.exists?
     end
 

data/app/models/hr_lite/payroll_line_item.rb

@@ -20,6 +20,9 @@ module HrLite
     validate :period_is_not_already_paid, on: :create
     # Removing a line from a paid month rewrites a settled payslip just the same.
     before_destroy { throw :abort if paid_month? }
+    # A run already computed for the month still shows the old pay.
+    after_create { flag_stale_run("added") }
+    after_destroy { flag_stale_run("removed") }
 
     scope :for_month, ->(month) { where(period_month: month) }
 
@@ -55,5 +58,10 @@ module HrLite
     end
 
     def paid_month? = SalarySlip.settled.exists?(user_id: user_id, period_month: period_month)
+
+    def flag_stale_run(verb)
+      run = PayrollRun.find_by(period_month: period_month, status: "review")
+      run&.update!(warnings: run.warnings + [ "#{HrLite.display_name(user)}'s #{component.label} was #{verb} after compute — recompute" ])
+    end
   end
 end

data/app/models/hr_lite/payroll_run.rb

@@ -1,7 +1,7 @@
 module HrLite
   # Monthly run lifecycle: draft -> processing -> review -> finalized ->
-  # published (terminal). Compute is synchronous (pure-Ruby math over a
-  # small team; the seam for a background job is one perform_later away).
+  # published (terminal). The page computes through PayrollComputeJob
+  # (compute_later!); compute! itself is synchronous.
   class PayrollRun < ApplicationRecord
     STATUSES = %w[draft processing review finalized published].freeze
 
@@ -12,8 +12,9 @@ module HrLite
     belongs_to :first_approved_by, class_name: HrLite.config.user_class, optional: true
 
     # A run with one of these is not paid on the 3rd without a person looking:
-    # someone missing, a state levying ₹0, or last year's / unverified rates.
-    BLOCKING_WARNING = /\ANo (salary structure|professional-tax slabs)|statutory card/
+    # someone missing, a state levying ₹0, last year's / unverified rates, or
+    # a change after compute ("… after compute — recompute") the slips lack.
+    BLOCKING_WARNING = /\ANo (salary structure|professional-tax slabs)|statutory card|after compute/
 
     validates :period_month, presence: true, uniqueness: true
     validates :status, inclusion: { in: STATUSES }
@@ -37,9 +38,9 @@ module HrLite
     # `processing` is allowed back in so a run stranded there by a killed
     # process (deploy roll, timeout) can be recomputed instead of blocking
     # that month forever.
-    def compute!(actor:)
+    def compute!(actor:, from: status)
       raise_unless %w[draft review processing]
-      previous = status
+      previous = from
 
       begin
         update!(status: "processing")
@@ -61,6 +62,14 @@ module HrLite
       end
     end
 
+    # ~1.2k queries at 54 people: the request only flips the run to processing.
+    def compute_later!(actor:)
+      raise_unless %w[draft review processing]
+      from = status
+      update!(status: "processing")
+      PayrollComputeJob.perform_later(self, from, actor)
+    end
+
     def finalize!(actor:)
       raise_unless %w[review]
       raise ActiveRecord::RecordInvalid.new(self), "no slips" if salary_slips.none?

data/app/models/hr_lite/regularization_request.rb

@@ -135,7 +135,7 @@ module HrLite
       transition!("cancelled", actor, nil)
       Notifications.publish(
         "regularization.cancelled",
-        title: "#{HrLite.display_name(user)} cancelled a regularization ticket (#{date.strftime('%d %b')})",
+        title: "#{HrLite.display_name(user)} cancelled a day fix request (#{date.strftime('%d %b')})",
         path: "/admin/regularization_requests",
         bell_to: HrLite.admin_users
       )
@@ -220,7 +220,7 @@ module HrLite
     def notify_requested
       Notifications.publish(
         "regularization.requested",
-        title: "#{HrLite.display_name(user)} raised a regularization ticket for #{date.strftime('%d %b')} " \
+        title: "#{HrLite.display_name(user)} asked to fix #{date.strftime('%d %b')} " \
                "(#{times_label})",
         body: reason.presence,
         path: "/admin/regularization_requests/#{id}",

data/app/models/hr_lite/resignation.rb

@@ -20,6 +20,7 @@ module HrLite
     STATUSES.each { |s| define_method("#{s}?") { status == s } }
 
     after_create :notify_submitted
+    after_create { audit!("submitted", user) }
 
     def accept!(actor:, last_day: nil, note: nil)
       raise ActiveRecord::RecordInvalid.new(self), "not pending" unless pending?
@@ -34,6 +35,7 @@ module HrLite
         # nothing was stamped, because the screen used to claim it was.
         @exit_date_recorded = profile.present?
         profile&.update!(date_of_exit: final_day)
+        audit!("accepted", actor)
       end
 
       # Notice periods are the normal case, so access is revoked here only
@@ -55,7 +57,7 @@ module HrLite
     def withdraw!(actor:)
       raise ActiveRecord::RecordInvalid.new(self), "not pending" unless pending? && actor.id == user_id
 
-      update!(status: "withdrawn", decided_at: Time.current)
+      transaction { update!(status: "withdrawn", decided_at: Time.current) && audit!("withdrawn", actor) }
       Notifications.publish(
         "resignation.withdrawn",
         title: "#{HrLite.display_name(user)} withdrew their resignation",
@@ -72,6 +74,8 @@ module HrLite
 
     private
 
+    def audit!(action, actor) = AuditLog.record!(action: "resignation.#{action}", subject: self, actor: actor, changes: { "last_day" => proposed_last_day.to_s })
+
     # Best-effort, like every other call of this hook: a host that cannot
     # revoke must not roll back an accepted resignation.
     def revoke_access!

data/app/models/hr_lite/role.rb

@@ -36,12 +36,17 @@ module HrLite
     # permission being taken away, not one left alone.
     def replace_grants!(grants)
       transaction do
+        before = grant_map
         role_grants.destroy_all
         grants.each do |key, scope|
           next if scope.blank? || scope.to_s == "none"
 
           role_grants.create!(permission_key: Permissions.validate!(key), scope: scope.to_s)
         end
+        role_grants.reload
+        after = grant_map
+        changed = (before.keys | after.keys).reject { |key| before[key] == after[key] }
+        AuditLog.record!(action: "role.grants_changed", subject: self, changes: changed.to_h { |key| [ key, [ before[key], after[key] ] ] }) if changed.any?
       end
       reload
     end

data/app/models/hr_lite/salary_slip.rb

@@ -63,7 +63,7 @@ module HrLite
 
     # Bump the version when the PDF template changes, or the old layout serves until the cache expires.
     def pdf_cache_key
-      [ "hr_lite_slip_v2", id, updated_at.to_i, payroll_run.status,
+      [ "hr_lite_slip_v3", id, updated_at.to_i, payroll_run.status,
         user_profile&.updated_at.to_i ].join("/")
     end
 

data/app/models/hr_lite/tax_declaration.rb

@@ -86,6 +86,11 @@ module HrLite
 
     def verify!(actor:, note: nil)
       raise ActiveRecord::RecordInvalid.new(self), "not submitted" unless submitted?
+      # A blank verified amount would count as ₹0 allowed once verified.
+      if tax_declaration_items.any? { |item| item.verified_amount.nil? }
+        errors.add(:base, "Every line needs a verified amount — enter 0 where the proof supports nothing")
+        raise ActiveRecord::RecordInvalid, self
+      end
 
       update!(status: "verified", verified_by_id: actor.id, verified_at: Time.current,
               note: note.presence)

data/app/services/hr_lite/attendance_puncher.rb

@@ -247,6 +247,10 @@ module HrLite
     # Late ladder against slot + buffer; after 11:00 also +1h on the next two
     # working days; after 11:30 the day is a half day. The buffer shifts all three.
     def apply_slot_rules(record)
+      # No slot to be late for on a weekly off, a holiday, or leave that starts the day (full or first half).
+      return unless WorkingCalendar.for_user(@user.id, record.date..record.date).working_day?(record.date)
+      return if LeaveRequest.active_on(record.date).where(user_id: @user.id, half_day_part: [ nil, "", "first" ]).exists?
+
       local = record.check_in_at.in_time_zone(HrLite.config.time_zone)
       arrived = local.hour * 60 + local.min - EmployeeProfile.where(user_id: @user.id).pick(:buffer_minutes).to_i
       late = AttendanceSlot.penalty_minutes(arrived - AttendanceSlot.start_minute_for(@user.id, record.date))

data/app/services/hr_lite/overview_query.rb

@@ -17,17 +17,6 @@ module HrLite
       reach(LeaveRequest.active_on(@date).includes(:leave_type, :user).order(:start_date))
     end
 
-    # Comp-off and regularization are approvals too. Counting leave alone made
-    # the board announce "All present and accounted for" while both queues
-    # still had work in them.
-    def pending_comp_offs
-      reach(CompOffRequest.pending.includes(:user).recent_first)
-    end
-
-    def pending_regularizations
-      reach(RegularizationRequest.pending.includes(:user).recent_first)
-    end
-
     def flagged_today
       reach(AttendanceRecord.for_date(@date).flagged.includes(:user))
     end
@@ -41,7 +30,6 @@ module HrLite
 
     def kpis
       {
-        pending: pending_requests.count + pending_comp_offs.count + pending_regularizations.count,
         on_leave: on_leave_today.count,
         flagged: flagged_today.count,
         missing_checkout: missing_checkout_yesterday.count

data/app/services/hr_lite/work_status.rb

@@ -16,8 +16,11 @@ module HrLite
     def self.for(user_id, at: Time.current) = for_users([ user_id ], at: at)[user_id]
 
     # When an open Busy or Meeting ends, or nil when the person is reachable.
-    def self.do_not_disturb_until(user_id, at: Time.current)
-      WorkModeEvent.open.overlay.where(user_id: user_id, mode: %w[busy meeting]).where("ends_at > ?", at).maximum(:ends_at)
+    def self.do_not_disturb_until(user_id, at: Time.current) = do_not_disturb_for([ user_id ], at: at)[user_id]
+
+    # The same for many people in one query: { user_id => ends_at }, reachable people absent.
+    def self.do_not_disturb_for(user_ids, at: Time.current)
+      WorkModeEvent.open.overlay.where(user_id: user_ids, mode: %w[busy meeting]).where("ends_at > ?", at).group(:user_id).maximum(:ends_at)
     end
 
     def self.for_users(user_ids, at: Time.current)

data/app/views/hr_lite/admin/assets/index.html.erb

@@ -22,6 +22,9 @@
 <% end %>
 
 <section class="hrl-card">
+  <% if @assets.empty? %>
+    <p class="hrl-muted">No assets recorded yet. Add the first one above.</p>
+  <% else %>
   <div class="hrl-table-wrap">
     <table class="hrl-table hrl-table--stack">
       <thead><tr><th>Asset</th><th>Status</th><th>With</th><th></th></tr></thead>
@@ -39,13 +42,16 @@
             <td data-label="">
               <% if asset.assigned? %>
                 <%= form_with url: hr_lite.take_back_admin_asset_path(asset), method: :post do %>
-                  <%= text_field_tag :condition_note, nil, placeholder: "Condition", class: "hrl-input" %>
+                  <%= label_tag "asset-condition-#{asset.id}", "Condition on return", class: "hrl-sr-only" %>
+                  <%= text_field_tag :condition_note, nil, id: "asset-condition-#{asset.id}", placeholder: "Condition on return", class: "hrl-input" %>
                   <%= submit_tag "Take back", class: "hrl-btn" %>
                 <% end %>
               <% elsif asset.available? %>
                 <%= form_with url: hr_lite.assign_admin_asset_path(asset), method: :post do %>
+                  <%= label_tag "asset-holder-#{asset.id}", "Hand over to", class: "hrl-sr-only" %>
                   <%= select_tag :user_id,
-                        options_for_select(HrLite.employees.map { |u| [ hr_display_name(u), u.id ] }), class: "hrl-input",
+                        options_for_select(HrLite.employees.map { |u| [ hr_display_name(u), u.id ] }), id: "asset-holder-#{asset.id}",
+                        include_blank: "Choose…", required: true, class: "hrl-input",
                         data: { hrl_filter: "Type a name to filter" } %>
                   <%= submit_tag "Hand over", class: "hrl-btn" %>
                 <% end %>
@@ -56,5 +62,6 @@
       </tbody>
     </table>
   </div>
+  <% end %>
   <%= hrl_pagination %>
 </section>

data/app/views/hr_lite/admin/attendances/show.html.erb

@@ -1,5 +1,6 @@
 <% content_for(:page_title) { "Attendance — #{hr_display_name(@employee)}" } %>
 <% content_for(:tabrow) { render "hr_lite/shared/person_tabs", user: @employee } %>
+<% content_for(:back, "Team") %>
 <div class="hrl-page__head">
   <h1 class="hrl-page__title"><%= hr_display_name(@employee) %></h1>
   <div class="hrl-page__actions">
@@ -33,6 +34,7 @@
 <% if @punches.any? %>
   <section class="hrl-card">
     <h2 class="hrl-card__title">Where they punched</h2>
+    <% all_punches = HrLite::AttendancePunch.where(user_id: @employee.id, date: @punches.map(&:date)).order(:at, :id).group_by(&:date) # one query, not one a day %>
     <% @punches.each do |record| %>
       <div class="hrl-feed__item hrl-small">
         <div class="hrl-feed__body">
@@ -47,7 +49,7 @@
               <% end %>
             </div>
           <% end %>
-          <% if record.check_in_place %><%= render "hr_lite/attendance/trail", record: record %><% end %>
+          <% if record.check_in_place %><%= render "hr_lite/attendance/trail", record: record, punches: all_punches.fetch(record.date, []) %><% end %>
           <% if (gap = record.punch_gap_m) %>
             <div class="<%= gap > HrLite::AttendanceRecord::PUNCH_GAP_ALERT_M ? "hrl-badge hrl-badge--warn" : "hrl-muted" %>"><%= (gap / 1000.0).round(1) %> km apart</div>
           <% end %>

data/app/views/hr_lite/admin/attendances/summary.html.erb

@@ -25,14 +25,17 @@
   <% end %>
 </section>
 
+<% fixes_pending = HrLite::RegularizationRequest.pending.where(user_id: @employee.id, date: @period.from..@period.to).pluck(:date) %>
 <section class="hrl-card">
   <h2 class="hrl-card__title">Days</h2>
   <% (@period.from..@period.to).each do |date| %>
-    <% day = @days.for(date); rec = day.record; punches = @punches[date].to_a %>
+    <% day = @days.for(date); rec = day.record; punches = @punches[date].to_a
+       not_in_yet = date == Date.current && day.kind == :absent # the day is not over %>
     <div class="hrl-feed__item hrl-row">
       <div class="hrl-feed__body hrl-small">
         <strong><%= date.strftime("%a %-d %b") %></strong>
-        <span class="hrl-badge <%= tones[day.kind] %>"><%= HrLite::ApplicationHelper::DAY_STATES[day.kind][1] %></span>
+        <span class="hrl-badge <%= not_in_yet ? "hrl-badge--muted" : tones[day.kind] %>"><%= not_in_yet ? "Not in yet" : HrLite::ApplicationHelper::DAY_STATES[day.kind][1] %></span>
+        <% if fixes_pending.include?(date) %><span class="hrl-badge hrl-badge--warn">Fix pending</span><% end %>
         <% if @profile&.hours_allowance_minutes && (length = HrLite::EmployeeProfile.day_minutes_for(@employee.id, on: date)) < HrLite::Setting.instance.day_minutes %>
           <span class="hrl-badge hrl-badge--muted">Day <%= hrl_duration(length * 60) %></span>
         <% end %>