hr_lite 0.60.0 → 0.62.0

data/app/models/hr_lite/hiring_candidate.rb

@@ -0,0 +1,56 @@
+module HrLite
+  # A person from a university's sheet, moving through one campaign. Every
+  # change goes on their timeline (AuditLog rows whose subject is them).
+  class HiringCandidate < ApplicationRecord
+    STAGES = %w[imported invited interested not_interested interview selected rejected on_hold].freeze
+    # Where a stage may go next. Sending moves imported → invited; scheduling moves to interview.
+    MOVES = {
+      "imported" => %w[invited interested not_interested],
+      "invited" => %w[interested not_interested],
+      "interested" => %w[interview not_interested on_hold rejected],
+      "not_interested" => %w[interested],
+      "interview" => %w[interview selected rejected on_hold],
+      "on_hold" => %w[interview selected rejected],
+      "selected" => [], "rejected" => []
+    }.freeze
+    REJECTION_REASONS = [ "Communication skills", "Not available for 6 months", "Location / relocation",
+                          "Stipend not acceptable", "Did not attend interview", "Other" ].freeze
+
+    belongs_to :campaign, class_name: "HrLite::HiringCampaign", inverse_of: :candidates
+    has_many :messages, class_name: "HrLite::HiringMessage", foreign_key: :candidate_id, dependent: :restrict_with_error
+    has_many :interviews, class_name: "HrLite::HiringInterview", foreign_key: :candidate_id, dependent: :restrict_with_error
+    has_many :replies, class_name: "HrLite::HiringReply", foreign_key: :candidate_id, inverse_of: :candidate, dependent: :restrict_with_error
+
+    encrypts :phone, :date_of_birth
+    normalizes :email, with: ->(email) { email.to_s.strip.downcase }
+
+    validates :name, presence: true
+    validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }, uniqueness: { scope: :campaign_id }
+    validates :stage, inclusion: { in: STAGES }
+
+    def first_name = name.to_s.split.first
+    def stage_label = stage == "interview" ? "Interview · round #{round}" : stage.humanize
+    def timeline = AuditLog.where(subject_type: self.class.name, subject_id: id).includes(:actor).order(created_at: :desc, id: :desc)
+
+    # The one door for a stage change: refuses a move the pipeline does not
+    # allow, needs a listed reason to reject, and writes the timeline row.
+    def move_to!(to, reason: nil, note: nil, round: self.round, actor: HrLite::Current.actor)
+      raise ArgumentError, "#{stage_label} cannot move to #{to.humanize}." unless MOVES.fetch(stage).include?(to)
+      raise ArgumentError, "Pick a rejection reason." if to == "rejected" && !REJECTION_REASONS.include?(reason)
+      raise ArgumentError, "Write a note for “Other”." if reason == "Other" && note.blank?
+
+      transaction do
+        from = stage
+        update!(stage: to, round: round, rejection_reason: (to == "rejected" ? [ reason, note.presence ].compact.join(": ") : rejection_reason))
+        log!("stage", actor: actor, from: from, to: to, reason: (reason if to == "rejected"))
+      end
+    end
+
+    # This round's reply link, made on first use (a template that names it).
+    def reply_for(round) = replies.find_or_create_by!(round: round)
+
+    def log!(action, actor: HrLite::Current.actor, **changes)
+      AuditLog.record!(action: "hiring.#{action}", subject: self, actor: actor, changes: changes.compact)
+    end
+  end
+end

data/app/models/hr_lite/hiring_interview.rb

@@ -0,0 +1,13 @@
+module HrLite
+  # One interview round on the sender's Google Calendar. A new round is a new
+  # row, so earlier rounds keep their own history.
+  class HiringInterview < ApplicationRecord
+    STATUSES = %w[unknown scheduled failed cancelled].freeze
+
+    belongs_to :candidate, class_name: "HrLite::HiringCandidate"
+
+    validates :status, inclusion: { in: STATUSES }
+    validates :round, numericality: { greater_than: 0 }
+    validates :starts_at, :ends_at, presence: true
+  end
+end

data/app/models/hr_lite/hiring_message.rb

@@ -0,0 +1,14 @@
+module HrLite
+  # One template sent (or being sent) to one candidate. The unique index on
+  # candidate + template is what makes a repeated click or job a no-op.
+  # "sending" left behind by a crash, and "unknown", both mean: look in Gmail.
+  class HiringMessage < ApplicationRecord
+    STATUSES = %w[queued sending sent failed unknown].freeze
+
+    belongs_to :candidate, class_name: "HrLite::HiringCandidate"
+    belongs_to :template, class_name: "HrLite::HiringTemplate"
+    belongs_to :sent_by, class_name: HrLite.config.user_class, optional: true
+
+    validates :status, inclusion: { in: STATUSES }
+  end
+end

data/app/models/hr_lite/hiring_reply.rb

@@ -0,0 +1,144 @@
+module HrLite
+  # A candidate's reply link for one interview round (@round1_link … @round3_link):
+  # the day and 2-hour slot they can do, an optional alternate phone, round 1's
+  # interest questions, and from round 2 their documents. One reply per link.
+  class HiringReply < ApplicationRecord
+    SLOTS = { "10-12" => "10 AM – 12 PM", "12-2" => "12 – 2 PM", "2-4" => "2 – 4 PM", "4-6" => "4 – 6 PM", "6-8" => "6 – 8 PM" }.freeze
+    SLOT_START = { "10-12" => "10:00", "12-2" => "12:00", "2-4" => "14:00", "4-6" => "16:00", "6-8" => "18:00" }.freeze
+    SLOT_CAPACITY = 4 # candidates per slot per day; HR calls each to confirm
+    JOINING = { "immediately" => "Immediately", "two_weeks" => "Within 2 weeks", "one_month" => "Within a month" }.freeze
+    YES_NO = { "stipend_ok" => "Fine with the stipend", "location_ok" => "Fine with the office location",
+               "schedule_ok" => "Fine with the schedule", "programme_ok" => "Commits to the programme" }.freeze
+    DOCUMENTS = { 2 => { "cv" => "CV", "photo_id" => "Photo ID" },
+                  3 => { "marksheets" => "Marksheets", "aadhaar" => "Aadhaar card", "pan" => "PAN card",
+                         "salary_slip_1" => "Salary slip (last month)", "salary_slip_2" => "Salary slip (2 months ago)",
+                         "salary_slip_3" => "Salary slip (3 months ago)" } }.freeze
+    PAN_FORMAT = /\A[A-Z]{5}[0-9]{4}[A-Z]\z/
+    # Verhoeff tables, for the Aadhaar check digit.
+    VERHOEFF_D = [ [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], [ 1, 2, 3, 4, 0, 6, 7, 8, 9, 5 ], [ 2, 3, 4, 0, 1, 7, 8, 9, 5, 6 ],
+                   [ 3, 4, 0, 1, 2, 8, 9, 5, 6, 7 ], [ 4, 0, 1, 2, 3, 9, 5, 6, 7, 8 ], [ 5, 9, 8, 7, 6, 0, 4, 3, 2, 1 ],
+                   [ 6, 5, 9, 8, 7, 1, 0, 4, 3, 2 ], [ 7, 6, 5, 9, 8, 2, 1, 0, 4, 3 ], [ 8, 7, 6, 5, 9, 3, 2, 1, 0, 4 ],
+                   [ 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 ] ].freeze
+    VERHOEFF_P = [ [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], [ 1, 5, 7, 6, 2, 8, 3, 0, 9, 4 ], [ 5, 8, 0, 3, 7, 9, 6, 1, 4, 2 ],
+                   [ 8, 9, 1, 6, 0, 4, 3, 5, 2, 7 ], [ 9, 4, 5, 3, 1, 2, 6, 8, 7, 0 ], [ 4, 2, 8, 6, 5, 7, 3, 9, 0, 1 ],
+                   [ 2, 7, 9, 3, 8, 0, 6, 4, 1, 5 ], [ 7, 0, 4, 6, 9, 1, 3, 2, 5, 8 ] ].freeze
+    DOCUMENT_TYPES = %w[application/pdf image/jpeg image/png].freeze
+    DOCUMENT_MAX = 5.megabytes
+
+    belongs_to :candidate, class_name: "HrLite::HiringCandidate", inverse_of: :replies
+    has_many_attached :documents
+    encrypts :alternate_phone, :aadhaar_number, :pan_number
+    has_secure_token :token, length: 24
+
+    validates :round, inclusion: { in: 1..3 }
+
+    scope :responded, -> { where.not(responded_at: nil) }
+
+    def self.slot_full?(date, slot) = responded.where(preferred_date: date, preferred_slot: slot).count >= SLOT_CAPACITY
+
+    # The next ten interview days. Sunday is off unless the campaign allows it.
+    def self.dates(allow_sunday:, from: Date.current) = (1..20).map { |i| from + i }.reject { |d| d.sunday? && !allow_sunday }.first(10)
+
+    def self.aadhaar_valid?(number)
+      number.to_s.match?(/\A[2-9]\d{11}\z/) &&
+        number.reverse.chars.each_with_index.reduce(0) { |c, (digit, i)| VERHOEFF_D[c][VERHOEFF_P[i % 8][digit.to_i]] }.zero?
+    end
+
+    # What this round asks for; round 3 skips PAN and slips the candidate says they lack.
+    def documents_asked
+      asked = DOCUMENTS.fetch(round, {})
+      asked = asked.except("pan") if pan_pending
+      asked = asked.except("salary_slip_1", "salary_slip_2", "salary_slip_3") if no_salary_slips
+      asked
+    end
+
+    def masked_aadhaar = aadhaar_number && "XXXX XXXX #{aadhaar_number.last(4)}"
+    def masked_pan = pan_number && "XXXXX#{pan_number[5, 4]}X"
+
+    # Documents are stored encrypted; this is the only way back to the bytes.
+    def read_document(attachment) = ActiveRecord::Encryption.encryptor.decrypt(attachment.download)
+    def document_label(attachment) = documents_asked[attachment.filename.to_s.split("--").first] || "Document"
+
+    # Saves the reply, moves round 1's candidate to interested / not interested,
+    # puts it on their timeline and rings the HR person who emailed them.
+    def submit!(interested: nil, date: nil, slot: nil, joining: nil, yes_no: {}, alternate_phone: nil, files: {}, kyc: {})
+      raise ArgumentError, "You have already replied. Thank you." if responded_at
+
+      assign_kyc!(kyc) if round == 3
+
+      declined = round == 1 && interested == "no"
+      raise ArgumentError, "Tell us whether you want to go ahead." if round == 1 && !%w[yes no].include?(interested)
+
+      answers = round == 1 ? { "interested" => interested } : {}
+      unless declined
+        date = self.class.dates(allow_sunday: candidate.campaign.allow_sunday).find { |day| day.iso8601 == date.to_s }
+        raise ArgumentError, "Pick a day for the interview." unless date
+        raise ArgumentError, "Pick a time slot." unless SLOTS.key?(slot)
+        raise ArgumentError, "That slot just filled up. Pick another one." if self.class.slot_full?(date, slot)
+        raise ArgumentError, "That phone number does not look right." if alternate_phone.present? && !alternate_phone.to_s.gsub(/[\s-]/, "").match?(/\A\+?\d{7,15}\z/)
+
+        if round == 1
+          raise ArgumentError, "Tell us how soon you can join." unless JOINING.key?(joining)
+
+          answers.merge!("joining" => joining, **YES_NO.keys.to_h { |key| [ key, yes_no[key] == "yes" ? "yes" : "no" ] })
+        end
+        check_files!(files)
+      end
+
+      transaction do
+        update!(responded_at: Time.current, answers: answers, alternate_phone: alternate_phone.presence,
+                preferred_date: (date unless declined), preferred_slot: (slot unless declined))
+        files.slice(*documents_asked.keys).each do |kind, file|
+          # Encrypted before it reaches storage: a leaked blob is ciphertext.
+          cipher = ActiveRecord::Encryption.encryptor.encrypt(file.tempfile.read.b)
+          documents.attach(io: StringIO.new(cipher), filename: "#{kind}--#{file.original_filename}", content_type: "application/octet-stream",
+                           identify: false)
+        end
+        if round == 1
+          to = declined ? "not_interested" : "interested"
+          candidate.move_to!(to, actor: nil) if HiringCandidate::MOVES.fetch(candidate.stage).include?(to)
+        end
+        candidate.log!("replied", actor: nil, round: round, interested: answers["interested"],
+                                  slot: ([ date.strftime("%-d %b"), SLOTS[slot] ].join(", ") unless declined))
+      end
+      notify_sender
+    end
+
+    private
+
+    # Round 3's joining KYC. Errors name the field, never the number.
+    def assign_kyc!(kyc)
+      raise ArgumentError, "Tick the consent box to share your documents." unless kyc[:consent] == "1"
+
+      aadhaar = kyc[:aadhaar_number].to_s.gsub(/\s/, "")
+      raise ArgumentError, "That Aadhaar number does not look right." unless self.class.aadhaar_valid?(aadhaar)
+
+      self.pan_pending = kyc[:pan_pending] == "1"
+      pan = kyc[:pan_number].to_s.strip.upcase
+      raise ArgumentError, "That PAN does not look right." unless pan_pending || pan.match?(PAN_FORMAT)
+
+      self.no_salary_slips = kyc[:no_salary_slips] == "1"
+      self.aadhaar_number = aadhaar
+      self.pan_number = (pan unless pan_pending)
+    end
+
+    # Every asked document, a real PDF/JPG/PNG (read from the bytes, not the
+    # browser's claim), at most 5 MB.
+    def check_files!(files)
+      documents_asked.each do |kind, label|
+        file = files[kind]
+        raise ArgumentError, "Attach your #{label}." unless file.respond_to?(:original_filename)
+        raise ArgumentError, "#{label} must be a PDF, JPG or PNG." unless DOCUMENT_TYPES.include?(sniff(file))
+        raise ArgumentError, "#{label} must be 5 MB or smaller." if file.size > DOCUMENT_MAX
+      end
+    end
+
+    def sniff(file) = Marcel::MimeType.for(file.tempfile, name: file.original_filename).tap { file.tempfile.rewind }
+
+    def notify_sender
+      user = candidate.messages.where(status: "sent").order(:sent_at).last&.sent_by or return
+      HrLite.notify(user: user, kind: "hiring.reply", body: candidate.campaign.title, path: "/admin/hiring_candidates/#{candidate_id}",
+                    title: "#{candidate.name} replied to round #{round}#{": #{answers['interested'] == 'yes' ? 'interested' : 'not interested'}" if round == 1}")
+    end
+  end
+end

data/app/models/hr_lite/hiring_template.rb

@@ -0,0 +1,11 @@
+module HrLite
+  # An email HR writes once and sends to many. @placeholders are filled per
+  # candidate by HiringMerge at send time.
+  class HiringTemplate < ApplicationRecord
+    has_many :messages, class_name: "HrLite::HiringMessage", foreign_key: :template_id, dependent: :restrict_with_error
+
+    validates :name, :subject, :body, presence: true
+
+    scope :alphabetical, -> { order(:name) }
+  end
+end

data/app/services/hr_lite/hiring_import.rb

@@ -0,0 +1,106 @@
+module HrLite
+  # Reads a university's candidate sheet into a preview, then imports it.
+  # Headers match an alias list after case-folding and dropping punctuation
+  # and spaces. A column nobody recognises is kept in `extra`, never dropped;
+  # two columns claiming one field wait for HR to pick one.
+  class HiringImport
+    ALIASES = {
+      "name" => %w[studentname name candidatename fullname],
+      "email" => %w[emailid email emailaddress mailid],
+      "phone" => %w[contactno contactnumber phone phoneno mobile mobileno],
+      "date_of_birth" => %w[dob dobddmmyyyy dateofbirth],
+      "campus" => %w[campus college],
+      "course" => %w[coursepursuing course programme program],
+      "branch" => %w[branchspecialization branch specialization],
+      "cv_url" => %w[linkforcv cv cvlink resume resumelink]
+    }.freeze
+
+    Column = Data.define(:index, :header, :field, :extra_key)
+    Row = Data.define(:number, :attributes, :extra, :outcome, :reason)
+
+    def self.normalize(header) = header.to_s.downcase.gsub(/[^a-z0-9]/, "")
+
+    # Cell values arrive as the sheet stored them: never evaluated, never fetched.
+    def self.text(value)
+      case value
+      when nil then ""
+      when Float then value == value.floor ? value.to_i.to_s : value.to_s
+      when Date, Time then value.strftime("%d/%m/%Y")
+      else value.to_s.strip
+      end
+    end
+
+    attr_reader :columns, :conflicts, :rows
+
+    # rows: arrays of cell values, headers first. picks: { "phone" => "3" }
+    # names the column that wins a field two columns claim.
+    def initialize(campaign, rows, picks: {})
+      @campaign = campaign
+      header, *body = rows
+      map_columns(Array(header), picks.to_h.transform_values(&:to_i))
+      @rows = classify(body)
+    end
+
+    def counts = %w[create update skip].index_with { |outcome| rows.count { |row| row.outcome == outcome } }
+
+    def import!
+      return false if conflicts.any?
+
+      HiringCandidate.transaction do
+        rows.reject { |row| row.outcome == "skip" }.each do |row|
+          candidate = @campaign.candidates.find_or_initialize_by(email: row.attributes["email"])
+          created = candidate.new_record?
+          candidate.assign_attributes(row.attributes.merge("extra" => candidate.extra.to_h.merge(row.extra)))
+          candidate.save!
+          candidate.log!(created ? "imported" : "reimported") if created || candidate.saved_changes.any?
+        end
+      end
+      true
+    end
+
+    private
+
+    def map_columns(header, picks)
+      @columns = header.each_with_index.map do |cell, index|
+        field = ALIASES.find { |_, names| names.include?(self.class.normalize(cell)) }&.first
+        Column.new(index:, header: cell.to_s.strip, field:, extra_key: nil)
+      end
+      claimed = @columns.select(&:field).group_by(&:field)
+      @conflicts = claimed.select { |field, cols| cols.size > 1 && cols.none? { |c| c.index == picks[field] } }
+      # A column that lost its field (or is unknown) keeps its data in `extra`.
+      taken = HiringMerge::RESERVED + ALIASES.keys
+      @columns = @columns.map do |col|
+        loses = col.field && claimed[col.field].size > 1 && picks[col.field] != col.index
+        next col if col.field && !loses
+
+        key = col.header.parameterize(separator: "_").presence || "column_#{col.index + 1}"
+        key = "sheet_#{key}" if taken.include?(key) || !key.match?(/\A[a-z]/) # @placeholders start with a letter
+        taken << key
+        col.with(field: nil, extra_key: key)
+      end
+    end
+
+    def classify(body)
+      seen = {}
+      existing = @campaign.candidates.pluck(:email).to_set
+      body.each_with_index.filter_map do |cells, i|
+        number = i + 2 # sheet row, counting the header
+        values = @columns.to_h { |col| [ col, self.class.text(Array(cells)[col.index]) ] }
+        next if values.values.all?(&:blank?) # an empty row in the sheet is not a candidate
+
+        attributes = values.select { |col, _| col.field }.to_h { |col, v| [ col.field, v.presence ] }
+        attributes["email"] = attributes["email"].to_s.strip.downcase.presence
+        extra = values.select { |col, v| col.extra_key && v.present? }.to_h { |col, v| [ col.extra_key, v ] }
+        outcome, reason =
+          if attributes["name"].blank? then [ "skip", "no name" ]
+          elsif attributes["email"].blank? then [ "skip", "no email address" ]
+          elsif !attributes["email"].match?(URI::MailTo::EMAIL_REGEXP) then [ "skip", "email address looks wrong" ]
+          elsif seen[attributes["email"]] then [ "skip", "same email as row #{seen[attributes['email']]}" ]
+          else [ existing.include?(attributes["email"]) ? "update" : "create", nil ]
+          end
+        seen[attributes["email"]] ||= number if attributes["email"]
+        Row.new(number:, attributes:, extra:, outcome:, reason:)
+      end
+    end
+  end
+end

data/app/services/hr_lite/hiring_merge.rb

@@ -0,0 +1,54 @@
+module HrLite
+  # Fills a hiring email's @placeholders for one candidate. Reserved names
+  # (campaign, candidate, interview, sender) win over a sheet's extra columns.
+  # An unknown or blank placeholder is reported, never sent as "".
+  class HiringMerge
+    TOKEN = /(?<![\w.@])@([a-z][a-z0-9_]*)/
+    GROUPS = { "Candidate" => %w[first_name name course branch campus],
+               "Offer" => %w[position programme stipend ctc location schedule],
+               "Interview" => %w[interview_date interview_time meet_link sender_name],
+               "Reply links" => %w[round1_link round2_link round3_link] }.freeze
+    RESERVED = GROUPS.values.flatten.freeze
+
+    Result = Data.define(:subject, :body, :missing)
+
+    def self.tokens(text) = text.to_s.scan(TOKEN).flatten.uniq
+
+    def initialize(candidate, sender_name:)
+      @extra = candidate.extra.to_h.transform_keys(&:to_s)
+      @values = @extra.merge(reserved(candidate, sender_name))
+    end
+
+    def render(template)
+      missing = []
+      fill = ->(text) {
+        text.to_s.gsub(TOKEN) do
+          key = Regexp.last_match(1)
+          value = @values[key]
+          value = (value.respond_to?(:call) ? value.call : value).to_s.strip
+          next value unless value.empty?
+
+          missing << "@#{key} (#{RESERVED.include?(key) || @extra.key?(key) ? 'empty' : 'unknown'})"
+          Regexp.last_match(0)
+        end
+      }
+      Result.new(subject: fill.(template.subject), body: fill.(template.body), missing: missing.uniq)
+    end
+
+    private
+
+    def reserved(candidate, sender_name)
+      campaign = candidate.campaign
+      interview = candidate.interviews.where(status: "scheduled").order(:round).last
+      at = interview&.starts_at&.in_time_zone(HrLite.config.time_zone)
+      { "name" => candidate.name, "first_name" => candidate.first_name, "course" => candidate.course,
+        "branch" => candidate.branch, "campus" => candidate.campus, "position" => campaign.position,
+        "programme" => campaign.programme, "stipend" => campaign.stipend, "ctc" => campaign.ctc,
+        "location" => campaign.location, "schedule" => campaign.schedule,
+        "interview_date" => at&.strftime("%-d %B %Y"), "interview_time" => at&.strftime("%-l:%M %p"),
+        "meet_link" => interview&.meet_link, "sender_name" => sender_name,
+        # Lazy: a round's link (and its row) is made only when a template names it.
+        **(1..3).to_h { |r| [ "round#{r}_link", -> { HrLite.public_url("/apply/#{candidate.reply_for(r).token}") } ] } }
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+<%= form_with model: campaign, url: (campaign.persisted? ? hr_lite.admin_hiring_campaign_path(campaign) : hr_lite.admin_hiring_campaigns_path), local: true do |f| %>
+  <%= render "hr_lite/shared/form_errors", record: campaign %>
+  <p class="hrl-small hrl-muted">These fill @position, @programme, @stipend, @ctc, @location and @schedule in every email.</p>
+  <div class="hrl-field"><%= f.label :title, "Campaign name" %><%= f.text_field :title, required: true, placeholder: "e.g. Campus drive, October" %></div>
+  <div class="hrl-field"><%= f.label :position %><%= f.text_field :position, required: true %></div>
+  <div class="hrl-field"><%= f.label :programme %><%= f.text_field :programme %></div>
+  <div class="hrl-field"><%= f.label :stipend, "Monthly stipend" %><%= f.text_field :stipend %></div>
+  <div class="hrl-field"><%= f.label :ctc, "Full-time CTC" %><%= f.text_field :ctc %></div>
+  <div class="hrl-field"><%= f.label :location, "Work location" %><%= f.text_area :location, rows: 2 %></div>
+  <div class="hrl-field"><%= f.label :schedule, "Work schedule" %><%= f.text_field :schedule %></div>
+  <div class="hrl-field"><label class="hrl-field--check"><%= f.check_box :allow_sunday %> Allow Sunday interviews (Sunday is off by default)</label></div>
+  <% if campaign.persisted? %>
+    <div class="hrl-field"><%= f.label :status %><%= f.select :status, [ %w[Open open], %w[Closed closed] ] %></div>
+  <% end %>
+  <div class="hrl-form-actions">
+    <%= f.submit "Save", class: "hrl-btn hrl-btn--primary" %>
+    <a class="hrl-btn" href="<%= campaign.persisted? ? hr_lite.admin_hiring_campaign_path(campaign) : hr_lite.admin_hiring_campaigns_path %>">Cancel</a>
+  </div>
+<% end %>

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

@@ -0,0 +1,3 @@
+<% content_for(:page_title) { "Edit campaign" } %>
+<div class="hrl-page__head"><h1 class="hrl-page__title">Edit <%= @campaign.title %></h1></div>
+<section class="hrl-card"><%= render "form", campaign: @campaign %></section>

data/app/views/hr_lite/admin/hiring_campaigns/import.html.erb

@@ -0,0 +1,18 @@
+<% content_for(:page_title) { "Upload candidates" } %>
+<div class="hrl-page__head">
+  <h1 class="hrl-page__title">Upload candidate sheet</h1>
+  <p class="hrl-page__sub"><%= @campaign.title %>. Nothing is saved until you confirm the preview.</p>
+</div>
+<section class="hrl-card">
+  <%= form_with url: hr_lite.import_admin_hiring_campaign_path(@campaign), method: :post, local: true, multipart: true do %>
+    <div class="hrl-field">
+      <label for="sheet">Sheet (.xlsx or .csv, headers in the first row)</label>
+      <input type="file" name="sheet" id="sheet" accept=".xlsx,.xls,.csv" required>
+    </div>
+    <p class="hrl-small hrl-muted">Name and email are required. Columns we do not recognise are kept, and can be used as @placeholders.</p>
+    <div class="hrl-form-actions">
+      <button class="hrl-btn hrl-btn--primary" type="submit">Preview</button>
+      <a class="hrl-btn" href="<%= hr_lite.admin_hiring_campaign_path(@campaign) %>">Cancel</a>
+    </div>
+  <% end %>
+</section>

data/app/views/hr_lite/admin/hiring_campaigns/index.html.erb

@@ -0,0 +1,21 @@
+<% content_for(:page_title) { "Hiring" } %>
+<div class="hrl-page__head">
+  <h1 class="hrl-page__title">Hiring</h1>
+  <div class="hrl-page__actions"><a class="hrl-btn hrl-btn--primary" href="<%= hr_lite.new_admin_hiring_campaign_path %>">New campaign</a></div>
+</div>
+
+<% if @campaigns.empty? %>
+  <section class="hrl-card hrl-card--empty"><p class="hrl-muted">No campaigns yet. Create one, then upload the university's candidate sheet.</p></section>
+<% end %>
+<% @campaigns.each do |campaign| %>
+  <section class="hrl-card">
+    <h2 class="hrl-card__title"><a class="hrl-card__link" href="<%= hr_lite.admin_hiring_campaign_path(campaign) %>"><%= campaign.title %></a></h2>
+    <p class="hrl-small hrl-muted"><%= [ campaign.position, campaign.stipend, (campaign.status == "closed" ? "Closed" : nil) ].compact_blank.join(" · ") %></p>
+    <div class="hrl-chiprow">
+      <% HrLite::HiringCandidate::STAGES.each do |stage| %>
+        <% if (n = @counts[[ campaign.id, stage ]]) %><span class="hrl-badge hrl-badge--muted"><%= n %> <%= stage.humanize.downcase %></span><% end %>
+      <% end %>
+    </div>
+  </section>
+<% end %>
+<%= hrl_pagination %>

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

@@ -0,0 +1,3 @@
+<% content_for(:page_title) { "New campaign" } %>
+<div class="hrl-page__head"><h1 class="hrl-page__title">New hiring campaign</h1></div>
+<section class="hrl-card"><%= render "form", campaign: @campaign %></section>

data/app/views/hr_lite/admin/hiring_campaigns/preview.html.erb

@@ -0,0 +1,62 @@
+<% content_for(:page_title) { "Check the import" } %>
+<% counts = @import.counts %>
+<div class="hrl-page__head">
+  <h1 class="hrl-page__title">Check the import</h1>
+  <p class="hrl-page__sub"><%= @campaign.title %></p>
+</div>
+<div class="hrl-kpis">
+  <div class="hrl-kpi"><div class="hrl-kpi__value"><%= counts["create"] %></div><div class="hrl-kpi__label">New</div></div>
+  <div class="hrl-kpi"><div class="hrl-kpi__value"><%= counts["update"] %></div><div class="hrl-kpi__label">Update</div></div>
+  <div class="hrl-kpi"><div class="hrl-kpi__value"><%= counts["skip"] %></div><div class="hrl-kpi__label">Skip</div></div>
+</div>
+
+<%= form_with url: hr_lite.import_admin_hiring_campaign_path(@campaign), method: :post, local: true do %>
+  <input type="hidden" name="rows" value="<%= @sealed %>">
+  <% if @import.conflicts.any? %>
+    <section class="hrl-card hrl-card--warn">
+      <h2 class="hrl-card__title">Pick one column for each field</h2>
+      <% @import.conflicts.each do |field, columns| %>
+        <fieldset class="hrl-field">
+          <legend><%= field.humanize %></legend>
+          <% columns.each do |column| %>
+            <label class="hrl-field--check"><input type="radio" name="picks[<%= field %>]" value="<%= column.index %>" required> “<%= column.header %>”</label>
+          <% end %>
+        </fieldset>
+      <% end %>
+      <p class="hrl-small hrl-muted">The column you do not pick is kept as extra data.</p>
+      <button class="hrl-btn" type="submit">Update preview</button>
+    </section>
+  <% end %>
+
+  <section class="hrl-card">
+    <h2 class="hrl-card__title">Columns</h2>
+    <div class="hrl-table-wrap">
+      <table class="hrl-table hrl-table--stack hrl-table--tight">
+        <thead><tr><th>In the sheet</th><th>Saved as</th></tr></thead>
+        <tbody>
+          <% @import.columns.each do |column| %>
+            <tr>
+              <td data-label="In the sheet"><%= column.header.presence || "(no header)" %></td>
+              <td data-label="Saved as"><%= column.field ? (column.field == "cv_url" ? "CV link" : column.field.humanize) : "Extra: @#{column.extra_key}" %></td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  </section>
+
+  <% skipped = @import.rows.select { |row| row.outcome == "skip" } %>
+  <% if skipped.any? %>
+    <section class="hrl-card">
+      <h2 class="hrl-card__title">Rows that will be skipped</h2>
+      <ul class="hrl-feed"><% skipped.each do |row| %><li class="hrl-feed__item">Row <%= row.number %>: <%= row.reason %></li><% end %></ul>
+    </section>
+  <% end %>
+
+  <div class="hrl-form-actions">
+    <% if @import.conflicts.empty? %>
+      <button class="hrl-btn hrl-btn--primary" type="submit" name="confirm" value="1">Import <%= counts["create"] + counts["update"] %> candidates</button>
+    <% end %>
+    <a class="hrl-btn" href="<%= hr_lite.admin_hiring_campaign_path(@campaign) %>">Cancel</a>
+  </div>
+<% end %>