feat: show state and responsible subject changes in issue activity

app/assets/stylesheets/_variables.scss

@@ -48,4 +48,5 @@ $zamietnuty: rgba(0, 0, 0, 0.2);
 $odstupene: rgba(151, 71, 255, 0.7);
 $cakajuce: rgba(255, 203, 37, 1);
 $uzavrete: rgba(220, 188, 189, 1);
-$duplicitny: rgba(220, 188, 189, 1);
+$duplicitny: rgba(220, 188, 189, 1);
+$neznamy: rgba(241, 245, 249, 1);

app/assets/stylesheets/application.scss

@@ -164,6 +164,7 @@ a.button-transparent:hover {
 .state-archivovany { background: variables.$uzavrete; }
 .state-duplicitny { background: variables.$zamietnuty; }
 .state-caka-na-autora { background: variables.$cakajuce; }
+.state-unknown { background: variables.$neznamy; }
 
 .statistics-block-category-komunikacie,
 .statistics-block-category-cesty-a-chodniky { background: #C4F8FF; }
@@ -2585,6 +2586,76 @@ section.podnet .podnet-discussion .comment {
   padding: 30px 20px;
   word-break: break-word;
 }
+section.podnet .podnet-discussion .state-change-message {
+  align-items: center;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 16px;
+  margin: 10px 0;
+  padding: 10px 20px;
+}
+
+section.podnet .podnet-discussion .state-change-message .change-icon {
+  align-items: center;
+  background: variables.$blue-light;
+  border-radius: 50%;
+  display: flex;
+  height: 32px;
+  justify-content: center;
+  width: 32px;
+  flex-shrink: 0;
+
+  svg {
+    stroke: variables.$blue-dark;
+    width: 16px;
+    height: 16px;
+  }
+}
+
+section.podnet .podnet-discussion .state-change-message .content {
+  align-items: center;
+  display: flex;
+  flex: 1;
+  flex-wrap: wrap;
+  gap: 10px;
+}
+
+section.podnet .podnet-discussion .state-change-message .text {
+  align-items: center;
+  color: variables.$black-light;
+  display: flex;
+  flex-wrap: wrap;
+  font-family: variables.$general;
+  font-size: variables.em(16,16);
+  gap: 8px;
+  font-weight: variables.$medium;
+}
+
+section.podnet .podnet-discussion .state-change-message .state-badge {
+  border-radius: 12px;
+  color: variables.$black;
+  font-size: variables.em(14,16);
+  font-weight: variables.$semibold;
+  padding: 4px 12px;
+}
+
+section.podnet .podnet-discussion .state-change-message .arrow-right {
+  stroke: variables.$black-light;
+  width: 16px;
+  height: 16px;
+}
+
+section.podnet .podnet-discussion .state-change-message .date {
+  color: variables.$black-light;
+  font-size: variables.em(14,16);
+  margin-left: auto;
+}
+
+section.podnet .podnet-discussion .comment-con > *:has(.state-change-message) + * .comment,
+section.podnet .podnet-discussion .comment-con > *:has(.state-change-message) + * .edit-comment-form {
+  border-top: 1px solid variables.$black;
+}
+
 section.podnet .podnet-discussion .duplicate {
   background: variables.$green-light;
 }
@@ -3514,4 +3585,3 @@ footer .footer-nav-bottom {
 
 // 1600px
 @include meta.load-css("_100em.scss");
-

app/jobs/notifications/publish_issue_responsible_subject_changed_job.rb

@@ -0,0 +1,16 @@
+module Notifications
+  class PublishIssueResponsibleSubjectChangedJob < ApplicationJob
+    def perform(issue, responsible_subject_id_change: [], notification_mailer: NotificationMailer)
+      return unless responsible_subject_id_change.present?
+
+      previous_rs_id = responsible_subject_id_change.first
+      previous_rs = previous_rs_id.nil? ? nil : ResponsibleSubject.find(previous_rs_id)
+
+      issue.subscriptions.active.each do |subscription|
+        next unless subscription.subscriber.email_notifiable?
+
+        notification_mailer.with(subscription: subscription).issue_responsible_subject_changed(previous_rs).deliver_later
+      end
+    end
+  end
+end

app/jobs/notifications/publish_issue_state_changed_job.rb

@@ -13,6 +13,8 @@ def perform(issue, state_id_change: [], notification_mailer: NotificationMailer)
           notification_mailer.with(subscription: subscription).issue_rejected.deliver_later
         when "duplicate"
           notification_mailer.with(subscription: subscription).issue_marked_as_duplicate.deliver_later
+        when "in_progress"
+          notification_mailer.with(subscription: subscription).issue_in_progress.deliver_later
         when "resolved"
           notification_mailer.with(subscription: subscription).issue_resolved.deliver_later
         when "unresolved"

app/jobs/triage/backfill_issue_history_job.rb

@@ -0,0 +1,219 @@
+class Triage::BackfillIssueHistoryJob < ApplicationJob
+  TRIAGE_STATE_ATTRIBUTE = "ops_state"
+  TRIAGE_RESPONSIBLE_SUBJECT_ATTRIBUTE = "responsible_subject"
+
+  def perform(issue, triage_zammad_client: TriageZammadEnvironment.client)
+    ticket_ids = [ issue.triage_external_id, issue.resolution_external_id ].compact.uniq
+    if ticket_ids.empty?
+      log(issue, "has no triage ticket, skipped")
+      return
+    end
+    return if state_backfilled?(issue) && responsible_subject_backfilled?(issue)
+
+    histories = {}
+    ticket_ids.each do |ticket_id|
+      history = triage_zammad_client.get_ticket_history(ticket_id)
+      if history.nil?
+        log(issue, "ticket #{ticket_id} not found, skipped")
+        return
+      end
+      histories[ticket_id] = history
+    end
+
+    issue.with_lock do
+      backfill_state_changes(issue, histories) unless state_backfilled?(issue)
+      backfill_responsible_subject_changes(issue, histories) unless responsible_subject_backfilled?(issue)
+    end
+  end
+
+  private
+
+  def log(issue, message)
+    Rails.logger.info("BackfillIssueHistory: issue ##{issue.id} #{message}")
+  end
+
+  def state_backfilled?(issue)
+    issue.activities.where(type: "Issues::StateChangeActivity").exists?
+  end
+
+  def responsible_subject_backfilled?(issue)
+    issue.activities.where(type: "Issues::SystemResponsibleSubjectChangeActivity").exists?
+  end
+
+  def backfill_state_changes(issue, histories)
+    transitions = histories.values.flat_map { |history| state_transitions(history) }
+    transitions.sort_by! { |entry| entry[:created_at] || issue.created_at }
+
+    entries = []
+    if transitions.any?
+      first_previous = transitions.first[:previous_state]
+      entries << { previous_state: nil, new_state: first_previous, created_at: issue.created_at } if first_previous
+    elsif issue.state
+      entries << { previous_state: nil, new_state: issue.state, created_at: issue.created_at }
+    end
+    entries.concat(transitions)
+
+    if entries.empty?
+      log(issue, "has no mappable state history, skipped")
+      return
+    end
+
+    last_new_state = transitions.last&.dig(:new_state)
+    if last_new_state && issue.state_id && last_new_state.id != issue.state_id
+      log(issue, "portal state (#{issue.state.key}) differs from last Zammad state (#{last_new_state.key}), backfilling Zammad history only")
+    end
+
+    insert_state_changes!(issue, entries)
+    log(issue, "backfilled #{entries.size} state change(s)")
+  end
+
+  def backfill_responsible_subject_changes(issue, histories)
+    transitions = histories.values.flat_map { |history| responsible_subject_transitions(history) }
+    transitions.sort_by! { |entry| entry[:created_at] || issue.created_at }
+
+    entries = []
+    if transitions.any?
+      first_previous = transitions.first[:previous_responsible_subject]
+      if first_previous
+        entries << { previous_responsible_subject: nil, new_responsible_subject: first_previous, created_at: issue.created_at }
+      end
+    elsif issue.responsible_subject
+      entries << { previous_responsible_subject: nil, new_responsible_subject: issue.responsible_subject, created_at: issue.created_at }
+    end
+    entries.concat(transitions)
+
+    if entries.empty?
+      log(issue, "has no mappable responsible subject history, skipped")
+      return
+    end
+
+    last_new_rs = transitions.last&.dig(:new_responsible_subject)
+    if last_new_rs && issue.responsible_subject_id && last_new_rs.id != issue.responsible_subject_id
+      log(issue, "portal responsible subject (#{issue.responsible_subject.name}) differs from last Zammad one (#{last_new_rs.name}), backfilling Zammad history only")
+    end
+
+    insert_responsible_subject_changes!(issue, entries)
+    log(issue, "backfilled #{entries.size} responsible subject change(s)")
+  end
+
+  def state_transitions(history)
+    history
+      .select { |entry| entry["type"] == "updated" && entry["object"] == "Ticket" && entry["attribute"] == TRIAGE_STATE_ATTRIBUTE }
+      .filter_map do |entry|
+      new_state = find_state(entry["value_to"])
+
+      if new_state.nil?
+        Rails.logger.info("BackfillIssueHistory: unmappable triage state #{entry["value_to"].inspect}, entry skipped")
+        next
+      end
+
+      previous_state = find_state(entry["value_from"])
+      next if previous_state == new_state
+
+      { previous_state: previous_state, new_state: new_state, created_at: parse_time(entry["created_at"]) }
+    end
+  end
+
+  def responsible_subject_transitions(history)
+    history
+      .select { |entry| entry["type"] == "updated" && entry["object"] == "Ticket" && entry["attribute"] == TRIAGE_RESPONSIBLE_SUBJECT_ATTRIBUTE }
+      .filter_map do |entry|
+      new_rs_id = parse_responsible_subject_id(entry["value_to"])
+      new_rs = ResponsibleSubject.find_by(id: new_rs_id) if new_rs_id
+
+      if new_rs_id && new_rs.nil?
+        Rails.logger.info("BackfillIssueHistory: unmappable responsible subject #{entry["value_to"].inspect}, entry skipped")
+        next
+      end
+
+      previous_rs = find_responsible_subject(entry["value_from"])
+      next if previous_rs == new_rs
+
+      { previous_responsible_subject: previous_rs, new_responsible_subject: new_rs, created_at: parse_time(entry["created_at"]) }
+    end
+  end
+
+  def find_state(value)
+    normalized = value.to_s.strip
+    return if normalized.blank?
+
+    Issues::State.find_by(key: normalized) || Issues::State.find_by(name: normalized)
+  end
+
+  def parse_responsible_subject_id(value)
+    value.to_s[/"value"\s*=>\s*(\d+)/, 1]&.to_i
+  end
+
+  def find_responsible_subject(value)
+    id = parse_responsible_subject_id(value)
+    ResponsibleSubject.find_by(id: id) if id
+  end
+
+  def parse_time(value)
+    Time.zone.parse(value.to_s)
+  rescue StandardError
+    nil
+  end
+
+  def insert_state_changes!(issue, entries)
+    now = Time.current
+
+    activity_ids = Issues::Activity.insert_all(
+      entries.map { |entry|
+        {
+          issue_id: issue.id,
+          type: "Issues::StateChangeActivity",
+          created_at: entry[:created_at] || now,
+          updated_at: now
+        }
+      },
+      returning: %w[id]
+    ).rows.flatten
+
+    raise "activity/state change count mismatch" if activity_ids.size != entries.size
+
+    Issues::StateChange.insert_all(
+      entries.zip(activity_ids).map { |entry, activity_id|
+        {
+          activity_id: activity_id,
+          previous_state_id: entry[:previous_state]&.id,
+          new_state_id: entry[:new_state].id,
+          uuid: SecureRandom.uuid,
+          created_at: entry[:created_at] || now,
+          updated_at: now
+        }
+      }
+    )
+  end
+
+  def insert_responsible_subject_changes!(issue, entries)
+    now = Time.current
+
+    activity_ids = Issues::Activity.insert_all(
+      entries.map { |entry|
+        {
+          issue_id: issue.id,
+          type: "Issues::SystemResponsibleSubjectChangeActivity",
+          created_at: entry[:created_at] || now,
+          updated_at: now
+        }
+      },
+      returning: %w[id]
+    ).rows.flatten
+
+    raise "activity/responsible subject change count mismatch" if activity_ids.size != entries.size
+
+    Issues::SystemResponsibleSubjectChange.insert_all(
+      entries.zip(activity_ids).map { |entry, activity_id|
+        {
+          activity_id: activity_id,
+          previous_responsible_subject_id: entry[:previous_responsible_subject]&.id,
+          new_responsible_subject_id: entry[:new_responsible_subject]&.id,
+          uuid: SecureRandom.uuid,
+          created_at: entry[:created_at] || now,
+          updated_at: now
+        }
+      }
+    )
+  end
+end

app/lib/zammad_api_client.rb

@@ -122,6 +122,19 @@ def get_ticket(ticket_id, expand: false, allowed_article_types: DEFAULT_ALLOWED_
     end
   end
 
+  def get_ticket_history(ticket_id)
+    response = raw_api_request(:get, "ticket_history/#{ticket_id}")
+    history = response["history"]
+    raise "Unexpected ticket_history response shape: #{response.keys.inspect}" unless history.is_a?(Array)
+
+    history.sort_by { |entry| entry["created_at"].to_s }
+  rescue RuntimeError => e
+    raise e unless e.message.include?("Couldn't find Ticket with") || e.message.include?("Request failed with status 404")
+
+    Rails.logger.info("Couldn't find history for ticket with id: #{ticket_id}")
+    nil
+  end
+
   def create_ticket_from_issue!(issue, issue_number:, process_type: DEFAULT_PROCESS_TYPE, state: nil, group: DEFAULT_GROUP, sender: DEFAULT_SENDER, owner_id: nil)
     ops_state = issue.state&.key
     if issue.issue_type == "praise" && ops_state == "resolved_private"

app/mailers/notification_mailer.rb

@@ -52,10 +52,20 @@ def issue_rejected
     mail
   end
 
+  def issue_in_progress
+    mail
+  end
+
   def issue_marked_as_duplicate
     mail
   end
 
+  def issue_responsible_subject_changed(previous_rs)
+    @previous_rs = previous_rs
+    @new_rs = @issue.responsible_subject
+    mail
+  end
+
   def issue_waiting_for_author
     mail
   end