hr_lite 0.1.0

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

@@ -0,0 +1,74 @@
+module HrLite
+  module Admin
+    class AppraisalsController < LeadershipController
+      before_action :set_profile
+
+      def new
+        @appraisal = Appraisal.new(
+          user_id: @profile.user_id,
+          period_start: Date.current.beginning_of_year, period_end: Date.current
+        )
+      end
+
+      def create
+        @appraisal = Appraisal.new(appraisal_params.merge(
+          user_id: @profile.user_id, reviewer_id: hr_current_user.id
+        ))
+        if @appraisal.save
+          redirect_to admin_employee_path(@profile), notice: "Appraisal drafted — share when ready."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+        @appraisal = scoped.find(params[:id])
+      end
+
+      def update
+        @appraisal = scoped.find(params[:id])
+        if @appraisal.update(appraisal_params)
+          redirect_to admin_employee_path(@profile), notice: "Appraisal updated."
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def share
+        appraisal = scoped.find(params[:id])
+        appraisal.share!(actor: hr_current_user)
+        redirect_to admin_employee_path(@profile), notice: "Appraisal shared with the employee."
+      rescue ActiveRecord::RecordInvalid => e
+        message = e.record.errors.full_messages.to_sentence.presence || "This appraisal was already shared."
+        redirect_to admin_employee_path(@profile), alert: message
+      end
+
+      def destroy
+        appraisal = scoped.find(params[:id])
+        if appraisal.destroy
+          redirect_to admin_employee_path(@profile), notice: "Draft appraisal removed.", status: :see_other
+        else
+          redirect_to admin_employee_path(@profile), status: :see_other,
+                      alert: appraisal.errors.full_messages.to_sentence
+        end
+      end
+
+      private
+
+      def set_profile
+        @profile = EmployeeProfile.find(params[:employee_id])
+      end
+
+      def scoped
+        Appraisal.where(user_id: @profile.user_id)
+      end
+
+      def appraisal_params
+        params.require(:appraisal).permit(
+          :period_start, :period_end, :rating, :strengths, :improvements,
+          :outcome, :effective_date, :new_designation
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module HrLite
+  module Admin
+    class AttendancesController < BaseController
+      # Team day view: everyone × their punch/status for one date.
+      def index
+        @date = parse_date_param(params[:date])
+        @employees = HrLite.employees
+        @records = AttendanceRecord.for_date(@date).where(user_id: @employees.map(&:id)).index_by(&:user_id)
+        @flagged_count = @records.values.count(&:flagged?)
+      end
+
+      # One employee's month + the regularization form for ?date=.
+      def show
+        @employee = HrLite.user_klass.find(params[:user_id])
+        @month = parse_month_param(params[:month])
+        @day_status = DayStatus.new(user: @employee, range: @month.beginning_of_month..@month.end_of_month)
+        @counts = @day_status.counts
+        @edit_date = params[:date].present? ? parse_date_param(params[:date]) : nil
+        @edit_record = @edit_date && AttendanceRecord.find_or_initialize_by(user_id: @employee.id, date: @edit_date)
+      end
+
+      # Regularization: fix punches with a mandatory note, fully audited.
+      # Clearing both punch times deletes the record (that is how an
+      # erroneous punch is removed).
+      def update
+        @employee = HrLite.user_klass.find(params[:user_id])
+        date = parse_date_param(params[:date])
+        record = AttendanceRecord.find_or_initialize_by(user_id: @employee.id, date: date)
+
+        note = params.dig(:attendance_record, :regularization_note).to_s.strip
+        if note.blank?
+          return redirect_to admin_attendance_path(@employee.id, date: date, month: date.strftime("%Y-%m")),
+                             alert: "A regularization note is required."
+        end
+
+        attrs = params.require(:attendance_record).permit(:check_in_at, :check_out_at, :status)
+        if attrs[:check_in_at].blank? && attrs[:check_out_at].blank?
+          record.destroy if record.persisted?
+          log_regularization(record, note, removed: true)
+          return redirect_to admin_attendance_path(@employee.id, month: date.strftime("%Y-%m")),
+                             notice: "Punch removed."
+        end
+
+        record.assign_attributes(attrs)
+        record.status = "present" if record.status.blank?
+        record.regularized_by_id = hr_current_user.id
+        record.regularized_at = Time.current
+        record.regularization_note = note
+
+        if record.save
+          log_regularization(record, note, removed: false)
+          redirect_to admin_attendance_path(@employee.id, month: date.strftime("%Y-%m")),
+                      notice: "Attendance updated."
+        else
+          redirect_to admin_attendance_path(@employee.id, date: date, month: date.strftime("%Y-%m")),
+                      alert: record.errors.full_messages.to_sentence
+        end
+      end
+
+      private
+
+      def log_regularization(record, note, removed:)
+        AuditLog.create!(
+          actor: hr_current_user, action: removed ? "destroy" : "regularize",
+          subject_type: record.class.name, subject_id: record.id || 0,
+          audited_changes: { "date" => record.date.to_s, "note" => note }
+        )
+        Notifications.publish(
+          "attendance.regularized",
+          title: "Attendance #{removed ? 'punch removed' : 'regularized'} for #{record.date.strftime('%d %b')}",
+          body: note,
+          path: "/attendance?month=#{record.date.strftime('%Y-%m')}",
+          bell_to: [ record.user ],
+          email_to: [ record.user ]
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module HrLite
+  module Admin
+    class AuditLogsController < LeadershipController
+      def index
+        @audit_logs = paginate(AuditLog.recent.includes(:actor))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module HrLite
+  module Admin
+    # Day-to-day operations tier: overview board, team attendance,
+    # leave decisions, balance adjustments. Leadership members are
+    # allowed too — governing implies at least operational visibility.
+    class BaseController < ApplicationController
+      before_action :require_hr_admin!
+
+      private
+
+      def require_hr_admin!
+        hr_access_denied unless hr_admin? || hr_leadership?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module HrLite
+  module Admin
+    # Standalone role change (promotion without an appraisal).
+    class DesignationChangesController < LeadershipController
+      before_action :set_profile
+
+      def new
+        @change = DesignationChange.new(user_id: @profile.user_id, effective_date: Date.current)
+      end
+
+      def create
+        @change = DesignationChange.new(change_params.merge(
+          user_id: @profile.user_id, created_by_id: hr_current_user.id
+        ))
+        if @change.save
+          redirect_to admin_employee_path(@profile), notice: "Role change recorded."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      def set_profile
+        @profile = EmployeeProfile.find(params[:employee_id])
+      end
+
+      def change_params
+        params.require(:designation_change).permit(:to_designation, :effective_date, :note)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module HrLite
+  module Admin
+    # Employee HR profiles (leadership). No destroy — exits are a date;
+    # payroll history is a statutory record.
+    class EmployeesController < LeadershipController
+      def index
+        @profiles = paginate(EmployeeProfile.includes(:user).order(:employee_code))
+        @users_without_profile = HrLite.employees.reject { |u| EmployeeProfile.exists?(user_id: u.id) }
+      end
+
+      def show
+        @profile = EmployeeProfile.includes(:user).find(params[:id])
+        @structures = SalaryStructure.where(user_id: @profile.user_id).order(effective_from: :desc)
+      end
+
+      def new
+        @profile = EmployeeProfile.new(user_id: params[:user_id], date_of_joining: Date.current)
+      end
+
+      def create
+        @profile = EmployeeProfile.new(profile_params)
+        if @profile.save
+          redirect_to admin_employee_path(@profile), notice: "Employee profile created."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+        @profile = EmployeeProfile.find(params[:id])
+      end
+
+      def update
+        @profile = EmployeeProfile.find(params[:id])
+        if @profile.update(profile_params)
+          redirect_to admin_employee_path(@profile), notice: "Employee profile updated."
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      def profile_params
+        params.require(:employee_profile).permit(
+          :user_id, :employee_code, :designation, :date_of_birth, :date_of_joining,
+          :date_of_exit, :department, :work_location, :pan_number, :pf_uan, :esi_number,
+          :bank_account_number, :bank_ifsc, :bank_name, :tax_regime, :declared_annual_deductions
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module HrLite
+  module Admin
+    class HolidaysController < LeadershipController
+      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)
+        @holiday = Holiday.new
+      end
+
+      def create
+        @holiday = Holiday.new(holiday_params)
+        if @holiday.save
+          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
+        end
+      end
+
+      def update
+        holiday = Holiday.find(params[:id])
+        if holiday.update(holiday_params)
+          redirect_to admin_holidays_path(year: holiday.date.year), notice: "Holiday updated."
+        else
+          redirect_to admin_holidays_path, alert: holiday.errors.full_messages.to_sentence
+        end
+      end
+
+      def destroy
+        holiday = Holiday.find(params[:id])
+        holiday.destroy!
+        redirect_to admin_holidays_path(year: holiday.date.year),
+                    notice: "Holiday removed.", status: :see_other
+      end
+
+      # Bulk paste: one "YYYY-MM-DD, Name[, optional]" per line. Reports
+      # per-line problems, skips duplicates silently.
+      def bulk_create
+        created = 0
+        problems = []
+
+        params[:lines].to_s.each_line.with_index(1) do |line, number|
+          line = line.strip
+          next if line.blank?
+
+          date_part, name_part, flag = line.split(",", 3).map { |part| part.to_s.strip }
+          date = Date.strptime(date_part.to_s, "%Y-%m-%d") rescue nil
+          if date.nil? || name_part.blank?
+            problems << "Line #{number}: expected YYYY-MM-DD, Name"
+            next
+          end
+          next if Holiday.exists?(date: date)
+
+          Holiday.create!(date: date, name: name_part, optional: flag.to_s.casecmp?("optional"))
+          created += 1
+        end
+
+        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 }
+      end
+
+      private
+
+      def holiday_params
+        params.require(:holiday).permit(:date, :name, :optional)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module HrLite
+  module Admin
+    # Governing tier: anything that changes policy or money — leave types,
+    # settings, office locations, holidays, employee profiles, salary
+    # structures, payroll, appraisals, audit trail. Leadership ONLY;
+    # being a host-app admin is not enough.
+    class LeadershipController < BaseController
+      skip_before_action :require_hr_admin!
+      before_action :require_hr_leadership!
+
+      private
+
+      def require_hr_leadership!
+        hr_access_denied unless hr_leadership?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module HrLite
+  module Admin
+    class LeaveBalancesController < BaseController
+      def index
+        year = params[:year].to_i
+        @year = year.between?(2000, 2100) ? year : Date.current.year
+        @types = LeaveType.active.where(paid: true).where.not(annual_quota: nil)
+        @employees = HrLite.employees
+      end
+
+      # Manual credit/debit — also the comp-off credit mechanism.
+      def adjust
+        user = HrLite.user_klass.find(params[:user_id])
+        type = LeaveType.find(params[:leave_type_id])
+        year = params[:year].to_i
+        delta = BigDecimal(params[:delta].to_s)
+        note = params[:note].to_s.strip
+
+        if note.blank?
+          return redirect_to admin_leave_balances_path(year: year), alert: "A note is required."
+        end
+
+        balance = LeaveBalance.for(user, type, year)
+        balance.adjustment += delta
+        balance.adjustment_note = [ balance.adjustment_note.presence, "#{delta.to_f} — #{note}" ].compact.join("; ")
+        balance.save!
+
+        AuditLog.create!(
+          actor: hr_current_user, action: "adjust",
+          subject_type: balance.class.name, subject_id: balance.id,
+          audited_changes: { "user" => HrLite.display_name(user), "type" => type.code,
+                             "delta" => delta.to_f, "note" => note }
+        )
+        redirect_to admin_leave_balances_path(year: year),
+                    notice: "Balance adjusted for #{HrLite.display_name(user)}."
+      rescue ArgumentError
+        redirect_to admin_leave_balances_path, alert: "Enter a valid adjustment number."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module HrLite
+  module Admin
+    class LeaveRequestsController < BaseController
+      def index
+        scope = LeaveRequest.includes(:leave_type, :user).recent_first
+        @status = params[:status].presence_in(LeaveRequest::STATUSES) || "pending"
+        @requests = paginate(scope.where(status: @status))
+      end
+
+      def show
+        @request = LeaveRequest.includes(:leave_type).find(params[:id])
+        @balance = @request.balance
+      end
+
+      def approve
+        request = LeaveRequest.find(params[:id])
+        if request.approve!(actor: hr_current_user, note: params[:decision_note].presence)
+          redirect_to admin_leave_requests_path, notice: "Leave approved."
+        else
+          redirect_to admin_leave_request_path(request),
+                      alert: "Cannot approve — balance no longer covers this request."
+        end
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_leave_request_path(request), alert: "Only pending requests can be decided."
+      end
+
+      def reject
+        request = LeaveRequest.find(params[:id])
+        note = params[:decision_note].to_s.strip
+        if note.blank?
+          return redirect_to admin_leave_request_path(request), alert: "A note is required to reject."
+        end
+
+        request.reject!(actor: hr_current_user, note: note)
+        redirect_to admin_leave_requests_path, notice: "Leave rejected."
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_leave_request_path(request), alert: "Only pending requests can be decided."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module HrLite
+  module Admin
+    class LeaveTypesController < LeadershipController
+      def index
+        @leave_types = LeaveType.order(:position, :id)
+      end
+
+      def new
+        @leave_type = LeaveType.new
+      end
+
+      def create
+        @leave_type = LeaveType.new(leave_type_params)
+        if @leave_type.save
+          redirect_to admin_leave_types_path, notice: "Leave type created."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+        @leave_type = LeaveType.find(params[:id])
+      end
+
+      def update
+        @leave_type = LeaveType.find(params[:id])
+        if @leave_type.update(leave_type_params)
+          redirect_to admin_leave_types_path, notice: "Leave type updated."
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      # Types with history cannot be destroyed — deactivate instead.
+      def destroy
+        leave_type = LeaveType.find(params[:id])
+        if leave_type.destroy
+          redirect_to admin_leave_types_path, notice: "Leave type removed.", status: :see_other
+        else
+          redirect_to admin_leave_types_path, status: :see_other,
+                      alert: "This type has leave history — deactivate it instead."
+        end
+      end
+
+      private
+
+      def leave_type_params
+        params.require(:leave_type)
+              .permit(:name, :code, :color, :paid, :annual_quota, :accrual,
+                      :carry_forward_cap, :active, :position)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module HrLite
+  module Admin
+    class OfficeLocationsController < LeadershipController
+      def index
+        @office_locations = OfficeLocation.order(:name)
+      end
+
+      def new
+        @office_location = OfficeLocation.new
+      end
+
+      def create
+        @office_location = OfficeLocation.new(office_location_params)
+        if @office_location.save
+          redirect_to admin_office_locations_path, notice: "Office added."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+        @office_location = OfficeLocation.find(params[:id])
+      end
+
+      def update
+        @office_location = OfficeLocation.find(params[:id])
+        if @office_location.update(office_location_params)
+          redirect_to admin_office_locations_path, notice: "Office updated."
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        OfficeLocation.find(params[:id]).destroy!
+        redirect_to admin_office_locations_path, notice: "Office removed.", status: :see_other
+      end
+
+      private
+
+      def office_location_params
+        params.require(:office_location).permit(:name, :lat, :lng, :radius_m, :active)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module HrLite
+  module Admin
+    class OverviewController < BaseController
+      SECTION_CAP = 10
+
+      def index
+        @query = OverviewQuery.new
+        @kpis = @query.kpis
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module HrLite
+  module Admin
+    class PayrollRunsController < LeadershipController
+      def index
+        @runs = paginate(PayrollRun.recent_first)
+      end
+
+      def new
+        @run = PayrollRun.new(period_month: Date.current.prev_month.beginning_of_month)
+      end
+
+      def create
+        month = parse_month_param(params.dig(:payroll_run, :period_month))
+        @run = PayrollRun.new(period_month: month, created_by_id: hr_current_user.id,
+                              notes: params.dig(:payroll_run, :notes))
+        if @run.save
+          redirect_to admin_payroll_run_path(@run), notice: "Run created — compute when ready."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def show
+        @run = PayrollRun.find(params[:id])
+        @slips = @run.salary_slips.includes(:user).sort_by { |slip| HrLite.display_name(slip.user) }
+      end
+
+      def destroy
+        run = PayrollRun.find(params[:id])
+        if run.destroy
+          redirect_to admin_payroll_runs_path, notice: "Draft run deleted.", status: :see_other
+        else
+          redirect_to admin_payroll_run_path(run), alert: run.errors.full_messages.to_sentence,
+                      status: :see_other
+        end
+      end
+
+      def compute
+        transition { |run| run.compute!(actor: hr_current_user) && "Computed — review the slips." }
+      end
+
+      def finalize
+        transition { |run| run.finalize!(actor: hr_current_user) && "Run finalized." }
+      end
+
+      def unlock
+        transition { |run| run.unlock!(actor: hr_current_user) && "Back in review." }
+      end
+
+      def publish
+        transition { |run| run.publish!(actor: hr_current_user) && "Published — employees notified." }
+      end
+
+      # Payout register: the full money sheet including bank details —
+      # deliberately leadership-only PII.
+      def register
+        run = PayrollRun.find(params[:id])
+        send_data register_csv(run), filename: "payroll-register-#{run.period_month.strftime('%Y-%m')}.csv",
+                                     type: "text/csv"
+      end
+
+      private
+
+      def transition
+        run = PayrollRun.find(params[:id])
+        notice = yield(run)
+        redirect_to admin_payroll_run_path(run), notice: notice
+      rescue ActiveRecord::RecordInvalid
+        redirect_to admin_payroll_run_path(run), alert: "That step is not available from #{run.status}."
+      end
+
+      def register_csv(run)
+        require "csv"
+        CSV.generate do |csv|
+          csv << [ "Code", "Name", "Days", "LOP", "Gross", "PF", "ESI", "PT", "TDS",
+                   "Net pay", "Bank", "Account", "IFSC" ]
+          run.salary_slips.includes(:user).each do |slip|
+            profile = slip.user_profile
+            deductions = slip.deductions_rows.index_by { |row| row["code"] }
+            csv << [
+              profile&.employee_code, HrLite.display_name(slip.user),
+              slip.payable_days, slip.effective_lop_days,
+              slip.gross_earnings, deductions.dig("pf_employee", "amount") || 0,
+              deductions.dig("esi_employee", "amount") || 0, deductions.dig("pt", "amount") || 0,
+              deductions.dig("tds", "amount") || 0, slip.net_pay,
+              profile&.bank_name, profile&.bank_account_number, profile&.bank_ifsc
+            ]
+          end
+        end
+      end
+    end
+  end
+end