ic-query 0.8.2

Internet Computer query library for NNS, SNS, ICRC, and related public network metadata
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Module: sns::report::text::proposals::detail
//!
//! Responsibility: render shared SNS proposal detail fragments.
//! Does not own: proposal fetching, cache loading, report construction, or JSON output.
//! Boundary: formats proposal detail lines and ballot tables for proposal text reports.

use super::SNS_PROPOSAL_TITLE_TEXT_LIMIT;
use crate::{
    sns::report::{
        SnsProposalBallotRow, SnsProposalRow,
        text::common::{neuron_id_text, optional_text},
    },
    table::{ColumnAlign, render_table},
    text_value::{sanitize_text, truncate_text, yes_no},
    token_amount::e8s_decimal_text,
};

pub(super) fn proposal_title_for_list(proposal: &SnsProposalRow, verbose: bool) -> String {
    if verbose {
        proposal.title.clone()
    } else {
        truncate_text(&proposal.title, SNS_PROPOSAL_TITLE_TEXT_LIMIT)
    }
}

pub(super) fn proposal_detail_lines(
    proposal: &SnsProposalRow,
    detail_limit: Option<usize>,
) -> Vec<String> {
    let mut lines = vec![
        format!("- proposal_id: {}", proposal.proposal_id),
        format!("  action_id: {}", proposal.action_id),
        format!("  action: {}", sanitize_text(&proposal.action)),
        format!(
            "  decision_state: {}",
            sanitize_text(&proposal.decision_state)
        ),
        format!("  topic: {}", safe_optional_text(proposal.topic.as_ref())),
        format!("  title: {}", sanitize_text(&proposal.title)),
        format!("  url: {}", safe_optional_text(proposal.url.as_ref())),
        format!(
            "  proposer_neuron_id: {}",
            safe_optional_text(proposal.proposer_neuron_id.as_ref())
        ),
        format!(
            "  reject_cost: {}",
            e8s_decimal_text(proposal.reject_cost_e8s)
        ),
        format!("  created_at: {}", sanitize_text(&proposal.created_at)),
        format!(
            "  decided_at: {}",
            safe_optional_text(proposal.decided_at.as_ref())
        ),
        format!(
            "  executed_at: {}",
            safe_optional_text(proposal.executed_at.as_ref())
        ),
        format!(
            "  failed_at: {}",
            safe_optional_text(proposal.failed_at.as_ref())
        ),
        format!("  reward_event_round: {}", proposal.reward_event_round),
        format!(
            "  is_eligible_for_rewards: {}",
            yes_no(proposal.is_eligible_for_rewards)
        ),
        format!("  ballot_count: {}", proposal.ballot_count),
    ];
    if let Some(tally) = proposal.latest_tally.as_ref() {
        lines.extend([
            format!("  tally_yes: {}", tally.yes),
            format!("  tally_no: {}", tally.no),
            format!("  tally_total: {}", tally.total),
        ]);
    }
    if let Some(reason) = proposal.failure_reason.as_ref() {
        lines.extend([
            format!("  failure_error_type: {}", reason.error_type),
            format!(
                "  failure_error_message: {}",
                sanitize_text(&reason.error_message)
            ),
        ]);
    }
    if !proposal.summary.is_empty() {
        lines.push(format!(
            "  summary: {}",
            proposal_detail_text(&proposal.summary, detail_limit)
        ));
    }
    if let Some(rendering) = proposal.payload_text_rendering.as_ref() {
        lines.push(format!(
            "  payload_text_rendering: {}",
            proposal_detail_text(rendering, detail_limit)
        ));
    }
    lines
}

pub(super) fn proposal_ballot_table(
    ballots: &[SnsProposalBallotRow],
    verbose: bool,
) -> Option<String> {
    if ballots.is_empty() {
        return None;
    }
    Some(render_table(
        &["NEURON_ID", "VOTE", "VOTING_POWER", "CAST_AT"],
        &ballots
            .iter()
            .map(|ballot| {
                [
                    neuron_id_text(&ballot.neuron_id, verbose),
                    ballot.vote_text.clone(),
                    e8s_decimal_text(ballot.voting_power),
                    optional_text(ballot.cast_at.as_ref()),
                ]
            })
            .collect::<Vec<_>>(),
        &[
            ColumnAlign::Left,
            ColumnAlign::Left,
            ColumnAlign::Right,
            ColumnAlign::Left,
        ],
    ))
}

fn proposal_detail_text(value: &str, detail_limit: Option<usize>) -> String {
    detail_limit.map_or_else(|| sanitize_text(value), |limit| truncate_text(value, limit))
}

fn safe_optional_text(value: Option<&String>) -> String {
    optional_text(value)
}