hr_lite 0.30.0 → 0.35.0

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/wfh_requests_controller.rb

@@ -0,0 +1,45 @@
+module HrLite
+  # Employee-side WFH requests. Scoping to hr_current_user IS the
+  # authorization; there is no edit, so a decided request cannot change.
+  class WfhRequestsController < ApplicationController
+    def index
+      @requests = paginate(WfhRequest.where(user_id: hr_current_user.id).recent_first)
+      @request = WfhRequest.new(start_date: Date.current, end_date: Date.current)
+      load_calendar
+    end
+
+    def create
+      @request = WfhRequest.new(params.require(:wfh_request).permit(:start_date, :end_date, :reason)
+                                      .merge(user_id: hr_current_user.id, status: "pending"))
+      # Row lock on the user: two tabs can't both pass the overlap check.
+      saved = WfhRequest.transaction { HrLite.user_klass.lock.find(hr_current_user.id) && @request.save }
+      if saved
+        @request.notify_requested
+        redirect_to wfh_requests_path, notice: "WFH request sent to HR."
+      else
+        @requests = paginate(WfhRequest.where(user_id: hr_current_user.id).recent_first)
+        load_calendar
+        render :index, status: :unprocessable_entity
+      end
+    end
+
+    def cancel
+      WfhRequest.where(user_id: hr_current_user.id).find(params[:id]).cancel!(actor: hr_current_user)
+      redirect_to wfh_requests_path, notice: "WFH request cancelled."
+    rescue ActiveRecord::RecordInvalid
+      redirect_to wfh_requests_path, alert: "Only pending requests can be cancelled."
+    end
+
+    private
+
+    # Status per date for the next 30 days; a later request wins a shared date.
+    def load_calendar
+      @window = Date.current..(Date.current + WfhRequest::MAX_DAYS_AHEAD)
+      @day_status = {}
+      WfhRequest.where(user_id: hr_current_user.id, status: %w[pending approved rejected])
+                .overlapping(@window.first, @window.last).order(:id).each do |request|
+        (request.start_date..request.end_date).each { |d| @day_status[d] = request.status if @window.cover?(d) }
+      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

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" ], 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" ] },
+      { 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,11 +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/wfh_request.rb

@@ -0,0 +1,108 @@
+module HrLite
+  # "Let me work from home on these dates." HR approves or rejects; only an
+  # approved request covering today lets a check-in skip the office geofence.
+  class WfhRequest < ApplicationRecord
+    STATUSES = %w[pending approved rejected cancelled].freeze
+    MAX_DAYS_AHEAD = 30
+    HR_MAX_DAYS = 60 # a span HR grants directly
+
+    belongs_to :user, class_name: HrLite.config.user_class
+    belongs_to :decided_by, class_name: HrLite.config.user_class, optional: true
+    belongs_to :created_by, class_name: HrLite.config.user_class, optional: true
+
+    validates :start_date, :end_date, :reason, presence: true
+    validates :status, inclusion: { in: STATUSES }
+    validate :dates_in_window, :no_overlap, on: :create
+
+    scope :pending, -> { where(status: "pending") }
+    scope :approved, -> { where(status: "approved") }
+    scope :live, -> { where(status: %w[pending approved]) }
+    scope :overlapping, ->(from, to) { where("start_date <= ? AND end_date >= ?", to, from) }
+    scope :recent_first, -> { order(start_date: :desc, id: :desc) }
+
+    STATUSES.each { |s| define_method("#{s}?") { status == s } }
+
+    def self.approved_for(user_id, date) = approved.where(user_id: user_id).overlapping(date, date).first
+
+    # HR grants WFH outright: approved on creation, up to HR_MAX_DAYS long.
+    def self.grant!(user_id:, by:, start_date:, end_date:, reason:)
+      request = create!(user_id: user_id, start_date: start_date, end_date: end_date, reason: reason,
+                        status: "approved", created_by_id: by.id, decided_by_id: by.id, decided_at: Time.current)
+      AuditLog.record!(action: "wfh.granted", subject: request, actor: by,
+                       changes: { "dates" => request.dates_label, "reason" => reason })
+      request.send(:announce, "wfh.approved", "HR gave you WFH — #{request.dates_label}", reason, "/wfh_requests", [ request.user ])
+      request
+    end
+
+    def granted? = created_by_id.present? && created_by_id != user_id
+
+    def dates_label
+      start_date == end_date ? start_date.strftime("%a %-d %b") : "#{start_date.strftime('%-d %b')} – #{end_date.strftime('%-d %b')}"
+    end
+
+    def days = (end_date - start_date).to_i + 1
+
+    def approve!(actor:, note: nil)
+      transition!("approved", actor, note)
+      announce("wfh.approved", "WFH approved — #{dates_label}", decision_note, "/wfh_requests", [ user ])
+    end
+
+    def reject!(actor:, note:)
+      transition!("rejected", actor, note)
+      announce("wfh.rejected", "WFH rejected — #{dates_label}", decision_note, "/wfh_requests", [ user ])
+    end
+
+    def cancel!(actor:)
+      transition!("cancelled", actor, nil)
+      announce("wfh.cancelled", "#{HrLite.display_name(user)} cancelled WFH for #{dates_label}", nil,
+               "/admin/wfh_requests/#{id}", HrLite.admin_users)
+    end
+
+    def notify_requested
+      AuditLog.record!(action: "wfh.requested", subject: self, actor: user,
+                       changes: { "dates" => dates_label, "reason" => reason })
+      announce("wfh.requested", "#{HrLite.display_name(user)} requested WFH for #{dates_label}", reason,
+               "/admin/wfh_requests/#{id}", HrLite.admin_users)
+    end
+
+    private
+
+    def transition!(new_status, actor, note)
+      with_lock do
+        raise ActiveRecord::RecordInvalid.new(self), "not pending" unless pending?
+
+        update!(status: new_status, decided_by_id: actor.id, decided_at: Time.current, decision_note: note)
+      end
+      AuditLog.record!(action: "wfh.#{new_status}", subject: self, actor: actor,
+                       changes: { "dates" => dates_label, "note" => note }.compact)
+      true
+    end
+
+    # A notification failure never undoes a request or a decision.
+    def announce(event, title, body, path, to)
+      Notifications.publish(event, title: title, body: body.presence, path: path, bell_to: to,
+                                   email_to: event == "wfh.requested" ? [] : to)
+    rescue => e
+      Rails.logger.error("[hr_lite] wfh notification failed: #{e.class}: #{e.message}")
+    end
+
+    def dates_in_window
+      return unless start_date && end_date
+
+      errors.add(:start_date, "cannot be in the past") if start_date < Date.current
+      errors.add(:end_date, "must be on or after the start date") if end_date < start_date
+      if granted?
+        errors.add(:end_date, "HR can grant at most #{HR_MAX_DAYS} days at a time") if days > HR_MAX_DAYS
+      elsif end_date > Date.current + MAX_DAYS_AHEAD
+        errors.add(:end_date, "must be within #{MAX_DAYS_AHEAD} days from today")
+      end
+    end
+
+    def no_overlap
+      return unless start_date && end_date && user_id
+
+      clash = self.class.live.where(user_id: user_id).overlapping(start_date, end_date).exists?
+      errors.add(:base, "You already have a pending or approved WFH request on some of these dates") if clash
+    end
+  end
+end