hr_lite 0.15.0 → 0.18.0

data/app/helpers/hr_lite/application_helper.rb

@@ -11,7 +11,8 @@ module HrLite
       # belongs in "More" rather than displacing something everybody uses.
       # Employee tier all the same — holding an approval IS the authorisation,
       # so a manager and a stand-in covering for one reach the same screen.
-      { label: "Approvals",  path: :approvals_path,      match: [ "/approvals" ] },
+      { label: "Approvals",  path: :approvals_path,      match: [ "/approvals" ],
+        if: -> { HrLite::ApprovalFlow.where(active: true).exists? } },
       { label: "Expenses",   path: :expenses_path,       match: [ "/expenses" ] },
       { label: "Benefits",   path: :benefits_path,       match: [ "/benefits" ] },
       { label: "Policies",   path: :policies_path,       match: [ "/policies" ] },
@@ -19,8 +20,10 @@ module HrLite
       { label: "Org",        path: :org_path,            match: [ "/org" ] },
       { label: "Kudos",      path: :kudos_path,          match: [ "/kudos" ] },
       { label: "Slips",      path: :salary_slips_path,   match: [ "/salary_slips" ] },
-      { label: "Career",     path: :career_path,         match: [ "/career", "/appraisals", "/profile" ] },
+      { label: "Career",     path: :career_path,         match: [ "/career", "/appraisals" ] },
+      { label: "Profile",    path: :employee_profile_path, match: [ "/profile", "/resignation" ] },
       { label: "Documents",  path: :documents_path,      match: [ "/documents" ] },
+      { label: "ID card",    path: :id_card_path,        match: [ "/id_card" ] },
       { label: "Tax",        path: :tax_declaration_path, match: [ "/tax_declaration" ] },
       { label: "Loans",      path: :loans_path,          match: [ "/loans" ] }
     ].freeze
@@ -30,16 +33,19 @@ module HrLite
       { label: "Team attendance", path: :admin_attendances_path,     match: [ "/admin/attendances" ] },
       { label: "Approvals",       path: :admin_leave_requests_path,  match: [ "/admin/leave_requests", "/admin/leave_balances", "/admin/comp_off_requests", "/admin/regularization_requests" ] },
       { label: "Reports",         path: :admin_reports_path,         match: [ "/admin/reports" ] },
-      { label: "Claims",          path: :admin_expenses_path,        match: [ "/admin/expenses" ] },
+      { label: "Claims",          path: :admin_expenses_path,        match: [ "/admin/expenses" ],
+        if: -> { hr_can?("expense.approve", scope: :team) } },
       { label: "Help desk",       path: :admin_hr_requests_path,     match: [ "/admin/hr_requests" ] },
       { label: "Assets",          path: :admin_assets_path,          match: [ "/admin/assets" ] },
+      { label: "Benefits",        path: :admin_benefits_path,        match: [ "/admin/benefits" ] },
       { label: "Joining & exits", path: :admin_checklists_path,      match: [ "/admin/checklists" ] }
     ].freeze
 
     LEADERSHIP_NAV_ITEMS = [
       { label: "Employees", path: :admin_employees_path,        match: [ "/admin/employees" ] },
-      { label: "Settings",  path: :admin_leave_types_path,      match: [ "/admin/leave_types", "/admin/office_locations", "/admin/holidays", "/admin/setting" ] },
+      { label: "Settings",  path: :admin_leave_types_path,      match: [ "/admin/leave_types", "/admin/office_locations", "/admin/holidays", "/admin/setting", "/admin/expense_categories" ] },
       { label: "Audit",     path: :admin_audit_logs_path,       match: [ "/admin/audit_logs" ] },
+      { label: "Policies",  path: :admin_policies_path,         match: [ "/admin/policies" ] },
       { label: "Documents", path: :admin_documents_path,        match: [ "/admin/documents" ] }
     ].freeze
 
@@ -54,9 +60,18 @@ module HrLite
       { label: "Loans",   path: :admin_loans_path,        match: [ "/admin/loans" ] }
     ].freeze
 
-    # Only items whose routes exist yet (the nav grows with each phase).
+    # The ID card's QR: office address and phone as plain text, so any phone
+    # camera shows who to call about a found card. No URL, nothing to host.
+    def hrl_office_qr_svg(company, brand)
+      text = [ brand, company[:address], company[:phone] ].compact_blank.join("\n")
+      RQRCode::QRCode.new(text).as_svg(use_path: true, viewbox: true, color: "0F172A").html_safe
+    end
+
+    # Only items whose routes exist yet (the nav grows with each phase), and
+    # whose optional `if:` holds — a link that always lands on "access
+    # denied" or an empty page is worse than no link.
     def hrl_nav_items(items)
-      items.select { |item| hr_lite_route?(item[:path]) }
+      items.select { |item| hr_lite_route?(item[:path]) && (item[:if].nil? || instance_exec(&item[:if])) }
     end
 
     def hr_lite_route?(helper_name)

data/app/jobs/hr_lite/payroll_auto_draft_job.rb

@@ -1,7 +1,7 @@
 module HrLite
   # Monthly automation: on the 1st, draft + compute the previous month's
-  # payroll from attendance and the policy, then tell leadership it is
-  # waiting for review. Publishing stays a deliberate human action —
+  # payroll from attendance and the policy, then tell whoever runs payroll
+  # (payroll.manage) it is waiting for review — leadership cannot open it. Publishing stays a deliberate human action —
   # the system prepares, people approve.
   class PayrollAutoDraftJob < ApplicationJob
     queue_as :default
@@ -16,10 +16,11 @@ module HrLite
       return unless run.draft? && run.salary_slips.none?
 
       run.compute!(actor: nil)
+      payroll = HrLite.users_holding("payroll.manage", scope: :all).to_a
       Notifications.publish(
         "payroll.draft_ready",
         title: "Payroll #{run.label} computed from attendance — #{run.salary_slips.count} slips await review",
-        path: "/admin/payroll_runs/#{run.id}"
+        path: "/admin/payroll_runs/#{run.id}", bell_to: payroll, email_to: payroll
       )
     end
   end

data/app/jobs/hr_lite/slips_ready_job.rb

@@ -0,0 +1,10 @@
+module HrLite
+  # Tells employees their slip is ready on config.slip_release_day, when
+  # SalarySlip.released first lets them open it. Enqueued by
+  # PayrollRun#publish!, which already sent the leadership copy.
+  class SlipsReadyJob < ApplicationJob
+    def perform(run)
+      run.notify_slips_ready(leadership: false)
+    end
+  end
+end

data/app/models/hr_lite/audit_log.rb

@@ -14,7 +14,7 @@ module HrLite
     # leadership audit screen or the policy.changed email.
     MONEY_TIER_TYPES = %w[
       HrLite::Appraisal HrLite::DesignationChange HrLite::SalaryStructure
-      HrLite::PayrollRun HrLite::SalarySlip
+      HrLite::PayrollRun HrLite::SalarySlip HrLite::PayrollLineItem
     ].freeze
 
     scope :recent, -> { order(created_at: :desc) }

data/app/models/hr_lite/benefit_enrolment.rb

@@ -9,7 +9,7 @@ module HrLite
     belongs_to :user, class_name: HrLite.config.user_class
 
     validates :enrolled_on, presence: true
-    validates :user_id, uniqueness: { scope: :benefit_id }
+    validates :user_id, uniqueness: { scope: :benefit_id, message: "is already enrolled" }
     validates :dependants, numericality: { greater_than_or_equal_to: 0 }
     validate :ended_after_it_started
 

data/app/models/hr_lite/employee_profile.rb

@@ -13,7 +13,7 @@ module HrLite
     # profiles as roots (founders/directors).
     belongs_to :manager, class_name: HrLite.config.user_class, optional: true
 
-    encrypts :pan_number, :pf_uan, :esi_number, :bank_account_number, :bank_ifsc
+    encrypts :pan_number, :pf_uan, :esi_number, :bank_account_number, :bank_ifsc, :blood_group, :emergency_contact
     # fy_opening_*: income already paid this financial year that this install
     # did not run — a previous employer, or the months before payroll was
     # switched on here. Feeds the TDS projection so a mid-year start does not
@@ -21,12 +21,21 @@ module HrLite
     encrypted_money :declared_annual_deductions, :fy_opening_gross, :fy_opening_tds
 
     TAX_REGIMES = %w[new old].freeze
+    BLOOD_GROUPS = %w[A+ A- B+ B- AB+ AB- O+ O-].freeze
+    # The ID-card photo. Images a browser can print; content-sniffed like
+    # Document, so the check is on the real bytes.
+    PHOTO_TYPES = %w[image/jpeg image/png image/webp].freeze
+    PHOTO_MAX_BYTES = 5.megabytes
+
+    has_one_attached :photo
 
     # Onboarding-form virtuals (the controller hands them to
     # config.onboard_user; never persisted, never audited).
     attr_accessor :new_user_name, :new_user_email, :new_user_password
 
     before_validation :assign_employee_code, on: :create
+    # Without a role a new hire cannot see policies or raise an HR request.
+    after_create { (role = Role.find_by(name: Role::EMPLOYEE)) && RoleAssignment.find_or_create_by!(user_id:, role:) }
 
     validates :employee_code, presence: true, uniqueness: true
     validates :user_id, uniqueness: true
@@ -37,6 +46,8 @@ module HrLite
     validates :bank_ifsc, format: { with: /\A[A-Z]{4}0[A-Z0-9]{6}\z/, message: "is not a valid IFSC" },
                           allow_blank: true
     validates :pf_uan, format: { with: /\A\d{12}\z/, message: "must be 12 digits" }, allow_blank: true
+    validates :blood_group, inclusion: { in: BLOOD_GROUPS }, allow_blank: true
+    validate :photo_is_a_small_image
     validate :exit_after_joining
     validate :manager_chain_acyclic
     validate :manager_is_active_staff, if: :manager_id_changed?
@@ -97,7 +108,7 @@ module HrLite
     private
 
     # Codes are system-assigned: Settings prefix + zero-padded next number
-    # (EMP001, EMP002, ...). Scans the highest existing suffix for the
+    # (ESA-000001, ESA-000002, ...). Scans the highest existing suffix for the
     # CURRENT prefix so changing the prefix restarts a fresh sequence
     # without colliding with history.
     def assign_employee_code
@@ -108,7 +119,7 @@ module HrLite
                  .pluck(:employee_code)
                  .filter_map { |code| code.delete_prefix(prefix)[/\A\d+\z/]&.to_i }
                  .max || 0
-      self.employee_code = format("%s%03d", prefix, last + 1)
+      self.employee_code = format("%s%06d", prefix, last + 1)
     end
 
     def sanitize_sql_like(value)
@@ -140,6 +151,13 @@ module HrLite
       end
     end
 
+    def photo_is_a_small_image
+      return unless photo.attached?
+      return errors.add(:photo, "must be a JPG, PNG or WebP image") unless PHOTO_TYPES.include?(photo.blob.content_type)
+
+      errors.add(:photo, "must be under #{PHOTO_MAX_BYTES / 1.megabyte} MB") if photo.blob.byte_size > PHOTO_MAX_BYTES
+    end
+
     def mask_middle(value)
       return nil if value.blank?
       return "•" * value.length if value.length <= 4

data/app/models/hr_lite/hr_request.rb

@@ -8,7 +8,7 @@ module HrLite
 
     CATEGORIES = %w[
       salary_certificate employment_certificate address_change bank_change
-      document_request payroll_query tax_query insurance_query policy_query other
+      document_request payroll_query tax_query insurance_query policy_query id_card other
     ].freeze
 
     belongs_to :user, class_name: HrLite.config.user_class
@@ -17,6 +17,7 @@ module HrLite
     validates :subject, presence: true
     validates :category, inclusion: { in: CATEGORIES }
     validates :status, inclusion: { in: STATUSES }
+    validate :id_card_can_be_printed, on: :create, if: -> { category == "id_card" }
 
     scope :open_requests, -> { where(status: %w[open in_progress]) }
     scope :recent_first, -> { order(created_at: :desc) }
@@ -25,7 +26,7 @@ module HrLite
 
     after_create_commit :notify_desk
 
-    def category_label = category.humanize
+    def category_label = category.humanize.sub(/\AId\b/, "ID")
 
     def assign!(actor:, assignee:)
       update!(assigned_to_id: assignee.id, status: "in_progress")
@@ -68,8 +69,16 @@ module HrLite
       Notifications.publish(
         "hr_request.raised",
         title: "#{HrLite.display_name(user)} asked: #{subject}",
-        body: body.presence, path: "/admin/hr_requests/#{id}", bell_to: desk
+        body: body.presence, path: "/admin/hr_requests/#{id}", bell_to: desk, email_to: desk
       )
     end
+
+    def id_card_can_be_printed
+      if !EmployeeProfile.find_by(user_id: user_id)&.photo&.attached?
+        errors.add(:base, "Add your photo to the ID card first")
+      elsif self.class.open_requests.exists?(user_id: user_id, category: "id_card")
+        errors.add(:base, "Your ID card print is already requested")
+      end
+    end
   end
 end

data/app/models/hr_lite/leave_balance.rb

@@ -63,7 +63,8 @@ module HrLite
       # each — and the admin balances grid reads this cell for every employee
       # times every leave type.
       calendar = WorkingCalendar.new(range)
-      requests.sum { |request| LeaveDayCounter.count(request, calendar: calendar) }
+      # Loss-of-pay days (beyond paid_days) never drew on the balance.
+      requests.sum { |request| [ LeaveDayCounter.count(request, calendar: calendar), request.paid_days ].compact.min }
     end
 
     def available(as_of: Date.current)

data/app/models/hr_lite/leave_request.rb

@@ -7,6 +7,8 @@ module HrLite
     belongs_to :user, class_name: HrLite.config.user_class
     belongs_to :leave_type
     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 :status, inclusion: { in: STATUSES }
@@ -22,7 +24,7 @@ module HrLite
     end
 
     before_validation :cache_days_count, on: :create
-    after_create :notify_requested
+    after_create :notify_requested, unless: :recorded_by_hr?
 
     scope :pending, -> { where(status: "pending") }
     scope :approved, -> { where(status: "approved") }
@@ -38,6 +40,26 @@ module HrLite
       leave_type.paid
     end
 
+    # Days this request would take past the balance — the loss of pay
+    # approving it today would fix, or did fix once approved. 0 for unlimited types.
+    def days_beyond_balance
+      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
+    end
+
+    # Unpaid share (0, 0.5 or 1) of `date`: the balance covered the leave's
+    # EARLIEST working days (paid_days of them), so the rest are loss of pay.
+    def unpaid_on(date)
+      return 0 if paid_days.nil?
+
+      @leave_calendar ||= WorkingCalendar.new(start_date..end_date)
+      through = LeaveDayCounter.count_range(start_date: start_date, end_date: date, half_day: half_day,
+                                            calendar: @leave_calendar)
+      (through - paid_days).clamp(0, half_day ? BigDecimal("0.5") : 1)
+    end
+
     # --- transitions -------------------------------------------------------
 
     # With a flow configured this is ONE RUNG: the request becomes `approved`
@@ -45,9 +67,10 @@ module HrLite
     # the flow is not waiting on, such as HR overriding — the first approval
     # settles it, exactly as before.
     #
-    # Returns false (leaving the request pending) when the balance no longer
-    # covers it; the re-check runs inside the row lock so two concurrent
-    # approvals cannot overdraw one balance.
+    # Days beyond the balance are approved as loss of pay (paid_days); only
+    # comp-off returns false (still pending) when its credit no longer covers
+    # it. The balance is read inside the row lock, so two concurrent
+    # approvals cannot both spend it.
     def approve!(actor:, note: nil)
       return record_routed_decision!(actor, note, :approved) if awaiting?(actor)
 
@@ -130,15 +153,20 @@ module HrLite
     def approve_outright!(actor:, note:)
       insufficient = false
       transition!("approved", actor, note) do
+        next if leave_type.unlimited?
+
         # Serialize on the BALANCE row. `transition!`'s own lock is on this
         # request, and two pending requests are two different rows — so both
         # approvals could read the same untouched balance and overdraw it.
-        LeaveBalance.lock_for(user, leave_type, LeaveYear.key_for(start_date)) unless leave_type.unlimited?
+        # As of start_date: the same date the create-time check uses.
+        covered = covered_by(LeaveBalance.lock_for(user, leave_type, LeaveYear.key_for(start_date)).available(as_of: start_date))
+        next if LeaveDayCounter.count(self) <= covered
 
-        if insufficient_balance_now?
+        if leave_type.comp_off
           insufficient = true
           raise ActiveRecord::Rollback
         end
+        self.paid_days = covered
       end
       return false if insufficient
 
@@ -193,21 +221,20 @@ module HrLite
           "type" => leave_type.code,
           "dates" => date_range_label,
           "days" => days_count&.to_s("F"),
+          "paid_days" => paid_days&.to_s("F"),
           "note" => note.presence
         }.compact
       )
     end
 
-    # This request is still pending here, so balance.used excludes it:
-    # approving is valid iff the request fits the remaining balance.
-    def insufficient_balance_now?
-      return false if leave_type.unlimited?
+    def recorded_by_hr? = created_by_id.present? && created_by_id != user_id
 
-      # Same as-of date the create-time check used. Reading it as of TODAY
-      # meant a request validated against the balance it would have on the
-      # leave dates could never be approved on a monthly-accrual type.
-      LeaveDayCounter.count(self) > balance.available(as_of: start_date)
-    end
+    # The balance covers whole half-days only, never less than nothing.
+    def covered_by(available) = [ (BigDecimal(available.to_s) * 2).floor / BigDecimal(2), 0 ].max
+
+    # Recorded leave is approved in the same transaction, so there is nothing
+    # left for a flow to route.
+    def open_approval_route = pending? && super
 
     def notify_requested
       Notifications.publish(
@@ -215,7 +242,8 @@ module HrLite
         title: "#{HrLite.display_name(user)} applied for #{leave_type.name} (#{date_range_label})",
         body: reason.presence,
         path: "/admin/leave_requests/#{id}",
-        bell_to: HrLite.admin_users
+        bell_to: HrLite.admin_users,
+        email_to: HrLite.admin_users
       )
     end
 
@@ -224,6 +252,8 @@ module HrLite
     # channel). Deliberately excludes the reason: dates are team-relevant,
     # the why is not.
     def notify_team
+      return if end_date < Date.current # nobody needs to hear who was out
+
       team = HrLite.active_employees.reject { |member| member.id == user_id }
       return if team.empty?
 
@@ -285,7 +315,7 @@ module HrLite
       clash = self.class.where(user_id: user_id, status: %w[pending approved])
                   .where.not(id: id)
                   .overlapping_range(start_date, end_date)
-      errors.add(:base, "You already have leave overlapping these dates") if clash.exists?
+      errors.add(:base, "Leave already overlaps these dates") if clash.exists?
     end
 
     # A full-day leave over a day that already has a check-in makes no
@@ -296,12 +326,14 @@ module HrLite
 
       punched = AttendanceRecord.where(user_id: user_id, date: start_date..end_date)
                                 .where.not(check_in_at: nil)
-      errors.add(:base, "You have marked attendance in this period") if punched.exists?
+      errors.add(:base, "Attendance is marked in this period") if punched.exists?
     end
 
+    # Only comp-off is refused past its balance: it is earned credit, never
+    # borrowed. Any other type's excess becomes loss of pay at approval.
     def sufficient_balance
       return unless start_date && end_date && leave_type
-      return if leave_type.unlimited? || errors.any?
+      return if leave_type.unlimited? || !leave_type.comp_off || errors.any?
 
       if LeaveDayCounter.count(self) > balance.available(as_of: start_date)
         errors.add(:base, "Not enough #{leave_type.name} balance")

data/app/models/hr_lite/payroll_line_item.rb

@@ -18,6 +18,8 @@ module HrLite
     validate :period_is_first_of_month
     validate :amount_is_positive
     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? }
 
     scope :for_month, ->(month) { where(period_month: month) }
 
@@ -47,11 +49,11 @@ module HrLite
     # TDS projector reads.
     def period_is_not_already_paid
       return if user_id.nil? || period_month.nil?
-
-      settled = SalarySlip.settled.exists?(user_id: user_id, period_month: period_month)
-      return unless settled
+      return unless paid_month?
 
       errors.add(:period_month, "has already been paid — put this on the next open month")
     end
+
+    def paid_month? = SalarySlip.settled.exists?(user_id: user_id, period_month: period_month)
   end
 end

data/app/models/hr_lite/payroll_run.rb

@@ -96,7 +96,23 @@ module HrLite
         audit!("payroll.published", actor, "slips" => salary_slips.count)
       end
 
-      slips = salary_slips.includes(:user).to_a
+      # config.slip_release_day holds the employee notice until the slip opens
+      # (SalarySlip.released); leadership still hears at publish.
+      day = HrLite.config.slip_release_day
+      release_at = day && period_month.next_month.change(day: day).in_time_zone(HrLite.config.time_zone)
+      if release_at&.future?
+        notify_slips_ready(employees: false)
+        SlipsReadyJob.set(wait_until: release_at).perform_later(self)
+      else
+        notify_slips_ready
+      end
+      true
+    end
+
+    # "Your salary slip is ready". SlipsReadyJob sends the employee half on
+    # the release day, without repeating the leadership copy.
+    def notify_slips_ready(employees: true, leadership: true)
+      slips = employees ? salary_slips.includes(:user).to_a : []
       # Everyone is emailed — a final settlement matters most to the person who
       # has left — but a bell is only useful to someone who can still sign in,
       # and offboarding revokes that. Sending one pointed at a page they cannot
@@ -111,9 +127,9 @@ module HrLite
         body: "Open Earthly HR to view or download it.",
         path: "/salary_slips",
         bell_to: slips.reject { |slip| exited.include?(slip.user_id) }.map(&:user),
-        email_to: slips.map(&:user)
+        email_to: slips.map(&:user),
+        skip_leadership: !leadership
       )
-      true
     end
 
     # Ruby-side aggregates (amounts are encrypted — no SQL sums).

data/app/models/hr_lite/policy.rb

@@ -12,6 +12,8 @@ module HrLite
     validates :effective_from, presence: true
     validates :version, numericality: { greater_than: 0 }
 
+    after_create_commit :announce, if: :published?
+
     scope :published, -> { where(published: true) }
     scope :live_on, ->(date) { published.where(effective_from: ..date) }
     scope :newest_first, -> { order(effective_from: :desc, version: :desc) }
@@ -34,6 +36,8 @@ module HrLite
       )
     end
 
+    def announcement? = !acknowledgement_required
+
     def acknowledged_by?(user)
       policy_acknowledgements.exists?(user_id: user.id)
     end
@@ -55,5 +59,16 @@ module HrLite
     rescue ActiveRecord::RecordNotUnique
       policy_acknowledgements.find_by!(user_id: user.id)
     end
+
+    private
+
+    def announce
+      staff = HrLite.active_employees
+      Notifications.publish(
+        "policy.published",
+        title: "#{announcement? ? 'Announcement' : 'Policy'}: #{title}#{' (please read and acknowledge)' unless announcement?}",
+        body: body.truncate(300), path: "/policies/#{id}", bell_to: staff, email_to: staff
+      )
+    end
   end
 end

data/app/models/hr_lite/salary_slip.rb

@@ -18,6 +18,12 @@ module HrLite
     before_save :ensure_run_editable
 
     scope :published, -> { joins(:payroll_run).where(hr_lite_payroll_runs: { status: "published" }) }
+    # What an employee may open: published, and with config.slip_release_day
+    # only from that day of the next month (day 10: October's slip on 10 Nov).
+    scope :released, ->(on: Date.current) {
+      day = HrLite.config.slip_release_day
+      day ? published.where(period_month: ..(on - (day - 1)).beginning_of_month.prev_month) : published
+    }
     # What counts as already paid for tax-to-date. A finalized run is money
     # already decided; waiting for publication made the next month's TDS
     # projection read those earnings as zero.

data/app/models/hr_lite/setting.rb

@@ -7,7 +7,7 @@ module HrLite
 
     validates :weekend_policy, inclusion: { in: WEEKEND_POLICIES }
     validates :employee_code_prefix, presence: true,
-                                     format: { with: /\A[A-Za-z]{1,10}\z/, message: "letters only, max 10" }
+                                     format: { with: /\A[A-Za-z]{1,10}-?\z/, message: "letters only (max 10), optionally ending in -" }
 
     def self.instance
       first_or_create!

data/app/services/hr_lite/attendance_summary.rb

@@ -2,7 +2,8 @@ module HrLite
   # Month roll-up per user — the payroll contract. Exact math per date:
   #
   #   holiday / weekend / present / paid full-day leave  -> payable +1
-  #   unpaid full-day leave (LWP) / absent               -> lop +1
+  #   unpaid full-day leave (LWP, or a paid-type day beyond the balance —
+  #     LeaveRequest#unpaid_on) / absent                 -> lop +1
   #   half-day punch (no leave)                          -> payable +0.5, lop +0.5
   #   half-day PAID leave: leave half payable; other half payable if
   #     punched, else lop (unpaid half-day leave: leave half is lop too)
@@ -54,13 +55,11 @@ module HrLite
           summary[:payable_days] += BigDecimal("0.5")
           summary[:lop_days] += BigDecimal("0.5")
         when :leave
-          if day.leave.paid?
-            summary[:paid_leave] += 1
-            summary[:payable_days] += 1
-          else
-            summary[:unpaid_leave] += 1
-            summary[:lop_days] += 1
-          end
+          unpaid = day.leave.paid? ? day.leave.unpaid_on(date) : 1
+          summary[:paid_leave] += 1 - unpaid
+          summary[:payable_days] += 1 - unpaid
+          summary[:unpaid_leave] += unpaid
+          summary[:lop_days] += unpaid
         when :half_day_leave
           apply_half_day_leave(summary, day)
         when :upcoming
@@ -77,13 +76,11 @@ module HrLite
     def self.apply_half_day_leave(summary, day)
       half = BigDecimal("0.5")
 
-      if day.leave.paid?
-        summary[:paid_leave] += half
-        summary[:payable_days] += half
-      else
-        summary[:unpaid_leave] += half
-        summary[:lop_days] += half
-      end
+      unpaid = day.leave.paid? ? day.leave.unpaid_on(day.leave.start_date) : half
+      summary[:paid_leave] += half - unpaid
+      summary[:payable_days] += half - unpaid
+      summary[:unpaid_leave] += unpaid
+      summary[:lop_days] += unpaid
 
       if day.record&.check_in_at
         summary[:present] += half

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

@@ -0,0 +1,65 @@
+<% content_for(:page_title) { "Benefits" } %>
+<div class="hrl-page__head">
+  <h1 class="hrl-page__title">Benefits</h1>
+  <div class="hrl-page__actions">
+    <a class="hrl-btn hrl-btn--primary" href="<%= hr_lite.new_admin_benefit_path %>">Add benefit</a>
+  </div>
+</div>
+
+<% if @benefits.none? %>
+  <section class="hrl-card"><p class="hrl-card--empty">No benefits yet — add one, then enrol people here.</p></section>
+<% end %>
+<% people = HrLite.active_employees.map { |u| [ hr_display_name(u), u.id ] } %>
+<% @benefits.each do |benefit| %>
+  <section class="hrl-card">
+    <h2 class="hrl-card__title"><%= benefit.name %></h2>
+    <p class="hrl-small hrl-muted">
+      <%= benefit.kind.humanize %><%= " · #{benefit.provider}" if benefit.provider.present? %>
+      · cover <%= hrl_money(benefit.coverage) %>
+    </p>
+    <%= form_with url: hr_lite.enrol_admin_benefit_path(benefit), method: :post, local: true do %>
+      <div class="hrl-field">
+        <%= label_tag "enrol_user_#{benefit.id}", "Employee" %>
+        <%= select_tag :user_id, options_for_select(people), id: "enrol_user_#{benefit.id}" %>
+      </div>
+      <div class="hrl-field">
+        <%= label_tag "enrol_on_#{benefit.id}", "Covered from" %>
+        <%= date_field_tag :enrolled_on, Date.current, id: "enrol_on_#{benefit.id}" %>
+      </div>
+      <div class="hrl-field">
+        <%= label_tag "enrol_dependants_#{benefit.id}", "Dependants covered" %>
+        <%= number_field_tag :dependants, 0, min: 0, id: "enrol_dependants_#{benefit.id}" %>
+      </div>
+      <div class="hrl-form-actions"><%= submit_tag "Enrol", class: "hrl-btn hrl-btn--primary" %></div>
+    <% end %>
+  </section>
+<% end %>
+
+<% if @enrolments.any? %>
+  <section class="hrl-card">
+    <h2 class="hrl-card__title">Enrolled</h2>
+    <div class="hrl-table-wrap">
+      <table class="hrl-table hrl-table--stack">
+        <thead><tr><th>Who</th><th>Benefit</th><th>Since</th><th>Dependants</th><th></th></tr></thead>
+        <tbody>
+          <% @enrolments.each do |enrolment| %>
+            <tr>
+              <td data-label="Who"><%= hr_display_name(enrolment.user) %></td>
+              <td data-label="Benefit"><%= enrolment.benefit.name %></td>
+              <td data-label="Since"><%= enrolment.enrolled_on.strftime("%d %b %Y") %></td>
+              <td data-label="Dependants" class="hrl-num"><%= enrolment.dependants %></td>
+              <td data-label="">
+                <%= form_with url: hr_lite.unenrol_admin_benefit_path(enrolment.benefit), method: :post do %>
+                  <%= hidden_field_tag :user_id, enrolment.user_id %>
+                  <%= date_field_tag :ended_on, Date.current, class: "hrl-input", "aria-label": "Last day of cover" %>
+                  <%= submit_tag "End cover", class: "hrl-btn" %>
+                <% end %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+    <%= hrl_pagination %>
+  </section>
+<% end %>