hr_lite 0.31.0 → 0.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc6f0b0eab85d612fdadaffc907d6b8d64eda04ed9fba81c5611ef37266916cf
-  data.tar.gz: 81a344480832392ca76230a465597bc085e6e155b063f7f823fc2348de9891cf
+  metadata.gz: 874b64768a50e28c793779db9c5ff36e35f0b266cb318f34ca94df74e4de4bd7
+  data.tar.gz: f959b7a94d511c5ebf1f712cb29c1261df6207dc0c9a3bc6938dffad170900f8
 SHA512:
-  metadata.gz: e9dba6adb15c59d153c44e29e5bbba3e24df80b6c2f8caaa4383bc49b98ba052a30780a51fe70bbfaf989188b8642bdb3de096214595dbeb511c3da6faf4a642
-  data.tar.gz: b8c776a6b48436ba780f09f948a5233d7372dd5abb5ed540c10507cb26de5a0cd7ec4f0f1a7cd40c528c5af18c0c8bc49e0d6959418d3b0c0b2a769450703011
+  metadata.gz: 482b65659ee54aec1e96bb34972028e428839f09925c7278cc97d3652a5ac54a622fcceb43575810561e1fd4dcb66037e2083d7f8856ae29ba71404c976d4dc6
+  data.tar.gz: 8d3540851748ca4677db0503a4f47e140bc7e27aa60ab7816280acfc317ae3fbc9ed0f7028719edf6a209932743aa24fb13ea94036b9f120296b0e576a089bac

data/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.35.0] - 2026-10-13
+
+- Today's check-ins on Home: everyone in today, split into on time, late and not in yet (leave, holidays and weekends left out). "On time" uses each person's own slot plus their HR buffer and the grace minutes, the same rule as the late penalty. Hover or tap a person for their check-in, how late, check-out and hours worked (or hours so far).
+- Custom status, Slack-style: your own text and an emoji (pick from a grid or type one), clearing after 30 minutes, 1 hour, 4 hours, today, or never. It works without a check-in, survives check-out and the nightly close, shows beside your name on the team board, and is never counted in work-time analytics.
+- Meetings from the calendar. With `config.calendar_events` and `config.calendar_users` set, Meeting mode starts on its own when a calendar meeting begins and ends with it. `CalendarMeetingSyncJob` runs on a schedule and can sync one person instantly (for calendar change notifications): a cancelled or declined invite ends the meeting, a moved one moves it, and nothing overrides a break or a mode the person chose.
+- One-click "Connect Google Calendar" on the punch card (`config.calendar_connection`): the host supplies the connect and disconnect links, so anyone can link a personal Gmail calendar alongside the organisation's Workspace calendars.
+- Do not disturb: while someone is Busy or in a meeting, their HR emails wait until it ends; the bell still lands.
+- Link a meeting, client meeting or trip to a CRM lead (`config.crm_search`, `config.crm_find`): a type-ahead picker in the forms, and the HR timeline links to the lead.
+- Work time for a finished period is cached, keyed on the newest change to its events and check-ins, so corrections show at once. Today is always worked out live.
+- Tap a chart segment on a phone to see its details (no hover there); segments are keyboard-focusable.
+
+## [0.34.0] - 2026-10-13
+
+- Holidays per office. A holiday applies to every office or to one (Admin → Holidays: "Applies to", also for bulk paste), and each employee can belong to an office (Admin → Employee: Office). Everything that decides whether a day is a working day now uses that person's calendar: attendance and absences, the nightly close, leave day counts and balances, loss of pay and payslips, comp-off, self-fix tickets, late carry-over, the team board, work status and weekly hours. Employees see their own office's holidays; announcements go only to the office concerned. People with no office get the all-office holidays, exactly as before. Two offices may now close on the same date.
+
+## [0.33.0] - 2026-10-13
+
+- Work time. Time per work mode, worked out from the mode timeline on every request (a correction shows at once; a break on top of a work mode counts once, as the break). Periods: day, week, month, quarter, year, custom (up to 366 days). Working time = in office, WFH, travelling, client and other meetings, busy; breaks = lunch and short breaks; out of office and offline are shown apart and never counted as working. Employees see their own under My work time; others need the new `work_analytics.view` permission (HR, Leadership and Super Admin get it; Manager does not by default) on Admin → Work time, where opening one person's breakdown is audited. Charts are server-drawn SVG: summary cards, a share donut with its denominator stated, stacked bars that open a day, and an hour-by-hour day strip. HR also gets a "worth a look" list: missing check-outs, worked days with no modes, modes with no check-in.
+
+## [0.32.0] - 2026-10-13
+
+- Work modes (with `office_geofence`). Check-in sets the day's mode automatically: inside an office radius it is In office; on an approved WFH day (dated or permanent) it must be within 500 m of the person's active approved home location; field staff (a profile switch) may check in from anywhere as Travelling or Client meeting, saying why and where. Check-out ends everything and sets Offline. Employees switch to In office, WFH, Travelling, Client meeting, Meeting, Lunch break (one a day, ends itself at the limit), Short break, Busy or Out of office; a mode is a status and never changes where the day's attendance was authorised. Timed modes end on the server (`WorkModeExpireJob`), with or without the page open. Holidays, leave and sick leave show automatically from their own records and take precedence. Every change is kept in a timeline with its source (system, employee, HR) and audited.
+- WFH locations: employees register up to three places from the device ("Register here", never typed); HR approves each from Approvals → Locations. Teammates see "Home", never the address or coordinates.
+- Mode icons beside names on the punch card and team board (a dot marks a system-set mode), team filters by department, mode and availability, and an HR Work modes board: live counts per mode, who needs review, field check-ins, a person's day timeline, a Sales view, and HR override with a reason. Lunch and short-break limits live in Admin → Settings.
+- Permanent WFH now means standing WFH approval for every working day; check-in still has to be at an approved home location.
+
 ## [0.31.0] - 2026-10-13
 
 - Office geofence (`config.office_geofence = true`, off by default). A check-in must come from inside an active office's radius (Admin → Offices), with a GPS fix at least that precise; otherwise it is refused with "You are not within the office location. Please request Work From Home (WFH) approval from HR." A denied or failed location says why. Check-out is unchanged.

data/app/assets/javascripts/hr_lite/chart_tip.js

@@ -0,0 +1,33 @@
+// Phones have no hover, so a title never shows there. Tapping (or tabbing to)
+// a [data-hrl-tip] element shows its tip text — or an SVG segment's <title> —
+// in a small box.
+(function () {
+  "use strict";
+  var tip;
+  function hide() { if (tip) tip.hidden = true; }
+  function show(el) {
+    var title = el.dataset.hrlTip ? { textContent: el.dataset.hrlTip } : el.querySelector("title");
+    if (!title) return;
+    if (!tip) {
+      tip = document.createElement("div");
+      tip.className = "hrl-chart-tip";
+      tip.setAttribute("role", "status");
+      document.body.appendChild(tip);
+    }
+    tip.textContent = title.textContent;
+    tip.hidden = false;
+    var box = el.getBoundingClientRect();
+    var left = Math.min(Math.max(8, box.left + window.scrollX), window.scrollX + document.documentElement.clientWidth - tip.offsetWidth - 8);
+    tip.style.left = left + "px";
+    // Below the element, so the label above it stays readable.
+    tip.style.top = (box.bottom + window.scrollY + 6) + "px";
+  }
+  document.addEventListener("click", function (e) {
+    var el = e.target.closest && e.target.closest("[data-hrl-tip]");
+    el ? show(el) : hide();
+  });
+  document.addEventListener("focusin", function (e) {
+    if (e.target.closest && e.target.closest("[data-hrl-tip]")) show(e.target.closest("[data-hrl-tip]"));
+  });
+  document.addEventListener("keydown", function (e) { if (e.key === "Escape") hide(); });
+})();

data/app/assets/javascripts/hr_lite/countdown.js

@@ -0,0 +1,12 @@
+// Ticks "Xh YYm left" on [data-hrl-countdown="<iso time>"]. Display only:
+// the server ends the mode itself, with or without this page open.
+(function () {
+  "use strict";
+  function tick() {
+    document.querySelectorAll("[data-hrl-countdown]").forEach(function (el) {
+      var left = Math.max(0, Math.round((Date.parse(el.dataset.hrlCountdown) - Date.now()) / 60000));
+      el.textContent = left === 0 ? "ended" : Math.floor(left / 60) + "h " + String(left % 60).padStart(2, "0") + "m left";
+    });
+  }
+  document.addEventListener("DOMContentLoaded", function () { tick(); setInterval(tick, 30000); });
+})();

data/app/assets/javascripts/hr_lite/crm_picker.js

@@ -0,0 +1,27 @@
+// Type-ahead for [data-hrl-crm="<search url>"]: typing fills the <select
+// name="crm_ref"> with matching leads. Without JS the select just stays empty.
+(function () {
+  "use strict";
+  function setup(box) {
+    var input = box.querySelector("input[type=search]");
+    var select = box.querySelector("select");
+    var timer;
+    input.addEventListener("input", function () {
+      clearTimeout(timer);
+      var q = input.value.trim();
+      if (q.length < 2) return;
+      timer = setTimeout(function () {
+        fetch(box.dataset.hrlCrm + "?q=" + encodeURIComponent(q), { headers: { Accept: "application/json" }, credentials: "same-origin" })
+          .then(function (r) { return r.ok ? r.json() : []; })
+          .then(function (leads) {
+            select.length = 1;
+            leads.forEach(function (lead) { select.add(new Option(lead.label, lead.id)); });
+            if (leads.length) select.selectedIndex = 1;
+          });
+      }, 250);
+    });
+  }
+  document.addEventListener("DOMContentLoaded", function () {
+    document.querySelectorAll("[data-hrl-crm]").forEach(setup);
+  });
+})();

data/app/assets/javascripts/hr_lite/emoji_pick.js

@@ -0,0 +1,11 @@
+// Emoji grid for the status form: a tap puts that emoji in the input.
+(function () {
+  "use strict";
+  document.addEventListener("click", function (e) {
+    var b = e.target.closest && e.target.closest("[data-hrl-emoji]");
+    if (!b) return;
+    var input = b.closest("form").querySelector("input[name=emoji]");
+    input.value = b.dataset.hrlEmoji;
+    input.focus();
+  });
+})();

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

@@ -569,3 +569,50 @@ a.hrl-tree__name { display: inline-flex; align-items: center; min-height: var(--
 /* Notifications link, shown only when the host configures one. */
 .hrl-bell { display: inline-flex; align-items: center; gap: .4rem; min-height: var(--hrl-target); font-size: var(--hrl-t-small); font-weight: 600; }
 .hrl-bell__count { min-width: 1.4rem; padding: 0 .4rem; border-radius: var(--hrl-radius-pill); background: var(--hrl-accent); color: var(--hrl-accent-ink); font-size: var(--hrl-t-micro); text-align: center; }
+
+/* Work-mode icons. A small dot marks a mode the system set. */
+.hrl-modes { display: inline-flex; gap: .25rem; vertical-align: middle; }
+.hrl-mode { position: relative; display: inline-flex; align-items: center; justify-content: center; width: 1.5rem; height: 1.5rem; border-radius: var(--hrl-radius-pill); background: var(--hrl-bg); color: var(--hrl-ink); flex: none; }
+.hrl-mode--office, .hrl-mode--wfh { background: var(--hrl-ok-bg); color: var(--hrl-ok); }
+.hrl-mode--travelling, .hrl-mode--outside_meeting, .hrl-mode--meeting { background: var(--hrl-info-bg); color: var(--hrl-accent); }
+.hrl-mode--lunch, .hrl-mode--short_break, .hrl-mode--busy, .hrl-mode--out_of_office { background: var(--hrl-warn-bg); color: var(--hrl-warn); }
+.hrl-mode--sick_leave, .hrl-mode--on_leave, .hrl-mode--holiday { background: var(--hrl-warn-bg); color: var(--hrl-warn); }
+.hrl-mode--auto::after { content: ""; position: absolute; right: -1px; bottom: -1px; width: 7px; height: 7px; border-radius: var(--hrl-radius-pill); background: var(--hrl-muted); border: 1.5px solid var(--hrl-card); }
+.hrl-mode-switch { display: grid; grid-template-columns: repeat(auto-fill, minmax(9rem, 1fr)); gap: var(--hrl-gap-target); margin-top: .5rem; }
+.hrl-mode-switch > details { grid-column: 1 / -1; }
+
+/* Work-time charts: one colour per mode, server-drawn SVG. */
+:root { --hrl-mode-office: #047857; --hrl-mode-wfh: #0d9488; --hrl-mode-travelling: #2563eb; --hrl-mode-outside-meeting: #0891b2; --hrl-mode-meeting: #4f46e5; --hrl-mode-busy: #b45309; --hrl-mode-lunch: #f59e0b; --hrl-mode-short-break: #fcd34d; --hrl-mode-out-of-office: #78716c; --hrl-mode-offline: #d1d5db; }
+.hrl-fill--office { fill: var(--hrl-mode-office); } .hrl-stroke--office { stroke: var(--hrl-mode-office); } .hrl-fill-bg--office { background: var(--hrl-mode-office); }
+.hrl-fill--wfh { fill: var(--hrl-mode-wfh); } .hrl-stroke--wfh { stroke: var(--hrl-mode-wfh); } .hrl-fill-bg--wfh { background: var(--hrl-mode-wfh); }
+.hrl-fill--travelling { fill: var(--hrl-mode-travelling); } .hrl-stroke--travelling { stroke: var(--hrl-mode-travelling); } .hrl-fill-bg--travelling { background: var(--hrl-mode-travelling); }
+.hrl-fill--outside_meeting { fill: var(--hrl-mode-outside-meeting); } .hrl-stroke--outside_meeting { stroke: var(--hrl-mode-outside-meeting); } .hrl-fill-bg--outside_meeting { background: var(--hrl-mode-outside-meeting); }
+.hrl-fill--meeting { fill: var(--hrl-mode-meeting); } .hrl-stroke--meeting { stroke: var(--hrl-mode-meeting); } .hrl-fill-bg--meeting { background: var(--hrl-mode-meeting); }
+.hrl-fill--busy { fill: var(--hrl-mode-busy); } .hrl-stroke--busy { stroke: var(--hrl-mode-busy); } .hrl-fill-bg--busy { background: var(--hrl-mode-busy); }
+.hrl-fill--lunch { fill: var(--hrl-mode-lunch); } .hrl-stroke--lunch { stroke: var(--hrl-mode-lunch); } .hrl-fill-bg--lunch { background: var(--hrl-mode-lunch); }
+.hrl-fill--short_break { fill: var(--hrl-mode-short-break); } .hrl-stroke--short_break { stroke: var(--hrl-mode-short-break); } .hrl-fill-bg--short_break { background: var(--hrl-mode-short-break); }
+.hrl-fill--out_of_office { fill: var(--hrl-mode-out-of-office); } .hrl-stroke--out_of_office { stroke: var(--hrl-mode-out-of-office); } .hrl-fill-bg--out_of_office { background: var(--hrl-mode-out-of-office); }
+.hrl-fill--offline { fill: var(--hrl-mode-offline); } .hrl-stroke--offline { stroke: var(--hrl-mode-offline); } .hrl-fill-bg--offline { background: var(--hrl-mode-offline); }
+.hrl-chart-row { display: grid; gap: var(--hrl-gap-target); }
+@media (min-width: 481px) { .hrl-chart-row { grid-template-columns: 10rem 1fr; align-items: center; } }
+.hrl-donut { width: 10rem; max-width: 100%; transform: rotate(0deg); }
+.hrl-donut__track { stroke: var(--hrl-bg); }
+.hrl-swatch { display: inline-block; width: .7rem; height: .7rem; border-radius: var(--hrl-radius-pill); vertical-align: middle; }
+.hrl-chart-scroll { overflow-x: auto; }
+.hrl-bars { width: 100%; min-width: 16rem; height: 10rem; }
+.hrl-bars__label { font-size: 5px; fill: var(--hrl-muted); }
+.hrl-timeline { width: 100%; height: 2rem; background: var(--hrl-bg); border-radius: var(--hrl-radius-sm); }
+.hrl-timeline__auto { stroke: var(--hrl-card); stroke-width: .3; stroke-dasharray: .6 .4; }
+.hrl-timeline__axis { display: flex; justify-content: space-between; }
+.hrl-timeline__list { margin: .5rem 0 0; padding-left: 1.2rem; display: grid; gap: .25rem; }
+.hrl-chart-tip { position: absolute; z-index: 30; max-width: 16rem; padding: .4rem .6rem; border-radius: var(--hrl-radius-sm); background: var(--hrl-ink); color: var(--hrl-card); font-size: var(--hrl-t-small); pointer-events: none; }
+[data-hrl-tip]:focus { outline: 2px solid var(--hrl-accent); outline-offset: 1px; }
+.hrl-custom-status { display: inline-flex; gap: .3rem; align-items: center; overflow-wrap: anywhere; }
+.hrl-emoji-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(2.75rem, 1fr)); gap: .25rem; margin-top: .4rem; }
+.hrl-emoji { min-height: var(--hrl-target); border: 1px solid var(--hrl-line); border-radius: var(--hrl-radius-sm); background: var(--hrl-card); font-size: 1.25rem; cursor: pointer; }
+/* Today's check-ins: one initials badge per person; hover/tap shows times. */
+.hrl-checkins + .hrl-checkins { margin-top: .6rem; }
+.hrl-checkins__people { display: flex; flex-wrap: wrap; gap: var(--hrl-gap-target); margin: .4rem 0 0; padding: 0; list-style: none; }
+.hrl-person { width: var(--hrl-target); height: var(--hrl-target); border-radius: var(--hrl-radius-pill); border: 2px solid var(--hrl-line); background: var(--hrl-bg); color: var(--hrl-ink); font-size: var(--hrl-t-small); font-weight: 600; cursor: pointer; }
+.hrl-person--ok { border-color: var(--hrl-ok); background: var(--hrl-ok-bg); color: var(--hrl-ok); }
+.hrl-person--warn { border-color: var(--hrl-warn); background: var(--hrl-warn-bg); color: var(--hrl-warn); }

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

@@ -25,17 +25,20 @@ module HrLite
       # The current week counts only the days already over.
       def week
         @monday = parse_date_param(params[:date]).beginning_of_week(:monday)
-        calendar = WorkingCalendar.new(@monday..(@monday + 4))
-        days = (@monday..[ @monday + 4, Date.current - 1 ].min).select { |d| calendar.working_day?(d) }
+        span = @monday..[ @monday + 4, Date.current - 1 ].min
+        calendars = WorkingCalendar.by_office(@monday..(@monday + 4))
         visible = hr_access.visible_user_ids("attendance.view")
         employees = HrLite.active_employees(on: @monday)
         employees = employees.select { |user| visible.include?(user.id) } if visible
-        records = AttendanceRecord.where(user_id: employees.map(&:id), date: days).group_by(&:user_id)
-        on_leave = days.index_with { |d| LeaveRequest.active_on(d).where(half_day: false).pluck(:user_id) }
+        offices = EmployeeProfile.where(user_id: employees.map(&:id)).pluck(:user_id, :office_location_id).to_h
+        records = AttendanceRecord.where(user_id: employees.map(&:id), date: span).group_by(&:user_id)
+        on_leave = span.index_with { |d| LeaveRequest.active_on(d).where(half_day: false).pluck(:user_id) }
         week_hours = HrLite.config.work_hours&.dig(:week)
 
         @rows = employees.map do |user|
-          worked = records.fetch(user.id, []).filter_map(&:worked_duration)
+          # Each person's own working days: their office's holidays are off.
+          days = span.select { |d| calendars[offices[user.id]].working_day?(d) }
+          worked = records.fetch(user.id, []).select { |r| days.include?(r.date) }.filter_map(&:worked_duration)
           hours = worked.sum / 3600.0
           target = week_hours && week_hours * days.count { |d| on_leave[d].exclude?(user.id) } / 5.0
           { user: user, hours: hours, avg: worked.any? ? hours / worked.size : nil, target: target,

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

@@ -116,7 +116,7 @@ module HrLite
           :date_of_exit, :probation_until, :department, :work_location, :pan_number, :pf_uan, :esi_number,
           :bank_account_number, :bank_ifsc, :bank_name, :tax_regime, :declared_annual_deductions,
           :fy_opening_gross, :fy_opening_tds, :blood_group, :emergency_contact,
-          :buffer_minutes, :buffer_reason, :buffer_note, :permanent_wfh
+          :buffer_minutes, :buffer_reason, :buffer_note, :permanent_wfh, :field_staff, :office_location_id
         )
       end
 

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

@@ -4,14 +4,15 @@ module HrLite
       def index
         year = params[:year].to_i
         @year = year.between?(2000, 2100) ? year : Date.current.year
-        @holidays = Holiday.where(date: Date.new(@year, 1, 1)..Date.new(@year, 12, 31)).order(:date)
+        @holidays = Holiday.includes(:office_location).where(date: Date.new(@year, 1, 1)..Date.new(@year, 12, 31)).order(:date)
         @holiday = Holiday.new
+        @offices = OfficeLocation.order(:name).pluck(:name, :id)
       end
 
       def create
         @holiday = Holiday.new(holiday_params)
         if @holiday.save
-          announce("Holiday added: #{@holiday.name} on #{@holiday.date.strftime('%a %d %b %Y')}")
+          announce("Holiday added: #{@holiday.name} on #{@holiday.date.strftime('%a %d %b %Y')}", @holiday.office_location_id)
           redirect_to admin_holidays_path(year: @holiday.date.year), notice: "Holiday added."
         else
           redirect_to admin_holidays_path, alert: @holiday.errors.full_messages.to_sentence
@@ -34,9 +35,11 @@ module HrLite
                     notice: "Holiday removed.", status: :see_other
       end
 
-      # Bulk paste: one "YYYY-MM-DD, Name[, optional]" per line. Reports
-      # per-line problems, skips duplicates silently.
+      # Bulk paste: one "YYYY-MM-DD, Name[, optional]" per line, all for the
+      # chosen office (blank = every office). Reports per-line problems, skips
+      # duplicates silently.
       def bulk_create
+        office_id = OfficeLocation.find_by(id: params[:office_location_id])&.id
         created = 0
         problems = []
 
@@ -50,13 +53,13 @@ module HrLite
             problems << "Line #{number}: expected YYYY-MM-DD, Name"
             next
           end
-          next if Holiday.exists?(date: date)
+          next if Holiday.exists?(date: date, office_location_id: office_id)
 
-          Holiday.create!(date: date, name: name_part, optional: flag.to_s.casecmp?("optional"))
+          Holiday.create!(date: date, name: name_part, optional: flag.to_s.casecmp?("optional"), office_location_id: office_id)
           created += 1
         end
 
-        announce("#{created} holiday#{'s' unless created == 1} added to the calendar") if created.positive?
+        announce("#{created} holiday#{'s' unless created == 1} added to the calendar", office_id) if created.positive?
         message = "#{created} holiday#{'s' unless created == 1} added."
         message += " Problems: #{problems.join('; ')}" if problems.any?
         redirect_to admin_holidays_path, problems.any? ? { alert: message } : { notice: message }
@@ -64,13 +67,18 @@ module HrLite
 
       private
 
-      def announce(title)
+      # An office's holiday goes to that office's people; an all-office one to everyone.
+      def announce(title, office_id)
         staff = HrLite.active_employees
+        if office_id
+          in_office = EmployeeProfile.where(office_location_id: office_id).pluck(:user_id).to_set
+          staff = staff.select { |u| in_office.include?(u.id) }
+        end
         Notifications.publish("holiday.published", title: title, path: "/holidays", bell_to: staff, email_to: staff)
       end
 
       def holiday_params
-        params.require(:holiday).permit(:date, :name, :optional)
+        params.require(:holiday).permit(:date, :name, :optional, :office_location_id)
       end
     end
   end

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

@@ -7,7 +7,7 @@ module HrLite
 
       def update
         @setting = Setting.instance
-        if @setting.update(params.require(:setting).permit(:weekend_policy, :employee_code_prefix))
+        if @setting.update(params.require(:setting).permit(:weekend_policy, :employee_code_prefix, :lunch_break_minutes, :short_break_minutes))
           redirect_to edit_admin_setting_path, notice: "Settings saved."
         else
           render :edit, status: :unprocessable_entity

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

@@ -0,0 +1,41 @@
+module HrLite
+  module Admin
+    # HR approves the WFH locations employees register. Coordinates are only
+    # shown here, inside attendance.view reach.
+    class WorkLocationsController < BaseController
+      def index
+        @status = params[:status].presence_in(WorkLocation::STATUSES) || "pending"
+        @locations = paginate(hr_scope(WorkLocation.where(status: @status), "attendance.view")
+                                .includes(:user).order(created_at: :desc))
+      end
+
+      def approve
+        decide("approved", params[:decision_note].to_s.strip.presence)
+      end
+
+      def reject
+        note = params[:decision_note].to_s.strip
+        return redirect_to admin_work_locations_path, alert: "A note is required to reject." if note.blank?
+
+        decide("rejected", note)
+      end
+
+      private
+
+      def decide(status, note)
+        location = hr_scope(WorkLocation.all, "attendance.manage").where.not(user_id: hr_current_user.id).find(params[:id])
+        location.decide!(status, actor: hr_current_user, note: note)
+        begin
+          Notifications.publish("work_location.#{status}", title: "WFH location #{status} — #{location.name}",
+                                                          body: note, path: "/work_locations",
+                                                          bell_to: [ location.user ], email_to: [ location.user ])
+        rescue => e
+          Rails.logger.error("[hr_lite] work location notification failed: #{e.class}: #{e.message}")
+        end
+        redirect_to admin_work_locations_path, notice: "Location #{status}."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_work_locations_path, alert: "Only pending locations can be decided."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module HrLite
+  module Admin
+    # Who is in which mode (live today, "during the day" for past dates), who
+    # needs a look, field check-ins, one person's timeline, and HR override.
+    # Locations and trip details show here only, inside attendance.view reach.
+    class WorkModesController < BaseController
+      def index
+        @date = params[:date].present? ? parse_date_param(params[:date]) : Date.current
+        visible = hr_access.visible_user_ids("attendance.view")
+        employees = HrLite.active_employees(on: @date)
+        employees = employees.select { |u| visible.include?(u.id) } if visible
+        if (dept = params[:department].presence)
+          in_dept = EmployeeProfile.where(department: dept).pluck(:user_id).to_set
+          employees = employees.select { |u| in_dept.include?(u.id) }
+        end
+        @departments = EmployeeProfile.where.not(department: [ nil, "" ]).distinct.order(:department).pluck(:department)
+        ids = employees.map(&:id)
+        @people = employees.index_by(&:id)
+
+        @by_mode = @date == Date.current ? live_modes(ids) : day_modes(ids)
+        records = AttendanceRecord.for_date(@date).where(user_id: ids).index_by(&:user_id)
+        on_leave = LeaveRequest.active_on(@date).where(user_id: ids, half_day: false).pluck(:user_id).to_set
+        calendars = WorkingCalendar.by_office(@date..@date)
+        offices = EmployeeProfile.where(user_id: ids).pluck(:user_id, :office_location_id).to_h
+        @needs_review = @date > Date.current ? [] : ids.select do |id|
+          calendars[offices[id]].working_day?(@date) && !on_leave.include?(id) && !records[id]&.check_in_at
+        end
+        @field = records.values.select { |r| %w[travelling outside_meeting].include?(r.work_mode) }
+        @field_events = WorkModeEvent.where(attendance_record_id: @field.map(&:id), source: "system", mode: %w[travelling outside_meeting])
+                                     .index_by(&:attendance_record_id)
+
+        if (@person = params[:user_id].presence && @people[params[:user_id].to_i])
+          day = @date.in_time_zone(HrLite.config.time_zone).all_day
+          @timeline = WorkModeEvent.where(user_id: @person.id).where("started_at <= ? AND (ended_at IS NULL OR ended_at >= ?)", day.last, day.first)
+                                   .order(:started_at, :id).limit(200)
+          @locations = WorkLocation.where(id: @timeline.filter_map(&:work_location_id)).index_by(&:id)
+        end
+      end
+
+      def override
+        employee = HrLite.user_klass.find(params[:user_id])
+        hr_require_reach!("attendance.manage", employee)
+        raise ActiveRecord::RecordNotFound if employee.id == hr_current_user.id
+
+        result = WorkModeSwitch.call(user: employee, mode: params[:mode], source: "hr", actor: hr_current_user,
+                                     params: params.permit(:title, :client, :destination, :reason, :minutes, :until, :category, :crm_ref))
+        flash_for = result.ok? ? { notice: "#{hr_display_name(employee)} is now: #{result.event.label}." } : { alert: result.error }
+        redirect_back fallback_location: admin_attendance_path(employee.id), **flash_for
+      end
+
+      private
+
+      # mode => user ids, from the live status (primary and overlay both count).
+      def live_modes(ids)
+        WorkStatus.for_users(ids).each_with_object(Hash.new { |h, k| h[k] = [] }) do |(id, st), out|
+          out[st.primary.mode] << id
+          out[st.overlay.mode] << id if st.overlay
+        end
+      end
+
+      # A past date: everyone who spent any time in each mode that day.
+      def day_modes(ids)
+        day = @date.in_time_zone(HrLite.config.time_zone).all_day
+        rows = WorkModeEvent.work.where(user_id: ids).where("started_at <= ? AND (ended_at IS NULL OR ended_at >= ?)", day.last, day.first)
+                            .distinct.pluck(:mode, :user_id)
+        out = rows.group_by(&:first).transform_values { |pairs| pairs.map(&:last).uniq }
+        out["on_leave"] = LeaveRequest.active_on(@date).where(user_id: ids, half_day: false).pluck(:user_id).uniq
+        out
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module HrLite
+  module Admin
+    # Work-time analytics for HR: one person (audited) or a department
+    # aggregate. Needs work_analytics.view; its scope decides whose rows.
+    class WorkTimeController < BaseController
+      before_action do
+        raise ActiveRecord::RecordNotFound unless HrLite.config.office_geofence
+        hr_access_denied unless hr_can?("work_analytics.view", scope: :team)
+      end
+
+      def index
+        @period, @period_error = WorkModeDurations::Period.from_params(params, Date.current)
+        visible = hr_access.visible_user_ids("work_analytics.view")
+        @employees = HrLite.employees.reject { |u| visible && !visible.include?(u.id) }
+        @departments = EmployeeProfile.where(user_id: @employees.map(&:id)).where.not(department: [ nil, "" ])
+                                      .distinct.order(:department).pluck(:department)
+        if (dept = params[:department].presence)
+          in_dept = EmployeeProfile.where(department: dept).pluck(:user_id).to_set
+          @employees = @employees.select { |u| in_dept.include?(u.id) }
+        end
+        @names = @employees.to_h { |u| [ u.id, hr_display_name(u) ] }
+
+        if params[:user_id].present?
+          @person = HrLite.user_klass.find(params[:user_id])
+          hr_require_reach!("work_analytics.view", @person)
+          @names[@person.id] = hr_display_name(@person)
+          ids = [ @person.id ]
+          AuditLog.record!(action: "work_analytics.viewed", subject: @person, actor: hr_current_user,
+                           changes: { "period" => @period.label })
+        else
+          ids = @employees.map(&:id)
+        end
+
+        @result = WorkModeDurations.call(ids, @period)
+        @records = @person ? AttendanceRecord.where(user_id: @person.id, date: @period.from..@period.to).where.not(check_in_at: nil).order(:date).limit(400) : []
+      end
+    end
+  end
+end

data/app/controllers/hr_lite/attendance_controller.rb

@@ -51,7 +51,8 @@ module HrLite
     private
 
     def punch(kind)
-      result = AttendancePuncher.call(user: hr_current_user, kind: kind, **punch_params.to_h.symbolize_keys)
+      field = params.fetch(:field, {}).permit(:mode, :purpose, :place).to_h
+      result = AttendancePuncher.call(user: hr_current_user, kind: kind, field: field, **punch_params.to_h.symbolize_keys)
       if result.ok?
         time = Time.current.strftime("%H:%M")
         redirect_to attendance_path, notice: "#{kind == :check_in ? 'Checked in' : 'Checked out'} at #{time}."

data/app/controllers/hr_lite/calendar_controller.rb

@@ -6,8 +6,9 @@ module HrLite
     def show
       @month = parse_month_param(params[:month])
       range = @month.beginning_of_month..@month.end_of_month
-      @calendar = WorkingCalendar.new(range)
-      @holidays = Holiday.in_range(range).order(:date).group_by(&:date)
+      office = WorkingCalendar.office_for(hr_current_user.id) # the viewer's office's holidays
+      @calendar = WorkingCalendar.new(range, office_id: office)
+      @holidays = Holiday.in_range(range).for_office(office).order(:date).group_by(&:date)
       @leaves = LeaveRequest.approved.includes(:leave_type, :user)
                             .overlapping_range(range.first, range.last)
                             .each_with_object(Hash.new { |h, k| h[k] = [] }) do |request, acc|

data/app/controllers/hr_lite/comp_off_requests_controller.rb

@@ -39,7 +39,7 @@ module HrLite
 
     # Most recent non-working day — the day they most likely worked extra.
     def default_date
-      calendar = WorkingCalendar.new((Date.current - 14)..Date.current)
+      calendar = WorkingCalendar.for_user(hr_current_user.id, (Date.current - 14)..Date.current)
       (0..14).map { |i| Date.current - i }.find { |d| !calendar.working_day?(d) } || Date.current
     end
   end

data/app/controllers/hr_lite/holidays_controller.rb

@@ -3,8 +3,9 @@ module HrLite
     def index
       year = params[:year].to_i
       @year = year.between?(2000, 2100) ? year : Date.current.year
-      @holidays = Holiday.where(date: Date.new(@year, 1, 1)..Date.new(@year, 12, 31)).order(:date)
-      @next_holiday_id = Holiday.company_wide.upcoming.pick(:id)
+      office = WorkingCalendar.office_for(hr_current_user.id) # yours plus the all-office ones
+      @holidays = Holiday.for_office(office).where(date: Date.new(@year, 1, 1)..Date.new(@year, 12, 31)).order(:date)
+      @next_holiday_id = Holiday.company_wide.for_office(office).upcoming.pick(:id)
     end
   end
 end

data/app/controllers/hr_lite/team_controller.rb

@@ -6,6 +6,19 @@ module HrLite
     def show
       @date = parse_date_param(params[:date])
       @board = TeamDay.new(date: @date)
+      return unless HrLite.config.office_geofence && @date == Date.current
+
+      # Live work modes: labels only (Office / Home / …), never where home is.
+      @statuses = WorkStatus.for_users(@board.rows.map { |r| r.user.id })
+      @departments = @board.rows.filter_map { |r| r.profile&.department.presence }.uniq.sort
+      @mode = params[:mode].presence_in(WorkModeEvent::MODES.keys + WorkStatus::DERIVED.keys)
+      @availability = params[:availability].presence_in(%w[available unavailable])
+      @rows = @board.rows.select do |r|
+        st = @statuses[r.user.id]
+        (params[:department].blank? || r.profile&.department == params[:department]) &&
+          (@mode.nil? || [ st.primary.mode, st.overlay&.mode ].include?(@mode)) &&
+          (@availability.nil? || st.available? == (@availability == "available"))
+      end
     end
   end
 end

data/app/controllers/hr_lite/work_locations_controller.rb

@@ -0,0 +1,44 @@
+module HrLite
+  # Employee's own WFH locations. Scoping to hr_current_user is the
+  # authorization; coordinates arrive only from the device capture.
+  class WorkLocationsController < ApplicationController
+    def index
+      @locations = WorkLocation.live.where(user_id: hr_current_user.id).order(:created_at)
+      @location = WorkLocation.new
+    end
+
+    def create
+      @location = WorkLocation.new(params.permit(:name, :address, :lat, :lng, :accuracy_m)
+                                         .merge(user_id: hr_current_user.id, status: "pending"))
+      saved = WorkLocation.transaction { HrLite.user_klass.lock.find(hr_current_user.id) && @location.save }
+      unless saved
+        @locations = WorkLocation.live.where(user_id: hr_current_user.id).order(:created_at)
+        return render :index, status: :unprocessable_entity
+      end
+
+      AuditLog.record!(action: "work_location.requested", subject: @location, actor: hr_current_user, changes: { "name" => @location.name })
+      notify("work_location.requested", "#{HrLite.display_name(hr_current_user)} registered a WFH location: #{@location.name}",
+             "/admin/work_locations", HrLite.admin_users)
+      redirect_to work_locations_path, notice: "Location sent to HR for approval."
+    end
+
+    def activate
+      location = WorkLocation.approved.where(user_id: hr_current_user.id).find(params[:id])
+      location.make_active!
+      redirect_to work_locations_path, notice: "#{location.name} is now your WFH location."
+    end
+
+    def remove
+      WorkLocation.live.where(user_id: hr_current_user.id).find(params[:id]).remove!(actor: hr_current_user)
+      redirect_to work_locations_path, notice: "Location removed."
+    end
+
+    private
+
+    def notify(event, title, path, to)
+      Notifications.publish(event, title: title, path: path, bell_to: to)
+    rescue => e
+      Rails.logger.error("[hr_lite] work location notification failed: #{e.class}: #{e.message}")
+    end
+  end
+end

data/app/controllers/hr_lite/work_modes_controller.rb

@@ -0,0 +1,40 @@
+module HrLite
+  # Employee switches their own mode. hr_current_user is the only subject.
+  class WorkModesController < ApplicationController
+    before_action { raise ActiveRecord::RecordNotFound unless HrLite.config.office_geofence }
+
+    def create
+      result = WorkModeSwitch.call(user: hr_current_user, mode: params[:mode], source: "employee", actor: hr_current_user,
+                                   params: params.permit(:title, :client, :destination, :reason, :minutes, :until, :category, :crm_ref))
+      if result.ok?
+        redirect_to attendance_path, notice: "You are now: #{result.event.label}."
+      else
+        redirect_to attendance_path, alert: result.error
+      end
+    end
+
+    def status
+      result = WorkModeSwitch.set_status(user: hr_current_user, text: params[:text], emoji: params[:emoji], clear_after: params[:clear_after])
+      result.ok? ? redirect_to(attendance_path, notice: "Status set.") : redirect_to(attendance_path, alert: result.error)
+    end
+
+    def clear_status
+      WorkModeEvent.open.where(user_id: hr_current_user.id, layer: "status").find_each { |e| e.close!("ended") }
+      redirect_to attendance_path, notice: "Status cleared."
+    end
+
+    # Lead type-ahead for the meeting forms; the host decides who sees what.
+    def crm_search
+      query = params[:q].to_s.strip
+      hook = HrLite.config.crm_search
+      leads = hook && query.length >= 2 ? Array(hook.call(hr_current_user, query)).first(20) : []
+      render json: leads.map { |l| { id: l[:id].to_s, label: l[:label].to_s } }
+    end
+
+    # Ends the current break / busy / meeting early.
+    def end_overlay
+      WorkModeEvent.open.overlay.where(user_id: hr_current_user.id).find_each { |e| e.close!("ended") }
+      redirect_to attendance_path, notice: "Back to work."
+    end
+  end
+end