hr_lite 0.31.0 → 0.35.0

data/app/controllers/hr_lite/work_time_controller.rb

@@ -0,0 +1,14 @@
+module HrLite
+  # "My work time": the signed-in person's own analytics. There is no user
+  # param — nobody can read someone else's here.
+  class WorkTimeController < ApplicationController
+    before_action { raise ActiveRecord::RecordNotFound unless HrLite.config.office_geofence }
+
+    def show
+      @period, @period_error = WorkModeDurations::Period.from_params(params, Date.current)
+      @result = WorkModeDurations.call([ hr_current_user.id ], @period)
+      @records = AttendanceRecord.where(user_id: hr_current_user.id, date: @period.from..@period.to)
+                                 .where.not(check_in_at: nil).order(:date).limit(400)
+    end
+  end
+end

data/app/helpers/hr_lite/application_helper.rb

@@ -2,7 +2,7 @@ module HrLite
   module ApplicationHelper
     NAV_ITEMS = [
       { label: "Home",       path: :root_path,           match: [ "/" ], group: "My work" },
-      { label: "Attendance", path: :attendance_path,     match: [ "/attendance", "/regularization_requests", "/wfh_requests" ], group: "My work" },
+      { label: "Attendance", path: :attendance_path,     match: [ "/attendance", "/regularization_requests", "/wfh_requests", "/work_locations" ], group: "My work" },
       { label: "Leaves",     path: :leave_requests_path, match: [ "/leave_requests", "/leave_balances", "/comp_off_requests" ], group: "My work" },
       { label: "Team",       path: :team_path,           match: [ "/team" ], group: "My work" },
       # The phone tab bar shows the first four; the rest fill the More sheet,
@@ -33,7 +33,11 @@ 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", "/admin/wfh_requests" ] },
+      { label: "Work modes",      path: :admin_work_modes_path,      match: [ "/admin/work_modes" ],
+        if: -> { HrLite.config.office_geofence } },
+      { label: "Work time",       path: :admin_work_time_path,       match: [ "/admin/work_time" ],
+        if: -> { HrLite.config.office_geofence && hr_can?("work_analytics.view", scope: :team) } },
+      { label: "Approvals",       path: :admin_leave_requests_path,  match: [ "/admin/leave_requests", "/admin/leave_balances", "/admin/comp_off_requests", "/admin/regularization_requests", "/admin/wfh_requests", "/admin/work_locations" ] },
       { label: "Reports",         path: :admin_reports_path,         match: [ "/admin/reports" ] },
       { label: "Claims",          path: :admin_expenses_path,        match: [ "/admin/expenses" ],
         if: -> { hr_can?("expense.approve", scope: :team) } },
@@ -201,6 +205,43 @@ module HrLite
       content_tag(:span, status.humanize, class: "hrl-badge #{css}")
     end
 
+    # Lucide icons (ISC licence), one per work mode / derived status.
+    MODE_ICONS = {
+      "office" => '<path d="M6 22V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v18Z"/><path d="M6 12H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h2"/><path d="M18 9h2a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2h-2"/><path d="M10 6h4M10 10h4M10 14h4M10 18h4"/>',
+      "wfh" => '<path d="M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8"/><path d="M3 10a2 2 0 0 1 .709-1.528l7-5.999a2 2 0 0 1 2.582 0l7 5.999A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/>',
+      "travelling" => '<path d="M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"/>',
+      "outside_meeting" => '<path d="M16 20V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16"/><rect width="20" height="14" x="2" y="6" rx="2"/>',
+      "meeting" => '<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.87M16 3.13a4 4 0 0 1 0 7.75"/>',
+      "lunch" => '<path d="M3 2v7c0 1.1.9 2 2 2h4a2 2 0 0 0 2-2V2M7 2v20"/><path d="M21 15V2a5 5 0 0 0-5 5v6c0 1.1.9 2 2 2h3Zm0 0v7"/>',
+      "short_break" => '<path d="M10 2v2M14 2v2M6 2v2"/><path d="M16 8a1 1 0 0 1 1 1v8a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1h14a4 4 0 1 1 0 8h-1"/>',
+      "busy" => '<path d="M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 18 0v7a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3"/>',
+      "out_of_office" => '<path d="M13 4h3a2 2 0 0 1 2 2v14M2 20h3M13 20h9M10 12v.01"/><path d="M13 4.562v16.157a1 1 0 0 1-1.242.97L5 20V5.562a2 2 0 0 1 1.515-1.94l4-1A2 2 0 0 1 13 4.561Z"/>',
+      "sick_leave" => '<path d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"/><path d="M3.22 12H9.5l.5-1 2 4.5 2-7 1.5 3.5h5.27"/>',
+      "holiday" => '<rect width="18" height="18" x="3" y="4" rx="2"/><path d="M16 2v4M8 2v4M3 10h18M8 14h.01M12 14h.01M16 14h.01M8 18h.01M12 18h.01M16 18h.01"/>',
+      "on_leave" => '<rect width="18" height="18" x="3" y="4" rx="2"/><path d="M16 2v4M8 2v4M3 10h18"/><path d="m9 16 2 2 4-4"/>',
+      "weekend" => '<rect width="18" height="18" x="3" y="4" rx="2"/><path d="M16 2v4M8 2v4M3 10h18"/>',
+      "offline" => '<circle cx="12" cy="12" r="10"/><path d="m4.9 4.9 14.2 14.2"/>',
+      "custom" => '<path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/>'
+    }.freeze
+    MODE_SOURCES = { "system" => "set automatically", "employee" => "set by the employee", "hr" => "set by HR" }.freeze
+
+    # One small icon for a WorkStatus::Entry; a dot marks a system-set mode.
+    # The label, source and end time live in title + screen-reader text.
+    def hrl_mode_icon(entry)
+      detail = [ entry.label, MODE_SOURCES[entry.source], ("until #{entry.until.strftime('%H:%M')}" if entry.until.respond_to?(:hour)) ].compact.join(" · ")
+      svg = content_tag(:svg, MODE_ICONS.fetch(entry.mode, MODE_ICONS["offline"]).html_safe,
+                        xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: 14, height: 14, fill: "none",
+                        stroke: "currentColor", "stroke-width": 2, "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": true)
+      content_tag(:span, svg + content_tag(:span, detail, class: "hrl-sr-only"),
+                  class: class_names("hrl-mode", "hrl-mode--#{entry.mode}", "hrl-mode--auto": entry.source == "system"),
+                  title: detail)
+    end
+
+    # Primary + compatible overlay, e.g. office + busy.
+    def hrl_status_icons(status)
+      safe_join([ hrl_mode_icon(status.primary), (hrl_mode_icon(status.overlay) if status.overlay) ].compact)
+    end
+
     private
 
     # Always ONE root node — these land inside stacked-table flex cells,

data/app/jobs/hr_lite/attendance_close_job.rb

@@ -4,16 +4,16 @@ module HrLite
   # A punch left open is checked out at the day's end and paid as a half day,
   # and so is a closed punch short of config.work_hours.
   # Nobody punched in already reads as absent (DayStatus), so they are only
-  # told. Leave days are left alone.
+  # told. Leave days, and each person's weekends and office holidays, are left alone.
   class AttendanceCloseJob < ApplicationJob
     def perform(date: (Time.current - 12.hours).to_date)
-      return unless WorkingCalendar.new(date..date).working_day?(date)
-
+      calendars = WorkingCalendar.by_office(date..date)
+      offices = EmployeeProfile.pluck(:user_id, :office_location_id).to_h
       on_leave = LeaveRequest.active_on(date).pluck(:user_id)
       records = AttendanceRecord.for_date(date).index_by(&:user_id)
       day = date.strftime("%d %b")
       HrLite.active_employees(on: date).each do |user|
-        next if on_leave.include?(user.id)
+        next if on_leave.include?(user.id) || !calendars[offices[user.id]].working_day?(date)
 
         record = records[user.id]
         if record.nil? || record.check_in_at.nil?
@@ -29,15 +29,22 @@ module HrLite
         end
         penalize_short_day(record) if record&.check_out_at
       end
+      close_work_modes(date) if HrLite.config.office_geofence
     end
 
     private
 
+    # Anything still running from that day ends at its close; Offline stays open.
+    def close_work_modes(date)
+      day_end = [ date.in_time_zone(HrLite.config.time_zone).end_of_day, Time.current ].min
+      WorkModeEvent.open.work.where.not(mode: "offline").where(started_at: ..day_end).find_each { |e| e.close!("day_closed", at: day_end) }
+    end
+
     # Out before the slot's required checkout: +30 min on the next working day.
     def penalize_short_day(record)
       return unless HrLite.config.attendance_slots && record.check_out_at < record.required_check_out_at
 
-      next_day = AttendancePenalty.next_working_days(record.date, 1).first
+      next_day = AttendancePenalty.next_working_days(record.user_id, record.date, 1).first
       AttendancePenalty.find_or_create_by!(attendance_record: record, reason: "short_day", date: next_day) do |p|
         p.user_id = record.user_id
         p.minutes = AttendanceSlot::STEP_MINUTES

data/app/jobs/hr_lite/calendar_meeting_start_job.rb

@@ -0,0 +1,31 @@
+module HrLite
+  # Opens Meeting mode (system-set) for a calendar event at its start. It asks
+  # the calendar again first, so a meeting moved or cancelled since it was
+  # scheduled does not open. It never overrides a break or a mode the person
+  # or HR chose, and only runs for someone checked in.
+  class CalendarMeetingStartJob < ApplicationJob
+    def perform(user_id, calendar_event_id)
+      now = Time.current
+      return if WorkModeEvent.exists?(user_id: user_id, calendar_event_id: calendar_event_id)
+
+      user = HrLite.user_klass.find_by(id: user_id) or return
+      hook = HrLite.config.calendar_events or return
+      meeting = CalendarMeetingSyncJob.meetings(hook, user, now, now + 1.minute)&.find { |m| m[:id] == calendar_event_id }
+      return unless meeting && meeting[:starts_at] <= now + 1.minute && meeting[:ends_at] > now
+
+      record = AttendanceRecord.find_by(user_id: user_id, date: now.in_time_zone(HrLite.config.time_zone).to_date)
+      return unless record&.check_in_at && record.check_out_at.nil?
+
+      status = WorkStatus.for(user_id)
+      return unless status.primary.event
+      return if status.overlay && status.overlay.source != "system"
+
+      event = WorkModeEvent.start!(user_id: user_id, mode: "meeting", source: "system", at: now, ends_at: meeting[:ends_at],
+                                   title: meeting[:title].to_s.truncate(120).presence || "Calendar meeting",
+                                   calendar_event_id: calendar_event_id, attendance_record: record)
+      WorkModeExpireJob.set(wait_until: meeting[:ends_at]).perform_later(event.id)
+    rescue ActiveRecord::RecordNotUnique
+      nil # another run opened it first
+    end
+  end
+end

data/app/jobs/hr_lite/calendar_meeting_sync_job.rb

@@ -0,0 +1,55 @@
+module HrLite
+  # Keeps Meeting mode in step with each person's calendar. The host runs it
+  # for everyone every few minutes, and for one person the moment Google says
+  # their calendar changed. Each run schedules meetings starting soon and
+  # reconciles open ones: a cancelled or declined invite ends the meeting, a
+  # moved end time moves it. Re-runs are harmless.
+  class CalendarMeetingSyncJob < ApplicationJob
+    WINDOW = 10.minutes
+
+    def perform(user_ids = nil)
+      hook = HrLite.config.calendar_events
+      return unless hook && HrLite.config.calendar_users && HrLite.config.office_geofence
+
+      now = Time.current
+      ids = HrLite.config.calendar_users.call
+      ids &= Array(user_ids).map(&:to_i) if user_ids
+      HrLite.user_klass.where(id: ids).find_each do |user|
+        meetings = self.class.meetings(hook, user, now, now + WINDOW)
+        next if meetings.nil? # the calendar could not be read: leave everything as it is
+
+        reconcile(user, meetings, now)
+        meetings.each do |m|
+          next unless m[:starts_at] < now + WINDOW && m[:ends_at] > now
+
+          CalendarMeetingStartJob.set(wait_until: [ m[:starts_at], now ].max).perform_later(user.id, m[:id])
+        end
+      end
+    end
+
+    # Timed meetings overlapping from..to, or nil when the hook fails.
+    def self.meetings(hook, user, from, to)
+      Array(hook.call(user, from, to)).map { |m| m.to_h.symbolize_keys }
+                                      .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}")
+      nil
+    end
+
+    private
+
+    def reconcile(user, meetings, now)
+      by_id = meetings.index_by { |m| m[:id] }
+      WorkModeEvent.open.where(user_id: user.id, source: "system").where.not(calendar_event_id: nil).find_each do |event|
+        meeting = by_id[event.calendar_event_id]
+        if meeting.nil? || meeting[:starts_at] > now
+          event.close!("ended", at: now) # cancelled, declined or moved later
+        elsif meeting[:ends_at] != event.ends_at && meeting[:ends_at] > now
+          event.update!(ends_at: meeting[:ends_at])
+          WorkModeExpireJob.set(wait_until: meeting[:ends_at]).perform_later(event.id)
+        end
+      end
+    end
+  end
+end

data/app/jobs/hr_lite/work_mode_expire_job.rb

@@ -0,0 +1,12 @@
+module HrLite
+  # Ends a timed mode at its end time on the server, browser or not. A break
+  # the system had to end at its limit is marked as an overrun for HR.
+  class WorkModeExpireJob < ApplicationJob
+    def perform(event_id)
+      event = WorkModeEvent.open.find_by(id: event_id)
+      return unless event&.ends_at && event.ends_at <= Time.current
+
+      event.update!(ended_at: event.ends_at, end_reason: "expired", overrun: %w[lunch short_break].include?(event.mode))
+    end
+  end
+end

data/app/models/hr_lite/attendance_penalty.rb

@@ -20,8 +20,8 @@ module HrLite
 
     scope :active, -> { where(removed_at: nil) }
 
-    def self.next_working_days(date, count)
-      calendar = WorkingCalendar.new((date + 1)..(date + 31))
+    def self.next_working_days(user_id, date, count)
+      calendar = WorkingCalendar.for_user(user_id, (date + 1)..(date + 31))
       ((date + 1)..(date + 31)).select { |d| calendar.working_day?(d) }.first(count)
     end
 

data/app/models/hr_lite/attendance_record.rb

@@ -6,12 +6,19 @@ module HrLite
     LATE_HALF_DAY_NOTE = "Half day: checked in after 11:30".freeze
     # Half days the system set (not HR); an approved ticket lifts them.
     AUTO_NOTES = [ AUTO_CHECKOUT_NOTE, SHORT_DAY_NOTE, LATE_HALF_DAY_NOTE ].freeze
+    # Where the day was worked, set at check-in under config.office_geofence.
+    WORK_MODES = { "office" => "Office", "wfh" => "WFH", "travelling" => "Travelling",
+                   "outside_meeting" => "Client meeting" }.freeze
     # Check-in and check-out further apart than this are called out on the board.
     PUNCH_GAP_ALERT_M = 500
 
     belongs_to :user, class_name: HrLite.config.user_class
     belongs_to :regularized_by, class_name: HrLite.config.user_class, optional: true
     belongs_to :wfh_request, optional: true
+    belongs_to :work_location, optional: true
+
+    def remote? = work_mode.present? && work_mode != "office"
+    def work_mode_label = WORK_MODES[work_mode]
 
     validates :date, presence: true, uniqueness: { scope: :user_id }
     validates :status, inclusion: { in: STATUSES }

data/app/models/hr_lite/comp_off_request.rb

@@ -45,7 +45,7 @@ module HrLite
       raise MissingCompOffType if type.nil?
 
       transition!("approved", actor, note) do
-        raise StaleOffDay if WorkingCalendar.new(date_worked..date_worked).working_day?(date_worked)
+        raise StaleOffDay if WorkingCalendar.for_user(user_id, date_worked..date_worked).working_day?(date_worked)
 
         # (A duplicate live request for the same date cannot exist — the
         # partial unique index on [user_id, date_worked] guarantees it.)
@@ -141,7 +141,7 @@ module HrLite
       return unless date_worked
       return if date_worked > Date.current
 
-      calendar = WorkingCalendar.new(date_worked..date_worked)
+      calendar = WorkingCalendar.for_user(user_id, date_worked..date_worked)
       if calendar.working_day?(date_worked)
         errors.add(:date_worked, "was a regular working day — comp-off is for working on a weekend or holiday")
       end

data/app/models/hr_lite/employee_profile.rb

@@ -12,6 +12,8 @@ module HrLite
     # Reporting line (L1). Optional; the org chart treats manager-less
     # profiles as roots (founders/directors).
     belongs_to :manager, class_name: HrLite.config.user_class, optional: true
+    # Decides which office holidays apply; none = only all-office holidays.
+    belongs_to :office_location, optional: true
 
     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

data/app/models/hr_lite/holiday.rb

@@ -2,17 +2,23 @@ module HrLite
   class Holiday < ApplicationRecord
     include Audited
 
-    validates :date, presence: true, uniqueness: true
+    belongs_to :office_location, optional: true
+
+    validates :date, presence: true, uniqueness: { scope: :office_location_id }
     validates :name, presence: true
 
     scope :company_wide, -> { where(optional: false) }
     scope :in_range, ->(range) { where(date: range) }
     scope :upcoming, -> { where(date: Date.current..).order(:date) }
 
-    # Company-wide holiday dates only — optional holidays never exclude
-    # working days.
-    def self.dates_for(range)
-      company_wide.in_range(range).pluck(:date).to_set
+    scope :for_office, ->(office_id) { where(office_location_id: [ nil, office_id ].uniq) }
+
+    # Days off for one office: every all-office holiday plus that office's
+    # own. Optional holidays never exclude working days.
+    def self.dates_for(range, office_id = nil)
+      company_wide.in_range(range).for_office(office_id).pluck(:date).to_set
     end
+
+    def office_label = office_location&.name || "All offices"
   end
 end

data/app/models/hr_lite/leave_balance.rb

@@ -62,7 +62,7 @@ module HrLite
       # Building one per request meant a Holiday query and a Setting query
       # each — and the admin balances grid reads this cell for every employee
       # times every leave type.
-      calendar = WorkingCalendar.new(range)
+      calendar = WorkingCalendar.for_user(user_id, range)
       # 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

data/app/models/hr_lite/leave_request.rb

@@ -58,7 +58,7 @@ module HrLite
     def unpaid_on(date)
       return 0 if paid_days.nil?
 
-      @leave_calendar ||= WorkingCalendar.new(start_date..end_date)
+      @leave_calendar ||= WorkingCalendar.for_user(user_id, 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)

data/app/models/hr_lite/regularization_request.rb

@@ -44,7 +44,7 @@ module HrLite
     # day HR already decided or rejected, stays HR's call.
     def self_fixable?
       rule = HrLite.config.self_regularization
-      return false unless rule && date >= Date.current - rule[:within_days] && WorkingCalendar.new(date..date).working_day?(date)
+      return false unless rule && date >= Date.current - rule[:within_days] && WorkingCalendar.for_user(user_id, date..date).working_day?(date)
 
       day = punch
       fills_gap = (check_in_at.nil? || !day&.check_in_at) &&

data/app/models/hr_lite/setting.rb

@@ -6,6 +6,8 @@ module HrLite
     WEEKEND_POLICIES = %w[sun_only sat_sun second_fourth_sat_sun].freeze
 
     validates :weekend_policy, inclusion: { in: WEEKEND_POLICIES }
+    validates :lunch_break_minutes, numericality: { only_integer: true, in: 5..120 }
+    validates :short_break_minutes, numericality: { only_integer: true, in: 1..60 }
     validates :employee_code_prefix, presence: true,
                                      format: { with: /\A[A-Za-z]{1,10}-?\z/, message: "letters only (max 10), optionally ending in -" }
 

data/app/models/hr_lite/work_location.rb

@@ -0,0 +1,62 @@
+module HrLite
+  # A place an employee may work from at home. Coordinates come from the
+  # device at "Register here", never typed; HR approves before it counts.
+  class WorkLocation < ApplicationRecord
+    STATUSES = %w[pending approved rejected removed].freeze
+    MAX_LIVE = 3
+    MAX_ACCURACY_M = 100 # a vaguer fix can't pin a home
+    FENCE_M = 500
+
+    belongs_to :user, class_name: HrLite.config.user_class
+    belongs_to :decided_by, class_name: HrLite.config.user_class, optional: true
+
+    validates :name, presence: true, length: { maximum: 60 }
+    validates :address, length: { maximum: 200 }
+    validates :status, inclusion: { in: STATUSES }
+    validates :lat, numericality: { greater_than_or_equal_to: -90, less_than_or_equal_to: 90 }
+    validates :lng, numericality: { greater_than_or_equal_to: -180, less_than_or_equal_to: 180 }
+    validates :accuracy_m, numericality: { greater_than: 0, less_than_or_equal_to: MAX_ACCURACY_M,
+                                           message: "must be %{count} m or better — step outside or wait for GPS and try again" }
+    validate :within_limit, on: :create
+
+    scope :live, -> { where(status: %w[pending approved]) }
+    scope :approved, -> { where(status: "approved") }
+    scope :pending, -> { where(status: "pending") }
+
+    STATUSES.each { |s| define_method("#{s}?") { status == s } }
+
+    def self.active_for(user_id) = approved.find_by(user_id: user_id, active: true)
+
+    def covers?(lat, lng) = Geo.distance_m(self.lat, self.lng, lat.to_f, lng.to_f) <= FENCE_M
+
+    def map_url = "https://www.google.com/maps?q=#{lat},#{lng}"
+
+    def decide!(status, actor:, note: nil)
+      raise ActiveRecord::RecordInvalid.new(self), "not pending" unless pending?
+
+      update!(status: status, decided_by_id: actor.id, decided_at: Time.current, decision_note: note)
+      make_active! if approved? && !self.class.approved.where(user_id: user_id, active: true).exists?
+      AuditLog.record!(action: "work_location.#{status}", subject: self, actor: actor, changes: { "name" => name, "note" => note }.compact)
+    end
+
+    def make_active!
+      transaction do
+        self.class.where(user_id: user_id, active: true).where.not(id: id).update_all(active: false)
+        update!(active: true)
+      end
+    end
+
+    def remove!(actor:)
+      update!(status: "removed", active: false)
+      AuditLog.record!(action: "work_location.removed", subject: self, actor: actor, changes: { "name" => name })
+    end
+
+    private
+
+    def within_limit
+      return unless self.class.live.where(user_id: user_id).count >= MAX_LIVE
+
+      errors.add(:base, "You can register at most #{MAX_LIVE} locations. Remove one first.")
+    end
+  end
+end

data/app/models/hr_lite/work_mode_event.rb

@@ -0,0 +1,84 @@
+module HrLite
+  # One stretch of a work mode. Open rows (ended_at nil) are the current
+  # status — at most one primary and one overlay per person; closed rows are
+  # the day's timeline. Never deleted.
+  class WorkModeEvent < ApplicationRecord
+    # mode => [ label, layer, place shown to teammates ]
+    MODES = {
+      "office" => [ "In office", "primary", "Office" ],
+      "wfh" => [ "Work from home", "primary", "Home" ],
+      "travelling" => [ "Travelling", "primary", "Travelling" ],
+      "outside_meeting" => [ "Outside office meeting", "primary", "Client meeting" ],
+      "offline" => [ "Offline", "primary", nil ],
+      "meeting" => [ "Meeting", "overlay", nil ],
+      "lunch" => [ "Lunch break", "overlay", nil ],
+      "short_break" => [ "Short break", "overlay", nil ],
+      "busy" => [ "Busy", "overlay", nil ],
+      "out_of_office" => [ "Out of office", "overlay", nil ],
+      "custom" => [ "Custom status", "status", nil ]
+    }.freeze
+    SOURCES = %w[system employee hr].freeze
+    END_REASONS = %w[switched expired ended checked_out day_closed].freeze
+
+    belongs_to :user, class_name: HrLite.config.user_class
+    belongs_to :set_by, class_name: HrLite.config.user_class, optional: true
+    belongs_to :attendance_record, optional: true
+
+    validates :mode, inclusion: { in: MODES.keys }
+    validates :source, inclusion: { in: SOURCES }
+    validates :end_reason, inclusion: { in: END_REASONS }, allow_nil: true
+    validates :title, :client, :destination, length: { maximum: 120 }
+    validate :custom_status_shape, if: -> { mode == "custom" }
+    validate :ends_after_start
+
+    before_validation { self.layer = MODES.dig(mode, 1) if mode }
+
+    scope :open, -> { where(ended_at: nil) }
+    scope :primary, -> { where(layer: "primary") }
+    scope :overlay, -> { where(layer: "overlay") }
+    scope :work, -> { where.not(layer: "status") }
+
+    def self.label(mode) = MODES.dig(mode, 0)
+
+    # Closes the open row on the same layer and opens this one, atomically.
+    def self.start!(user_id:, mode:, source:, actor: nil, at: Time.current, **attrs)
+      transaction do
+        layer = MODES.dig(mode, 1)
+        open.where(user_id: user_id, layer: layer).lock.each { |e| e.close!("switched", at: at) }
+        event = create!(user_id: user_id, mode: mode, source: source, started_at: at, set_by_id: actor&.id, **attrs)
+        AuditLog.record!(action: "work_mode.#{mode}", subject: event, actor: actor || HrLite::Current.actor,
+                         changes: { "source" => source, "until" => event.ends_at&.iso8601, "reason" => event.reason }.compact)
+        event
+      end
+    end
+
+    # Ends every open work row for the person (check-out). A custom status
+    # stays: it is the person's own and clears on its own timer.
+    def self.close_all!(user_id, reason, at: Time.current)
+      open.work.where(user_id: user_id).lock.each { |e| e.close!(reason, at: at) }
+    end
+
+    def label = self.class.label(mode)
+    def place = MODES.dig(mode, 2)
+    def timed? = ends_at.present?
+    def expired?(now = Time.current) = ended_at.nil? && ends_at.present? && ends_at <= now
+
+    def close!(reason, at: Time.current)
+      update!(ended_at: [ at, ends_at ].compact.min, end_reason: reason)
+    end
+
+    private
+
+    # Text and/or one emoji; the emoji is a single symbol, never words.
+    def custom_status_shape
+      errors.add(:base, "Write a status or pick an emoji.") if title.blank? && emoji.blank?
+      return if emoji.blank?
+
+      errors.add(:emoji, "must be a single emoji") unless emoji.grapheme_clusters.size == 1 && emoji !~ /[[:alnum:][:space:]]/
+    end
+
+    def ends_after_start
+      errors.add(:ends_at, "must be after the start") if ends_at && started_at && ends_at <= started_at
+    end
+  end
+end