hr_lite 0.1.0

data/app/services/hr_lite/attendance_summary.rb

@@ -0,0 +1,98 @@
+module HrLite
+  # Month roll-up per user — the payroll contract. Exact math per date:
+  #
+  #   holiday / weekend / present / paid full-day leave  -> payable +1
+  #   unpaid full-day leave (LWP) / absent               -> lop +1
+  #   half-day punch (no leave)                          -> payable +0.5, lop +0.5
+  #   half-day PAID leave: leave half payable; other half payable if
+  #     punched, else lop (unpaid half-day leave: leave half is lop too)
+  #   future dates                                       -> upcoming (neither)
+  #   dates outside the employment window (before DOJ / after exit, when an
+  #     EmployeeProfile exists)                          -> out_of_window (neither)
+  #
+  # The window lives HERE and only here — payroll consumes payable/lop as-is
+  # and never re-clips, so a mid-month joiner is never double-penalized.
+  # For closed months: payable + lop + upcoming + out_of_window == days_in_month.
+  module AttendanceSummary
+    def self.for(user:, month:)
+      range = month.beginning_of_month..month.end_of_month
+      profile = EmployeeProfile.find_by(user_id: user.id)
+      from_day_status(DayStatus.new(user: user, range: range), range, profile: profile)
+    end
+
+    # Batch variant for team/payroll screens: 3 queries total, not 3×N.
+    def self.for_all(users:, month:)
+      users.index_with { |user| self.for(user: user, month: month) }.transform_keys(&:id)
+    end
+
+    def self.from_day_status(day_status, range, profile: nil)
+      summary = {
+        present: 0.to_d, half_day: 0.to_d, paid_leave: 0.to_d, unpaid_leave: 0.to_d,
+        holiday: 0, weekend: 0, absent: 0.to_d, upcoming: 0, out_of_window: 0,
+        payable_days: 0.to_d, lop_days: 0.to_d, days_in_month: range.count
+      }
+
+      range.each do |date|
+        if profile && !profile.active_on?(date)
+          summary[:out_of_window] += 1
+          next
+        end
+
+        day = day_status.for(date)
+        case day.kind
+        when :holiday
+          summary[:holiday] += 1
+          summary[:payable_days] += 1
+        when :weekend
+          summary[:weekend] += 1
+          summary[:payable_days] += 1
+        when :present
+          summary[:present] += 1
+          summary[:payable_days] += 1
+        when :half_day
+          summary[:half_day] += 1
+          summary[:payable_days] += BigDecimal("0.5")
+          summary[:lop_days] += BigDecimal("0.5")
+        when :leave
+          if day.leave.paid?
+            summary[:paid_leave] += 1
+            summary[:payable_days] += 1
+          else
+            summary[:unpaid_leave] += 1
+            summary[:lop_days] += 1
+          end
+        when :half_day_leave
+          apply_half_day_leave(summary, day)
+        when :upcoming
+          summary[:upcoming] += 1
+        else # :absent
+          summary[:absent] += 1
+          summary[:lop_days] += 1
+        end
+      end
+
+      summary
+    end
+
+    def self.apply_half_day_leave(summary, day)
+      half = BigDecimal("0.5")
+
+      if day.leave.paid?
+        summary[:paid_leave] += half
+        summary[:payable_days] += half
+      else
+        summary[:unpaid_leave] += half
+        summary[:lop_days] += half
+      end
+
+      if day.record&.check_in_at
+        summary[:present] += half
+        summary[:payable_days] += half
+      else
+        summary[:absent] += half
+        summary[:lop_days] += half
+      end
+    end
+    private_class_method :apply_half_day_leave
+  end
+end

data/app/services/hr_lite/calculators/esi.rb

@@ -0,0 +1,25 @@
+module HrLite
+  module Calculators
+    # ESI: eligibility is decided on the FULL structure monthly gross
+    # (a low-attendance month must not pull someone into ESI); when
+    # eligible, contributions apply to the earned gross and round UP
+    # to the next rupee (ESIC rule).
+    module Esi
+      Result = Struct.new(:applicable, :employee, :employer, keyword_init: true) do
+        def applicable? = applicable
+      end
+
+      def self.call(monthly_gross:, gross_earned:, applicable:, rates:)
+        eligible = applicable && Money.d(monthly_gross) <= rates[:gross_ceiling]
+        return Result.new(applicable: false, employee: BigDecimal(0), employer: BigDecimal(0)) unless eligible
+
+        earned = Money.d(gross_earned)
+        Result.new(
+          applicable: true,
+          employee: Money.ceil_rupee(earned * rates[:employee_rate]),
+          employer: Money.ceil_rupee(earned * rates[:employer_rate])
+        )
+      end
+    end
+  end
+end

data/app/services/hr_lite/calculators/pf.rb

@@ -0,0 +1,32 @@
+module HrLite
+  module Calculators
+    # Provident fund on earned basic. Employee 12%; employer 12% split into
+    # EPS (8.33%, wage-capped) and EPF (remainder); EDLI + admin charges are
+    # employer-cost lines. All contributions round to the nearest rupee.
+    module Pf
+      Result = Struct.new(:pf_wage, :employee, :employer_eps, :employer_epf,
+                          :edli, :admin_charges, keyword_init: true)
+
+      def self.call(basic_earned:, on_full_basic:, rates:)
+        basic = Money.d(basic_earned)
+        pf_wage = on_full_basic ? basic : [ basic, rates[:wage_ceiling] ].min
+
+        employee = Money.round_rupee(pf_wage * rates[:employee_rate])
+        employer_total = Money.round_rupee(pf_wage * rates[:employer_rate])
+        eps_wage = [ pf_wage, rates[:eps_wage_ceiling] ].min
+        eps = Money.round_rupee(eps_wage * rates[:eps_rate])
+        eps = employer_total if eps > employer_total
+        edli_wage = [ pf_wage, rates[:edli_ceiling] ].min
+
+        Result.new(
+          pf_wage: pf_wage,
+          employee: employee,
+          employer_eps: eps,
+          employer_epf: employer_total - eps,
+          edli: Money.round_rupee(edli_wage * rates[:edli_rate]),
+          admin_charges: Money.round_rupee(pf_wage * rates[:admin_rate])
+        )
+      end
+    end
+  end
+end

data/app/services/hr_lite/calculators/professional_tax.rb

@@ -0,0 +1,20 @@
+module HrLite
+  module Calculators
+    # State-slab professional tax on earned gross. Unknown states and
+    # states without PT (UP, Uttarakhand) simply yield zero. Slabs may
+    # carry a feb_extra for states that top up the February deduction.
+    module ProfessionalTax
+      def self.call(state:, gross_earned:, period_month:, rates:)
+        slabs = rates[state.to_s] || []
+        earned = Money.d(gross_earned)
+
+        slab = slabs.reverse.find { |row| earned > row[:above] }
+        return BigDecimal(0) unless slab
+
+        amount = slab[:monthly]
+        amount += slab[:feb_extra] if slab[:feb_extra] && period_month.month == 2
+        Money.round_rupee(amount)
+      end
+    end
+  end
+end

data/app/services/hr_lite/calculators/proration.rb

@@ -0,0 +1,30 @@
+module HrLite
+  module Calculators
+    # Calendar-day proration: each structure component earns
+    # full × payable/days_in_month, rounded to paise per line.
+    module Proration
+      COMPONENTS = [
+        [ "basic", "Basic" ],
+        [ "hra", "HRA" ],
+        [ "special_allowance", "Special allowance" ],
+        [ "other_earnings", "Other earnings" ]
+      ].freeze
+
+      def self.call(structure:, payable_days:, days_in_month:)
+        factor = Money.d(payable_days) / Money.d(days_in_month)
+
+        COMPONENTS.filter_map do |attribute, label|
+          full = structure.public_send(attribute)
+          next if full.nil? || full.zero?
+
+          {
+            code: attribute,
+            label: label,
+            full_amount: Money.round2(full),
+            amount: Money.round2(full * factor)
+          }
+        end
+      end
+    end
+  end
+end

data/app/services/hr_lite/calculators/tds.rb

@@ -0,0 +1,74 @@
+module HrLite
+  module Calculators
+    # Projection-grade TDS (not Form-16-grade — no surcharge, perquisites or
+    # HRA-exemption math; the per-slip override is the escape hatch and the
+    # slip shows the whole working so "why is my TDS X" answers itself).
+    #
+    #   projected annual gross = FY gross paid so far + this month
+    #                            + structure gross × months remaining after this one
+    #   taxable  = projected − standard deduction − (old regime: declared deductions)
+    #   annual   = slab tax − 87A rebate (full when taxable ≤ cap) + 4% cess, §288B rounded
+    #   monthly  = max((annual − TDS already deducted) / months remaining incl. this, 0)
+    module Tds
+      Result = Struct.new(:monthly, :projected_annual_gross, :taxable, :annual_tax,
+                          :details, keyword_init: true)
+
+      HIGH_INCOME_WARNING_THRESHOLD = BigDecimal("5000000")
+
+      def self.call(regime:, structure_monthly_gross:, gross_earned_this_month:,
+                    fy_gross_paid:, fy_tds_paid:, months_remaining:,
+                    declared_annual_deductions:, rates:, override: nil)
+        table = rates[regime.to_s] || rates["new"]
+
+        if override.present?
+          monthly = Money.round_rupee(override)
+          return Result.new(monthly: monthly, projected_annual_gross: nil, taxable: nil, annual_tax: nil,
+                            details: { "regime" => regime.to_s, "override" => monthly.to_s("F") })
+        end
+
+        months_remaining = [ months_remaining.to_i, 1 ].max
+        projected = Money.d(fy_gross_paid) + Money.d(gross_earned_this_month) +
+                    (Money.d(structure_monthly_gross) * (months_remaining - 1))
+
+        deductions = table[:standard_deduction]
+        deductions += Money.d(declared_annual_deductions) if regime.to_s == "old"
+        taxable = [ projected - deductions, BigDecimal(0) ].max
+
+        slab_tax = slab_tax_for(taxable, table[:slabs])
+        slab_tax = BigDecimal(0) if taxable <= table[:rebate_cap] # §87A full rebate
+        annual = Money.round_to_10(slab_tax * (1 + table[:cess_rate]))
+
+        monthly = Money.round_rupee((annual - Money.d(fy_tds_paid)) / months_remaining)
+        monthly = BigDecimal(0) if monthly.negative?
+
+        Result.new(
+          monthly: monthly,
+          projected_annual_gross: Money.round2(projected),
+          taxable: Money.round2(taxable),
+          annual_tax: annual,
+          details: {
+            "regime" => regime.to_s,
+            "projected_annual_gross" => Money.round2(projected).to_s("F"),
+            "standard_deduction" => table[:standard_deduction].to_s("F"),
+            "declared_deductions" => (regime.to_s == "old" ? Money.d(declared_annual_deductions).to_s("F") : "0"),
+            "taxable" => Money.round2(taxable).to_s("F"),
+            "annual_tax_with_cess" => annual.to_s("F"),
+            "fy_tds_already_deducted" => Money.d(fy_tds_paid).to_s("F"),
+            "months_remaining" => months_remaining.to_s,
+            "high_income_review" => (taxable > HIGH_INCOME_WARNING_THRESHOLD).to_s
+          }
+        )
+      end
+
+      def self.slab_tax_for(taxable, slabs)
+        slabs.sum(BigDecimal(0)) do |lower, upper, rate|
+          next BigDecimal(0) if taxable <= lower
+
+          span_top = upper && taxable > upper ? upper : taxable
+          (span_top - lower) * rate
+        end
+      end
+      private_class_method :slab_tax_for
+    end
+  end
+end

data/app/services/hr_lite/day_status.rb

@@ -0,0 +1,49 @@
+module HrLite
+  # Resolves what each date "is" for a user, with the full precedence chain:
+  #
+  #   holiday > weekend > approved full-day leave > punch > absent/upcoming
+  #
+  # A half-day leave coexists with a punch (kind :half_day_leave, record
+  # exposed); a punch on a holiday keeps :holiday but exposes the record
+  # (UI shows a "worked" hint). One resolver feeds the month grids, the
+  # overview board and the attendance summary — a single truth.
+  class DayStatus
+    Day = Struct.new(:kind, :record, :leave, keyword_init: true)
+
+    def initialize(user:, range:)
+      @range = range
+      @records = AttendanceRecord.where(user_id: user.id, date: range).index_by(&:date)
+      @calendar = WorkingCalendar.new(range)
+      @leaves = LeaveRequest.approved.includes(:leave_type)
+                            .where(user_id: user.id)
+                            .overlapping_range(range.first, range.last).to_a
+    end
+
+    attr_reader :calendar
+
+    def for(date)
+      record = @records[date]
+      leave = @leaves.find { |l| l.start_date <= date && l.end_date >= date }
+
+      return Day.new(kind: :holiday, record: record, leave: leave) if @calendar.holiday?(date)
+      return Day.new(kind: :weekend, record: record, leave: leave) if @calendar.weekend?(date)
+
+      if leave
+        kind = leave.half_day ? :half_day_leave : :leave
+        return Day.new(kind: kind, record: record, leave: leave)
+      end
+
+      if record&.check_in_at
+        Day.new(kind: record.status.to_sym, record: record)
+      elsif date > Date.current
+        Day.new(kind: :upcoming, record: nil)
+      else
+        Day.new(kind: :absent, record: record)
+      end
+    end
+
+    def counts
+      @range.each_with_object(Hash.new(0)) { |date, acc| acc[self.for(date).kind] += 1 }
+    end
+  end
+end

data/app/services/hr_lite/leave_day_counter.rb

@@ -0,0 +1,24 @@
+module HrLite
+  # How many working days a leave request actually consumes. Weekends and
+  # company-wide holidays inside the range are free; a half-day (single-day
+  # requests only) consumes 0.5.
+  module LeaveDayCounter
+    def self.count(leave_request)
+      count_range(
+        start_date: leave_request.start_date,
+        end_date: leave_request.end_date,
+        half_day: leave_request.half_day
+      )
+    end
+
+    def self.count_range(start_date:, end_date:, half_day: false)
+      return 0 if start_date.nil? || end_date.nil? || end_date < start_date
+
+      range = start_date..end_date
+      working = WorkingCalendar.new(range).working_days_in(range)
+      return BigDecimal("0.5") if half_day && working.positive?
+
+      BigDecimal(working)
+    end
+  end
+end

data/app/services/hr_lite/overview_query.rb

@@ -0,0 +1,39 @@
+module HrLite
+  # Feeds both the admin overview board and the daily leadership digest —
+  # one source, so they always agree. Sections return Relations (callers
+  # paginate or cap as they see fit).
+  class OverviewQuery
+    def initialize(date: Date.current)
+      @date = date
+    end
+
+    def pending_requests
+      LeaveRequest.pending.includes(:leave_type, :user).order(:created_at)
+    end
+
+    def on_leave_today
+      LeaveRequest.active_on(@date).includes(:leave_type, :user).order(:start_date)
+    end
+
+    def flagged_today
+      AttendanceRecord.for_date(@date).flagged.includes(:user)
+    end
+
+    def missing_checkout_yesterday
+      AttendanceRecord.for_date(@date - 1).missing_checkout.includes(:user)
+    end
+
+    def kpis
+      {
+        pending: pending_requests.count,
+        on_leave: on_leave_today.count,
+        flagged: flagged_today.count,
+        missing_checkout: missing_checkout_yesterday.count
+      }
+    end
+
+    def empty?
+      kpis.values.all?(&:zero?)
+    end
+  end
+end

data/app/services/hr_lite/payroll_run_processor.rb

@@ -0,0 +1,46 @@
+module HrLite
+  # (Re)computes every slip for a run in one transaction. Missing structures
+  # become warnings, manual overrides survive recomputes, employees who
+  # became ineligible lose their draft slips.
+  class PayrollRunProcessor
+    def self.call(run)
+      new(run).call
+    end
+
+    def initialize(run)
+      @run = run
+    end
+
+    def call
+      warnings = []
+
+      ActiveRecord::Base.transaction do
+        eligible = EmployeeProfile.active_for(@run.period_month).includes(:user).to_a
+        keep_ids = []
+
+        eligible.each do |profile|
+          user = profile.user
+          structure = SalaryStructure.effective_for(user, @run.period_month)
+          if structure.nil?
+            warnings << "No salary structure for #{HrLite.display_name(user)} — skipped"
+            next
+          end
+
+          slip = @run.salary_slips.find_or_initialize_by(user_id: user.id)
+          attributes = SlipBuilder.call(
+            run: @run, user: user, structure: structure, profile: profile,
+            lop_override: slip.lop_override, tds_override: slip.tds_override
+          )
+          slip.assign_attributes(attributes)
+          slip.save!
+          keep_ids << slip.id
+        end
+
+        @run.salary_slips.where.not(id: keep_ids).destroy_all
+        @run.update!(warnings: warnings)
+      end
+
+      @run
+    end
+  end
+end

data/app/services/hr_lite/pdf_renderer.rb

@@ -0,0 +1,23 @@
+module HrLite
+  # Slip PDF entry point. Host override first (earthly_vms plugs its cached
+  # WickedPdf service in via config.render_pdf); otherwise a built-in
+  # WickedPdf render when the gem is present; otherwise nil — the controller
+  # explains that PDF is not configured rather than crashing.
+  module PdfRenderer
+    def self.render(template:, assigns:, cache_key: nil)
+      if HrLite.config.render_pdf
+        HrLite.config.render_pdf.call(template: template, assigns: assigns, cache_key: cache_key)
+      elsif wicked_pdf_class
+        html = HrLite::ApplicationController.render(
+          template: template, assigns: assigns, layout: "hr_lite/pdf", formats: [ :html ]
+        )
+        wicked_pdf_class.new.pdf_from_string(html, page_size: "A4")
+      end
+    end
+
+    # Seam for tests and for hosts that lazy-load wicked_pdf.
+    def self.wicked_pdf_class
+      defined?(WickedPdf) ? WickedPdf : nil
+    end
+  end
+end

data/app/services/hr_lite/slip_builder.rb

@@ -0,0 +1,106 @@
+module HrLite
+  # Assembles one employee's slip numbers for a run. Sequence: attendance
+  # summary -> proration -> PF -> ESI -> PT -> TDS -> totals. Every line is
+  # rounded by its own statutory rule exactly once; net pay is a plain
+  # subtraction of already-rounded lines, so nothing can drift.
+  class SlipBuilder
+    def self.call(run:, user:, structure:, profile:, lop_override: nil, tds_override: nil)
+      new(run, user, structure, profile, lop_override, tds_override).call
+    end
+
+    def initialize(run, user, structure, profile, lop_override, tds_override)
+      @run = run
+      @user = user
+      @structure = structure
+      @profile = profile
+      @lop_override = lop_override
+      @tds_override = tds_override
+      @rates = StatutoryRateCard.for(run.period_month)
+    end
+
+    def call
+      summary = AttendanceSummary.for(user: @user, month: @run.period_month)
+      days_in_month = summary[:days_in_month]
+      lop = Money.d(@lop_override || summary[:lop_days])
+      payable = [ Money.d(days_in_month) - Money.d(summary[:out_of_window]) - lop, Money.d(0) ].max
+
+      earnings = Calculators::Proration.call(
+        structure: @structure, payable_days: payable, days_in_month: days_in_month
+      )
+      gross_earned = earnings.sum(BigDecimal(0)) { |row| row[:amount] }
+      basic_earned = earnings.find { |row| row[:code] == "basic" }&.fetch(:amount) || BigDecimal(0)
+
+      deductions = []
+      employer_costs = {}
+
+      if @structure.pf_applicable
+        pf = Calculators::Pf.call(basic_earned: basic_earned,
+                                  on_full_basic: @structure.pf_on_full_basic, rates: @rates[:pf])
+        deductions << { code: "pf_employee", label: "Provident fund", amount: pf.employee,
+                        meta: { pf_wage: pf.pf_wage.to_s("F") } }
+        employer_costs.merge!(
+          pf_eps: pf.employer_eps, pf_epf: pf.employer_epf,
+          edli: pf.edli, pf_admin: pf.admin_charges
+        )
+      end
+
+      esi = Calculators::Esi.call(monthly_gross: @structure.monthly_gross, gross_earned: gross_earned,
+                                  applicable: @structure.esi_applicable, rates: @rates[:esi])
+      if esi.applicable?
+        deductions << { code: "esi_employee", label: "ESI", amount: esi.employee }
+        employer_costs[:esi_employer] = esi.employer
+      end
+
+      pt = Calculators::ProfessionalTax.call(state: @structure.pt_state, gross_earned: gross_earned,
+                                             period_month: @run.period_month, rates: @rates[:pt])
+      deductions << { code: "pt", label: "Professional tax", amount: pt } if pt.positive?
+
+      fy = SalarySlip.fy_to_date(@user, @run.period_month)
+      tds = Calculators::Tds.call(
+        regime: @profile.tax_regime,
+        structure_monthly_gross: @structure.monthly_gross,
+        gross_earned_this_month: gross_earned,
+        fy_gross_paid: fy[:gross],
+        fy_tds_paid: fy[:tds],
+        months_remaining: months_remaining_in_fy,
+        declared_annual_deductions: @profile.declared_annual_deductions,
+        rates: @rates[:income_tax],
+        override: @tds_override
+      )
+      deductions << { code: "tds", label: "Income tax (TDS)", amount: tds.monthly } if tds.monthly.positive?
+
+      total_deductions = deductions.sum(BigDecimal(0)) { |row| row[:amount] }
+
+      {
+        period_month: @run.period_month,
+        days_in_month: days_in_month,
+        payable_days: payable,
+        lop_days: Money.d(summary[:lop_days]),
+        lop_override: @lop_override,
+        tds_override: @tds_override,
+        earnings: serialize_rows(earnings),
+        deductions: serialize_rows(deductions),
+        employer_costs: employer_costs.transform_values { |v| v.to_s("F") }.to_json,
+        tax_details: tds.details.to_json,
+        gross_earnings: gross_earned,
+        total_deductions: total_deductions,
+        net_pay: gross_earned - total_deductions,
+        computed_at: Time.current
+      }
+    end
+
+    private
+
+    # Months left in the Indian FY including the run month itself.
+    def months_remaining_in_fy
+      month = @run.period_month.month
+      month >= 4 ? (15 - month) : (3 - month + 1)
+    end
+
+    def serialize_rows(rows)
+      rows.map { |row|
+        row.transform_values { |value| value.is_a?(BigDecimal) ? value.to_s("F") : value }
+      }.to_json
+    end
+  end
+end

data/app/services/hr_lite/working_calendar.rb

@@ -0,0 +1,41 @@
+module HrLite
+  # The single source of day classification. Preloads holidays and the
+  # weekend policy once per instance; every other service (leave counting,
+  # day status, attendance summary) delegates here.
+  class WorkingCalendar
+    def initialize(range)
+      @range = range
+      @holiday_dates = Holiday.dates_for(range)
+      @policy = Setting.instance.weekend_policy
+    end
+
+    def holiday?(date)
+      @holiday_dates.include?(date)
+    end
+
+    def weekend?(date)
+      case @policy
+      when "sun_only"
+        date.sunday?
+      when "second_fourth_sat_sun"
+        date.sunday? || (date.saturday? && [ 2, 4 ].include?(week_of_month(date)))
+      else # sat_sun
+        date.saturday? || date.sunday?
+      end
+    end
+
+    def working_day?(date)
+      !holiday?(date) && !weekend?(date)
+    end
+
+    def working_days_in(range)
+      range.count { |date| working_day?(date) }
+    end
+
+    private
+
+    def week_of_month(date)
+      ((date.day - 1) / 7) + 1
+    end
+  end
+end

data/app/views/hr_lite/admin/appraisals/_form.html.erb

@@ -0,0 +1,29 @@
+<section class="hrl-card">
+  <%= form_with model: appraisal, url: url, method: method, scope: :appraisal, local: true do |f| %>
+    <%= render "hr_lite/shared/form_errors", record: appraisal %>
+    <div class="hrl-field"><%= f.label :period_start %><%= f.date_field :period_start %></div>
+    <div class="hrl-field"><%= f.label :period_end %><%= f.date_field :period_end %></div>
+    <div class="hrl-field">
+      <%= f.label :rating, "Rating (1-5, optional)" %>
+      <%= f.select :rating, [ [ "No rating", "" ] ] + (1..5).map { |n| [ "#{n}/5", n ] } %>
+    </div>
+    <div class="hrl-field"><%= f.label :strengths %><%= f.text_area :strengths %></div>
+    <div class="hrl-field"><%= f.label :improvements, "Areas to grow" %><%= f.text_area :improvements %></div>
+    <div class="hrl-field">
+      <%= f.label :outcome %>
+      <%= f.select :outcome, HrLite::Appraisal::OUTCOMES.map { |o| [ o.humanize, o ] } %>
+    </div>
+    <div class="hrl-field">
+      <%= f.label :new_designation, "New designation (promotion only)" %>
+      <%= f.text_field :new_designation %>
+    </div>
+    <div class="hrl-field">
+      <%= f.label :effective_date, "Effective date (for increment/promotion)" %>
+      <%= f.date_field :effective_date %>
+    </div>
+    <div class="hrl-form-actions">
+      <%= f.submit "Save draft", class: "hrl-btn hrl-btn--primary" %>
+      <a class="hrl-btn" href="<%= hr_lite.admin_employee_path(@profile) %>">Cancel</a>
+    </div>
+  <% end %>
+</section>

data/app/views/hr_lite/admin/appraisals/edit.html.erb

@@ -0,0 +1,6 @@
+<% content_for(:page_title) { "Edit appraisal" } %>
+<div class="hrl-page__head">
+  <h1 class="hrl-page__title">Edit appraisal — <%= hr_display_name(@profile.user) %></h1>
+</div>
+<%= render "form", appraisal: @appraisal,
+           url: hr_lite.admin_employee_appraisal_path(@profile, @appraisal), method: :patch %>

data/app/views/hr_lite/admin/appraisals/new.html.erb

@@ -0,0 +1,6 @@
+<% content_for(:page_title) { "New appraisal" } %>
+<div class="hrl-page__head">
+  <h1 class="hrl-page__title">New appraisal — <%= hr_display_name(@profile.user) %></h1>
+</div>
+<%= render "form", appraisal: @appraisal,
+           url: hr_lite.admin_employee_appraisals_path(@profile), method: :post %>