hr_lite 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a035599be75b81c0d2f3d1fc1b8f95328df845445f6c93d997a9906f9b43846e
-  data.tar.gz: 8a840cc6c1af2ef49af660859fc6edf0f2ccec4b59377017c9cc0467793e8396
+  metadata.gz: '04966d2c7a57a06e49c64c6a375b148c497f83340a79445eb0f243dd783246f0'
+  data.tar.gz: 1112874bf22548910a651e53123056fd1341e045598060660c12f93b284789bb
 SHA512:
-  metadata.gz: 9bef92ea728cc960bc548c37fe3a8a34090ad531bec3ab248dc572ce9931f44fb5bf2591b1578df0c22f68ffd5ab7c02e6e7a8ed43445b1087524fc59584889b
-  data.tar.gz: 2598075e1f67e8e2c9e7fa4142db5e7561f42f17e32a9be6207ca560116a8e9d3ac7b7876c02e4bc77c250df6ef0ec0b05592ad9c073b22aaa8f01158129276f
+  metadata.gz: '00219df8c7244175712e7a87768f50301fa2f8b0110ae201f343409064bdb1083cce3eef587ad046cf7e1831a1981eb7d3c6e816e2a9d431cbbb86aaf5ef8c89'
+  data.tar.gz: 53af8da6feddf2be67301f9754f2912a08fe246bada0b68eb89b2eb49b70a3279db4ded5645f3438bc859e1a57be3cde29e6c1fc59526db2747d1cc98a5525c6

data/CHANGELOG.md

@@ -7,6 +7,70 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.14.0] - 2026-08-18
+
+The admin half, plus the two ends of employment that were still manual.
+**Adds one migration.**
+
+### Added
+
+- **Admin screens for everything shipped since 0.11.0**: decide a claim and
+  record the payroll month it was paid with, answer or hand on a help-desk
+  request, hand out and take back an asset. The engine had all of this; there
+  was no way to do any of it.
+- **Assets.** One live holder at a time, enforced by a partial unique index —
+  two open assignments would mean the laptop is in two places, which it is
+  not. Assignments are append-only and record what condition it came back in,
+  because "screen cracked" is the difference between an asset returned and an
+  asset written off.
+- **Joining and leaving checklists**, from templates. The joining list opens
+  when a profile is created and the leaving list when an exit date is
+  stamped — the checklist nobody remembers to start is the one that does not
+  happen. Opening is idempotent, so adding a template later adds only what is
+  new. A failure to build one can never stop an employee being created.
+- Each step names the permission its owner should hold, so IT taking back a
+  laptop and HR collecting a document are not the same person by accident.
+- Permissions `asset.view`, `asset.manage`, `checklist.manage`.
+
+### Why it matters
+
+An asset that is never returned is a cost nobody notices, and access that is
+never revoked is a security problem that outlives the employment. Both were
+previously somebody's memory.
+
+## [0.13.0] - 2026-08-18
+
+The screens. No migration.
+
+### Added
+
+- **Employee self-service for everything built since 0.11.0**: claim an
+  expense (with what is left of each cap shown before you type an amount),
+  see what you are covered for, read and acknowledge a policy, ask HR a
+  question and read the answer.
+- **A reports hub** — headcount, joiners and leavers, leave balances,
+  attendance and expenses — each with a CSV download, and each **scoped by
+  the same permission that guards the screen its data comes from**. A report
+  is not a side door into rows somebody cannot otherwise reach: a manager's
+  headcount is their own team. The hub lists only the reports the reader can
+  actually open, since a list of links that turn you away is worse than a
+  short list.
+- CSV downloads are audited, the same way the payout register is.
+
+### Fixed
+
+- **The reports hub locked Finance out of the expense report.** It inherited
+  the operations gate, and Finance approves expenses but runs none of the
+  operations screens. Found by writing the spec for it.
+
+### Changed
+
+- `.hrl-prose` for long-form policy text, capped at 68 characters a line — a
+  policy read across the full width of a laptop is a policy nobody finishes.
+- The demo sandbox seeds an expense claim, a benefit enrolment, a policy
+  awaiting acknowledgement and an open HR request, so the new screens have
+  something on them at first boot.
+
 ## [0.12.0] - 2026-08-18
 
 The four things an employee had to leave the system to do. **Adds one
@@ -729,7 +793,9 @@ Initial release.
   bus with per-event channel matrix (bell, email, leadership email/bell),
   daily leadership digest and an append-only audit trail.
 
-[Unreleased]: https://github.com/kshtzkr/hr_lite/compare/v0.12.0...HEAD
+[Unreleased]: https://github.com/kshtzkr/hr_lite/compare/v0.14.0...HEAD
+[0.14.0]: https://github.com/kshtzkr/hr_lite/compare/v0.13.0...v0.14.0
+[0.13.0]: https://github.com/kshtzkr/hr_lite/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/kshtzkr/hr_lite/compare/v0.11.0...v0.12.0
 [0.11.0]: https://github.com/kshtzkr/hr_lite/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/kshtzkr/hr_lite/compare/v0.9.0...v0.10.0

data/app/assets/stylesheets/hr_lite/hr_lite.css

@@ -318,3 +318,9 @@
 .hrl-mt { margin-top: .85rem; }
 .hrl-right { margin-left: auto; }
 .hrl-row { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; }
+
+/* Long-form policy text. Constrained measure — a policy read across the
+   full width of a laptop is a policy nobody finishes. */
+.hrl-prose { max-width: 68ch; }
+.hrl-prose p { margin: 0 0 .8rem; line-height: 1.6; }
+.hrl-prose p:last-child { margin-bottom: 0; }

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

@@ -0,0 +1,53 @@
+module HrLite
+  module Admin
+    # Who has the laptop.
+    class AssetsController < BaseController
+      skip_before_action :require_operations_access!
+      before_action :require_assets!
+
+      def index
+        @assets = paginate(Asset.order(:status, :name).includes(asset_assignments: :user))
+        @outstanding = AssetAssignment.live.includes(:asset, :user)
+      end
+
+      def new
+        @asset = Asset.new
+      end
+
+      def create
+        @asset = Asset.new(asset_params)
+        if @asset.save
+          redirect_to admin_assets_path, notice: "#{@asset.name} added."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def assign
+        asset = Asset.find(params[:id])
+        user = HrLite.user_klass.find(params[:user_id])
+        asset.assign_to!(user, actor: hr_current_user)
+        redirect_to admin_assets_path, notice: "#{asset.name} given to #{HrLite.display_name(user)}."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_assets_path, alert: "#{asset.name} is already with somebody."
+      end
+
+      def take_back
+        asset = Asset.find(params[:id])
+        asset.return!(actor: hr_current_user, condition: params[:condition_note],
+                      status: params[:status].presence_in(Asset::STATUSES) || "available")
+        redirect_to admin_assets_path, notice: "#{asset.name} taken back."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_assets_path, alert: "#{asset.name} is not with anybody."
+      end
+
+      private
+
+      def require_assets! = hr_require_permission!("asset.manage", scope: :all)
+
+      def asset_params
+        params.require(:asset).permit(:name, :category, :serial_number, :purchased_on, :notes)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module HrLite
+  module Admin
+    # Joining and leaving, step by step, with what is overdue at the top.
+    class ChecklistsController < BaseController
+      skip_before_action :require_operations_access!
+      before_action :require_checklists!
+
+      def index
+        @kind = params[:kind].presence_in(ChecklistTemplate::KINDS) || "onboarding"
+        @items = ChecklistItem.for_kind(@kind).outstanding.includes(:user)
+                              .order(Arel.sql("due_on IS NULL, due_on"))
+        @overdue = @items.select(&:overdue?)
+      end
+
+      def complete
+        item = ChecklistItem.find(params[:id])
+        item.complete!(actor: hr_current_user, note: params[:note])
+        redirect_to admin_checklists_path(kind: item.kind), notice: "#{item.title} — done."
+      end
+
+      def reopen
+        item = ChecklistItem.find(params[:id])
+        item.reopen!(actor: hr_current_user)
+        redirect_to admin_checklists_path(kind: item.kind), notice: "#{item.title} — reopened."
+      end
+
+      private
+
+      def require_checklists! = hr_require_permission!("checklist.manage", scope: :all)
+    end
+  end
+end

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

@@ -93,6 +93,10 @@ module HrLite
         exit_date = params[:date_of_exit].present? ? parse_date_param(params[:date_of_exit]) : Date.current
 
         @profile.update!(date_of_exit: exit_date)
+        # The last day has a list too — and it is the one that matters most,
+        # since an unreturned laptop and un-revoked access both outlive the
+        # employment.
+        ChecklistItem.open_for!(@profile.user, kind: "offboarding", anchor_date: exit_date)
         begin
           HrLite.config.offboard_user.call(@profile.user)
         rescue => e

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

@@ -0,0 +1,45 @@
+module HrLite
+  module Admin
+    # The other side of the claim: decide it, then say when it was paid.
+    class ExpensesController < BaseController
+      skip_before_action :require_operations_access!
+      before_action :require_deciding!
+
+      def index
+        @status = params[:status].presence_in(Expense::STATUSES) || "submitted"
+        scope = Expense.where(status: @status).includes(:user, :category).recent_first
+        @expenses = paginate(hr_scope(scope, "expense.approve"))
+      end
+
+      def approve
+        expense = decidable.find(params[:id])
+        expense.approve!(actor: hr_current_user, note: params[:decision_note].presence)
+        redirect_to admin_expenses_path, notice: "Claim approved."
+      end
+
+      def reject
+        expense = decidable.find(params[:id])
+        note = params[:decision_note].to_s.strip
+        return redirect_to admin_expenses_path, alert: "A note is required to reject." if note.blank?
+
+        expense.reject!(actor: hr_current_user, note: note)
+        redirect_to admin_expenses_path, notice: "Claim rejected."
+      end
+
+      def reimburse
+        expense = decidable.find(params[:id])
+        month = parse_month_param(params[:period_month])
+        expense.reimburse!(actor: hr_current_user, period_month: month)
+        redirect_to admin_expenses_path, notice: "Marked reimbursed with #{month.strftime('%B %Y')}."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_expenses_path, alert: "Only an approved claim can be reimbursed."
+      end
+
+      private
+
+      def require_deciding! = hr_require_permission!("expense.approve", scope: :team)
+
+      def decidable = hr_scope(Expense.all, "expense.approve")
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module HrLite
+  module Admin
+    # The desk itself.
+    class HrRequestsController < BaseController
+      skip_before_action :require_operations_access!
+      before_action :require_desk!
+
+      def index
+        @status = params[:status].presence_in(HrRequest::STATUSES) || "open"
+        @requests = paginate(HrRequest.where(status: @status).includes(:user, :assigned_to)
+                                      .recent_first)
+      end
+
+      def show
+        @request = HrRequest.find(params[:id])
+      end
+
+      def assign
+        request = HrRequest.find(params[:id])
+        assignee = HrLite.user_klass.find(params[:assignee_id])
+        request.assign!(actor: hr_current_user, assignee: assignee)
+        redirect_to admin_hr_request_path(request), notice: "Assigned to #{HrLite.display_name(assignee)}."
+      end
+
+      def resolve
+        request = HrRequest.find(params[:id])
+        request.resolve!(actor: hr_current_user, resolution: params[:resolution].to_s.strip)
+        redirect_to admin_hr_requests_path, notice: "Answered."
+      rescue ArgumentError
+        redirect_to admin_hr_request_path(request), alert: "Write an answer before resolving."
+      end
+
+      private
+
+      def require_desk! = hr_require_permission!("hr_request.manage", scope: :all)
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+module HrLite
+  module Admin
+    # The numbers somebody asks for at the end of a month, and the CSV they
+    # ask for straight afterwards.
+    #
+    # Every report is scoped by the SAME permission that guards the screens
+    # its data comes from — a report is not a side door into rows somebody
+    # cannot otherwise reach.
+    class ReportsController < BaseController
+      # Finance can approve expenses but runs none of the operations screens,
+      # so the operations gate would have shut them out of their own expense
+      # report. The hub is reachable by anybody who can see AT LEAST ONE
+      # report; each report then checks its own permission.
+      skip_before_action :require_operations_access!
+      before_action :require_any_report!
+
+      REPORTS = {
+        "headcount" => "Headcount by department",
+        "joiners_and_leavers" => "Joiners and leavers",
+        "leave_balances" => "Leave balances",
+        "attendance" => "Attendance summary",
+        "expenses" => "Expense claims"
+      }.freeze
+
+      def index
+        # Only the reports this person could actually open — a list of links
+        # that turn you away is worse than a shorter list.
+        @reports = REPORTS.select { |name, _| permitted?(name) }
+        @month = parse_month_param(params[:month])
+      end
+
+      def show
+        @month = parse_month_param(params[:month])
+        @name = params[:id]
+        return hr_access_denied unless REPORTS.key?(@name)
+        return hr_access_denied unless permitted?(@name)
+
+        @rows = rows_for(@name)
+        respond_to do |format|
+          format.html
+          format.csv do
+            AuditLog.record!(action: "report.exported", subject: hr_current_user,
+                             actor: hr_current_user,
+                             changes: { "report" => @name, "rows" => @rows.size,
+                                        "month" => @month.strftime("%Y-%m") })
+            send_data to_csv(@rows), filename: "#{@name}-#{@month.strftime('%Y-%m')}.csv",
+                                     type: "text/csv"
+          end
+        end
+      end
+
+      private
+
+      def require_any_report!
+        hr_access_denied if REPORTS.keys.none? { |name| permitted?(name) }
+      end
+
+      # A report reaches exactly as far as the screen it summarises.
+      def permitted?(name)
+        case name
+        when "expenses" then hr_can?("expense.approve", scope: :all)
+        when "leave_balances" then hr_can?("leave.view", scope: :team)
+        when "attendance" then hr_can?("attendance.view", scope: :team)
+        else hr_can?("profile.view", scope: :team)
+        end
+      end
+
+      def visible_users
+        ids = hr_access.visible_user_ids("profile.view")
+        employees = HrLite.employees
+        ids.nil? ? employees : employees.select { |user| ids.include?(user.id) }
+      end
+
+      def rows_for(name)
+        case name
+        when "headcount" then headcount_rows
+        when "joiners_and_leavers" then joiners_and_leavers_rows
+        when "leave_balances" then leave_balance_rows
+        when "attendance" then attendance_rows
+        when "expenses" then expense_rows
+        end
+      end
+
+      def headcount_rows
+        profiles = EmployeeProfile.where(user_id: visible_users.map(&:id))
+                                  .active_for(@month)
+        profiles.group_by { |p| p.department.presence || "Unassigned" }
+                .sort_by(&:first)
+                .map { |department, rows| { "Department" => department, "People" => rows.size } }
+      end
+
+      def joiners_and_leavers_rows
+        window = @month..@month.end_of_month
+        EmployeeProfile.where(user_id: visible_users.map(&:id))
+                       .where("date_of_joining BETWEEN ? AND ? OR date_of_exit BETWEEN ? AND ?",
+                              window.first, window.last, window.first, window.last)
+                       .includes(:user)
+                       .map do |profile|
+          { "Employee" => HrLite.display_name(profile.user),
+            "Department" => profile.department,
+            "Joined" => profile.date_of_joining&.to_s,
+            "Left" => profile.date_of_exit&.to_s }
+        end
+      end
+
+      def leave_balance_rows
+        year = LeaveYear.key_for(@month)
+        types = LeaveType.active.where(paid: true).where.not(annual_quota: nil)
+        visible_users.flat_map do |user|
+          types.map do |type|
+            balance = LeaveBalance.for(user, type, year)
+            { "Employee" => HrLite.display_name(user), "Type" => type.code,
+              "Entitled" => balance.entitled.to_f, "Used" => balance.used.to_f,
+              "Available" => balance.available.to_f }
+          end
+        end
+      end
+
+      def attendance_rows
+        visible_users.map do |user|
+          summary = AttendanceSummary.for(user: user, month: @month)
+          { "Employee" => HrLite.display_name(user),
+            "Payable days" => summary[:payable_days].to_f,
+            "LOP" => summary[:lop_days].to_f,
+            "Days in month" => summary[:days_in_month] }
+        end
+      end
+
+      def expense_rows
+        Expense.where(spent_on: @month..@month.end_of_month)
+               .includes(:user, :category).recent_first.map do |expense|
+          { "Employee" => HrLite.display_name(expense.user),
+            "Category" => expense.category.name,
+            "Spent on" => expense.spent_on.to_s,
+            "Amount" => expense.amount.to_s("F"),
+            "Status" => expense.status }
+        end
+      end
+
+      def to_csv(rows)
+        require "csv"
+        return "" if rows.empty?
+
+        CSV.generate do |csv|
+          csv << rows.first.keys
+          rows.each { |row| csv << row.values }
+        end
+      end
+    end
+  end
+end

data/app/controllers/hr_lite/benefits_controller.rb

@@ -0,0 +1,17 @@
+module HrLite
+  # What the signed-in person is actually covered for — previously something
+  # you had to email somebody to find out.
+  class BenefitsController < ApplicationController
+    before_action :require_viewing!
+
+    def index
+      @enrolments = BenefitEnrolment.live_on(Date.current)
+                                    .where(user_id: hr_current_user.id)
+                                    .includes(:benefit)
+    end
+
+    private
+
+    def require_viewing! = hr_require_permission!("benefit.view")
+  end
+end

data/app/controllers/hr_lite/expenses_controller.rb

@@ -0,0 +1,50 @@
+module HrLite
+  # An employee's own claims. Scoped to the signed-in person the same way
+  # every other self-service screen is: a foreign id 404s through the
+  # relation rather than 403ing.
+  class ExpensesController < ApplicationController
+    before_action :require_claiming!
+
+    def index
+      @expenses = paginate(own.includes(:category).recent_first)
+      @categories = ExpenseCategory.active.alphabetical
+    end
+
+    def new
+      @expense = Expense.new(spent_on: Date.current)
+      @categories = ExpenseCategory.active.alphabetical
+    end
+
+    def create
+      @expense = Expense.new(expense_params.merge(user_id: hr_current_user.id))
+      if @expense.save
+        @expense.submit!(actor: hr_current_user)
+        redirect_to expenses_path, notice: "Claim submitted."
+      else
+        @categories = ExpenseCategory.active.alphabetical
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def cancel
+      expense = own.find(params[:id])
+      if expense.draft? || expense.submitted?
+        expense.update!(status: "cancelled")
+        expense.approval_route.cancel_all!
+        redirect_to expenses_path, notice: "Claim withdrawn."
+      else
+        redirect_to expenses_path, alert: "Only a claim still waiting can be withdrawn."
+      end
+    end
+
+    private
+
+    def require_claiming! = hr_require_permission!("expense.claim")
+
+    def own = Expense.where(user_id: hr_current_user.id)
+
+    def expense_params
+      params.require(:expense).permit(:category_id, :amount, :spent_on, :description, :receipt)
+    end
+  end
+end

data/app/controllers/hr_lite/hr_requests_controller.rb

@@ -0,0 +1,43 @@
+module HrLite
+  # The employee's side of the help desk.
+  class HrRequestsController < ApplicationController
+    before_action :require_raising!
+
+    def index
+      @requests = paginate(own.recent_first)
+    end
+
+    def show
+      @request = own.find(params[:id])
+    end
+
+    def new
+      @request = HrRequest.new
+    end
+
+    def create
+      @request = HrRequest.new(request_params.merge(user_id: hr_current_user.id))
+      if @request.save
+        redirect_to hr_requests_path, notice: "Sent to HR."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def cancel
+      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."
+    end
+
+    private
+
+    def require_raising! = hr_require_permission!("hr_request.raise")
+
+    def own = HrRequest.where(user_id: hr_current_user.id)
+
+    def request_params = params.require(:hr_request).permit(:category, :subject, :body)
+  end
+end

data/app/controllers/hr_lite/policies_controller.rb

@@ -0,0 +1,26 @@
+module HrLite
+  # What people are held to, and the button that says they have read it.
+  class PoliciesController < ApplicationController
+    before_action :require_reading!
+
+    def index
+      @policies = Policy.current.sort_by(&:title)
+      @acknowledged = PolicyAcknowledgement.where(user_id: hr_current_user.id)
+                                           .pluck(:policy_id).to_set
+    end
+
+    def show
+      @policy = Policy.published.find(params[:id])
+    end
+
+    def acknowledge
+      policy = Policy.published.find(params[:id])
+      policy.acknowledge!(hr_current_user)
+      redirect_to policies_path, notice: "Thank you — recorded against #{policy.title} v#{policy.version}."
+    end
+
+    private
+
+    def require_reading! = hr_require_permission!("policy.view", scope: :all)
+  end
+end

data/app/helpers/hr_lite/application_helper.rb

@@ -12,6 +12,10 @@ module HrLite
       # 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: "Expenses",   path: :expenses_path,       match: [ "/expenses" ] },
+      { label: "Benefits",   path: :benefits_path,       match: [ "/benefits" ] },
+      { label: "Policies",   path: :policies_path,       match: [ "/policies" ] },
+      { label: "Ask HR",     path: :hr_requests_path,    match: [ "/hr_requests" ] },
       { label: "Org",        path: :org_path,            match: [ "/org" ] },
       { label: "Kudos",      path: :kudos_path,          match: [ "/kudos" ] },
       { label: "Slips",      path: :salary_slips_path,   match: [ "/salary_slips" ] },
@@ -21,7 +25,12 @@ module HrLite
     ADMIN_NAV_ITEMS = [
       { label: "Overview",        path: :admin_overview_path,        match: [ "/admin/overview" ] },
       { 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: "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: "Help desk",       path: :admin_hr_requests_path,     match: [ "/admin/hr_requests" ] },
+      { label: "Assets",          path: :admin_assets_path,          match: [ "/admin/assets" ] },
+      { label: "Joining & exits", path: :admin_checklists_path,      match: [ "/admin/checklists" ] }
     ].freeze
 
     LEADERSHIP_NAV_ITEMS = [

data/app/models/hr_lite/asset.rb

@@ -0,0 +1,57 @@
+module HrLite
+  # A laptop, a phone, a SIM. An asset nobody tracks is a cost nobody
+  # notices, and the moment it matters is somebody's last day.
+  class Asset < ApplicationRecord
+    include Audited
+
+    STATUSES = %w[available assigned returned lost damaged retired].freeze
+    CATEGORIES = %w[laptop phone sim id_card accessory vehicle other].freeze
+
+    has_many :asset_assignments, class_name: "HrLite::AssetAssignment", dependent: :destroy
+
+    validates :name, presence: true
+    validates :status, inclusion: { in: STATUSES }
+    validates :category, inclusion: { in: CATEGORIES }
+    validates :serial_number, uniqueness: { allow_blank: true }
+
+    scope :available, -> { where(status: "available") }
+    scope :out, -> { where(status: "assigned") }
+
+    STATUSES.each { |s| define_method("#{s}?") { status == s } }
+
+    def live_assignment = asset_assignments.find_by(returned_on: nil)
+
+    def holder = live_assignment&.user
+
+    def assign_to!(user, actor: nil, on: Date.current)
+      raise ActiveRecord::RecordInvalid.new(self), "already assigned" if live_assignment
+
+      transaction do
+        asset_assignments.create!(user_id: user.id, assigned_on: on, assigned_by_id: actor&.id)
+        update!(status: "assigned")
+      end
+      true
+    end
+
+    # `condition` records what came back — "screen cracked" is the difference
+    # between an asset returned and an asset written off.
+    def return!(actor: nil, on: Date.current, condition: nil, status: "available")
+      assignment = live_assignment
+      raise ActiveRecord::RecordInvalid.new(self), "not assigned" if assignment.nil?
+
+      transaction do
+        assignment.update!(returned_on: on, condition_note: condition.presence)
+        update!(status: status)
+      end
+      true
+    end
+
+    # Everything still out with somebody who has left — the report that
+    # should exist before an exit, not after.
+    def self.outstanding_for(user)
+      joins(:asset_assignments)
+        .where(hr_lite_asset_assignments: { user_id: user.id, returned_on: nil })
+        .distinct
+    end
+  end
+end