Niklas Ye
6834302622
Release / build (amd64, linux) (push) Failing after 6s
Release / release (push) Has been skipped
Release / build (amd64, darwin) (push) Failing after 5s
Release / build (arm64, darwin) (push) Failing after 6s
Release / build (arm64, linux) (push) Failing after 11s
Add a fourth tab (Alerts | Archived | Schedule | Users). Archived alerts are fetched lazily on first visit using the archived=true query param on GET /api/alerts. Press x from the Alerts list or detail to archive an alert; the non-archived list refreshes immediately. Press x from the Archived list or detail to unarchive; the archived list refreshes. Ack/unack are disabled in the Archived detail view. New API methods: ArchiveAlert (POST), UnarchiveAlert (DELETE). ArchivedAt field added to the Alert type.
633 lines
19 KiB
Go
633 lines
19 KiB
Go
package tui
|
||
|
||
import (
|
||
"fmt"
|
||
"sort"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/charmbracelet/lipgloss"
|
||
"github.com/yeniklas/terdut-tui/internal/api"
|
||
)
|
||
|
||
var sectionNames = []string{"Alerts", "Archived", "Schedule", "Users"}
|
||
|
||
func (m Model) View() string {
|
||
if m.width == 0 {
|
||
return ""
|
||
}
|
||
return lipgloss.JoinVertical(lipgloss.Left,
|
||
m.renderHeader(),
|
||
m.renderTabs(),
|
||
m.renderBody(),
|
||
m.renderFooter(),
|
||
)
|
||
}
|
||
|
||
func (m Model) renderHeader() string {
|
||
title := styleHeader.Render("terdut-tui")
|
||
right := styleMuted.Render(m.serverURL)
|
||
gap := m.width - lipgloss.Width(title) - lipgloss.Width(right)
|
||
if gap < 0 {
|
||
gap = 0
|
||
}
|
||
return title + strings.Repeat(" ", gap) + right
|
||
}
|
||
|
||
func (m Model) renderTabs() string {
|
||
var tabs []string
|
||
for i, name := range sectionNames {
|
||
if section(i) == m.activeSection {
|
||
tabs = append(tabs, styleTabActive.Render(name))
|
||
} else {
|
||
tabs = append(tabs, styleTabInactive.Render(name))
|
||
}
|
||
}
|
||
sep := styleMuted.Render(strings.Repeat("─", m.width))
|
||
return strings.Join(tabs, "") + "\n" + sep
|
||
}
|
||
|
||
func (m Model) renderBody() string {
|
||
if m.err != nil {
|
||
return "\n" + styleError.Render(fmt.Sprintf(" Error: %v", m.err)) +
|
||
"\n" + styleMuted.Render(" Press r to retry.")
|
||
}
|
||
if !m.connected {
|
||
return "\n" + styleMuted.Render(" Connecting…")
|
||
}
|
||
|
||
switch m.mode {
|
||
case modeDetail:
|
||
return m.renderDetail()
|
||
case modeComment:
|
||
return m.renderCommentCompose()
|
||
case modeConfirmDelete:
|
||
switch m.confirmTarget {
|
||
case confirmDeleteComment:
|
||
return m.renderDetail()
|
||
case confirmDeleteUser:
|
||
return m.renderUsers()
|
||
default:
|
||
return m.renderSchedule()
|
||
}
|
||
case modeStats:
|
||
return m.renderStats()
|
||
case modeScheduleUserPicker:
|
||
return m.renderUserPicker()
|
||
case modeUserCreate:
|
||
return m.renderUserCreate()
|
||
case modeAPIKeyMenu:
|
||
return m.renderAPIKeyMenu()
|
||
case modeAPIKeyCreate:
|
||
return m.renderAPIKeyCreate()
|
||
case modeAPIKeyReveal:
|
||
return m.renderAPIKeyReveal()
|
||
case modeAPIKeyRevokeByID:
|
||
return m.renderAPIKeyRevokeByID()
|
||
default:
|
||
return m.renderDashboard()
|
||
}
|
||
}
|
||
|
||
func (m Model) renderFooter() string {
|
||
switch m.mode {
|
||
case modeDetail:
|
||
var actions string
|
||
if m.activeSection == sectionArchived {
|
||
actions = styleFooter.Render(" x·unarchive c·comment [/]·select d·del S·stats esc·back")
|
||
} else {
|
||
actions = styleFooter.Render(" a·ack A·unack x·archive c·comment [/]·select d·del s·assign S·stats esc·back")
|
||
}
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + actions
|
||
}
|
||
return "\n" + actions
|
||
|
||
case modeComment:
|
||
return "\n" + styleFooter.Render(" enter·submit esc·cancel")
|
||
|
||
case modeConfirmDelete:
|
||
var deleteDesc string
|
||
switch m.confirmTarget {
|
||
case confirmDeleteComment:
|
||
if m.commentCursor >= 0 && m.commentCursor < len(m.comments) {
|
||
deleteDesc = fmt.Sprintf("comment by %s", m.comments[m.commentCursor].Username)
|
||
} else {
|
||
deleteDesc = "comment"
|
||
}
|
||
case confirmDeleteScheduleEntry:
|
||
if m.pendingDeleteEntry != nil {
|
||
deleteDesc = fmt.Sprintf("on-call for %s (%s)", m.pendingDeleteEntry.Date, m.pendingDeleteEntry.Username)
|
||
} else {
|
||
deleteDesc = "schedule entry"
|
||
}
|
||
case confirmDeleteUser:
|
||
deleteDesc = fmt.Sprintf("user %s (cascades all API keys)", m.selectedUser.Username)
|
||
}
|
||
return "\n" + styleError.Render(fmt.Sprintf(" Delete %s? [y/N]", deleteDesc))
|
||
|
||
case modeStats:
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + styleFooter.Render(" esc·back")
|
||
}
|
||
return "\n" + styleFooter.Render(" esc·back")
|
||
|
||
case modeScheduleUserPicker:
|
||
mode := "day"
|
||
if m.pickerAssignWeek {
|
||
mode = "week"
|
||
}
|
||
return "\n" + styleFooter.Render(fmt.Sprintf(" j/k·navigate enter·assign %s esc·cancel", mode))
|
||
|
||
case modeUserCreate:
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + styleFooter.Render(" tab·next field enter·create esc·cancel")
|
||
}
|
||
return "\n" + styleFooter.Render(" tab·next field enter·create esc·cancel")
|
||
|
||
case modeAPIKeyMenu:
|
||
return "\n" + styleFooter.Render(" n·new key r·revoke by ID esc·back")
|
||
|
||
case modeAPIKeyCreate:
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + styleFooter.Render(" enter·create esc·back")
|
||
}
|
||
return "\n" + styleFooter.Render(" enter·create esc·back")
|
||
|
||
case modeAPIKeyReveal:
|
||
footer := " c·copy to clipboard esc·done"
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + styleFooter.Render(footer)
|
||
}
|
||
return "\n" + styleFooter.Render(footer)
|
||
|
||
case modeAPIKeyRevokeByID:
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + styleFooter.Render(" enter·revoke esc·back")
|
||
}
|
||
return "\n" + styleFooter.Render(" enter·revoke esc·back")
|
||
|
||
default:
|
||
if m.activeSection == sectionArchived {
|
||
actions := styleFooter.Render(" x·unarchive enter·detail r·refresh tab·section q·quit")
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + actions
|
||
}
|
||
return "\n" + actions
|
||
}
|
||
if m.activeSection == sectionSchedule {
|
||
actions := styleFooter.Render(" +·assign day W·assign week d·del ←/→·shift week tab·section r·refresh q·quit")
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + actions
|
||
}
|
||
return "\n" + actions
|
||
}
|
||
if m.activeSection == sectionUsers {
|
||
actions := styleFooter.Render(" n·new user d·delete k·API keys r·refresh tab·section q·quit")
|
||
if m.statusMsg != "" {
|
||
return styleStatus.Render(" "+m.statusMsg) + "\n" + actions
|
||
}
|
||
return "\n" + actions
|
||
}
|
||
var footerLeft string
|
||
if m.activeSection == sectionAlerts {
|
||
footerLeft = styleFooter.Render(" x·archive")
|
||
}
|
||
helpView := styleFooter.Render(m.help.ShortHelpView(m.keys.ShortHelp()))
|
||
if m.statusMsg != "" {
|
||
status := styleStatus.Render(m.statusMsg)
|
||
gap := m.width - lipgloss.Width(status) - lipgloss.Width(helpView)
|
||
if gap < 0 {
|
||
gap = 0
|
||
}
|
||
return "\n" + status + strings.Repeat(" ", gap) + helpView
|
||
}
|
||
if footerLeft != "" {
|
||
gap := m.width - lipgloss.Width(footerLeft) - lipgloss.Width(helpView)
|
||
if gap < 0 {
|
||
gap = 0
|
||
}
|
||
return "\n" + footerLeft + strings.Repeat(" ", gap) + helpView
|
||
}
|
||
return "\n" + helpView
|
||
}
|
||
}
|
||
|
||
// ── Dashboard ──────────────────────────────────────────────────────────────
|
||
|
||
func (m Model) renderDashboard() string {
|
||
switch m.activeSection {
|
||
case sectionAlerts:
|
||
return m.renderAlerts()
|
||
case sectionArchived:
|
||
return m.renderArchived()
|
||
case sectionSchedule:
|
||
return m.renderSchedule()
|
||
case sectionUsers:
|
||
return m.renderUsers()
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// ── Schedule ───────────────────────────────────────────────────────────────
|
||
|
||
func (m Model) renderSchedule() string {
|
||
if m.scheduleLoading {
|
||
return "\n" + styleMuted.Render(" Loading schedule…")
|
||
}
|
||
|
||
// On-call header
|
||
var onCallLine string
|
||
if m.currentOnCall != nil {
|
||
onCallLine = fmt.Sprintf(" On-call today: %s",
|
||
styleAlertName.Render(m.currentOnCall.Username))
|
||
} else {
|
||
onCallLine = styleMuted.Render(" On-call today: nobody scheduled")
|
||
}
|
||
|
||
// Window label
|
||
from := m.scheduleWindow
|
||
to := m.scheduleWindow.AddDate(0, 0, 6)
|
||
windowLabel := styleMuted.Render(fmt.Sprintf(" %s — %s",
|
||
from.Format("Jan 02"), to.Format("Jan 02, 2006")))
|
||
|
||
gap := m.width - lipgloss.Width(onCallLine) - lipgloss.Width(windowLabel)
|
||
if gap < 0 {
|
||
gap = 0
|
||
}
|
||
header := "\n" + onCallLine + strings.Repeat(" ", gap) + windowLabel + "\n"
|
||
return header + m.scheduleTable.View()
|
||
}
|
||
|
||
func (m Model) renderUserPicker() string {
|
||
if m.usersLoading {
|
||
return "\n" + styleMuted.Render(" Loading users…")
|
||
}
|
||
|
||
var scope string
|
||
cursor := m.scheduleTable.Cursor()
|
||
if cursor >= 0 && cursor < len(m.scheduleDays) {
|
||
d := m.scheduleDays[cursor].date
|
||
if m.pickerAssignWeek {
|
||
weekday := int(d.Weekday())
|
||
if weekday == 0 {
|
||
weekday = 7
|
||
}
|
||
monday := d.AddDate(0, 0, -(weekday - 1))
|
||
sunday := monday.AddDate(0, 0, 6)
|
||
_, week := d.ISOWeek()
|
||
scope = fmt.Sprintf("week W%02d (%s–%s)",
|
||
week, monday.Format("Jan 02"), sunday.Format("Jan 02"))
|
||
} else {
|
||
if d.Format("2006-01-02") == time.Now().UTC().Format("2006-01-02") {
|
||
scope = "Today (" + d.Format("Mon") + ")"
|
||
} else {
|
||
scope = d.Format("Jan 02 (Mon)")
|
||
}
|
||
}
|
||
}
|
||
|
||
header := fmt.Sprintf("\n Assign on-call for %s — select a user:\n\n",
|
||
styleBold.Render(scope))
|
||
return header + m.userPickerTable.View()
|
||
}
|
||
|
||
func (m Model) renderAlerts() string {
|
||
statsBar := m.renderStatsBar()
|
||
var content string
|
||
if m.loading && len(m.alerts) == 0 {
|
||
content = styleMuted.Render(" Loading alerts…")
|
||
} else if len(m.alerts) == 0 {
|
||
label := m.filterStatus
|
||
if label == "" {
|
||
label = "all"
|
||
}
|
||
content = styleMuted.Render(fmt.Sprintf(" No %s alerts.", label))
|
||
} else {
|
||
content = m.alertTable.View()
|
||
}
|
||
return lipgloss.JoinVertical(lipgloss.Left, statsBar, content)
|
||
}
|
||
|
||
func (m Model) renderArchived() string {
|
||
if m.archivedLoading {
|
||
return styleMuted.Render(" Loading archived alerts…")
|
||
}
|
||
if len(m.archivedAlerts) == 0 {
|
||
return styleMuted.Render(" No archived alerts.")
|
||
}
|
||
return m.archivedTable.View()
|
||
}
|
||
|
||
func (m Model) renderStatsBar() string {
|
||
total, firing, resolved := 0, 0, 0
|
||
if m.stats != nil {
|
||
total = m.stats.Total
|
||
firing = m.stats.Firing
|
||
resolved = m.stats.Resolved
|
||
}
|
||
filterLabel := m.filterStatus
|
||
if filterLabel == "" {
|
||
filterLabel = "all"
|
||
}
|
||
left := fmt.Sprintf(" Total: %d %s %s",
|
||
total,
|
||
styleFiring.Render(fmt.Sprintf("Firing: %d", firing)),
|
||
styleResolved.Render(fmt.Sprintf("Resolved: %d", resolved)),
|
||
)
|
||
right := styleMuted.Render(fmt.Sprintf("filter: %s [f] ", filterLabel))
|
||
gap := m.width - lipgloss.Width(left) - lipgloss.Width(right)
|
||
if gap < 0 {
|
||
gap = 0
|
||
}
|
||
return left + strings.Repeat(" ", gap) + right
|
||
}
|
||
|
||
// ── Detail ─────────────────────────────────────────────────────────────────
|
||
|
||
func (m Model) renderDetail() string {
|
||
if m.detailLoading {
|
||
return "\n" + styleMuted.Render(" Loading alert details…")
|
||
}
|
||
return m.detailViewport.View()
|
||
}
|
||
|
||
func (m Model) renderCommentCompose() string {
|
||
vp := m.detailViewport.View()
|
||
sep := styleMuted.Render(strings.Repeat("─", m.width))
|
||
prompt := styleHeader.Render("Comment: ") + m.commentInput.View()
|
||
return vp + "\n" + sep + "\n" + prompt
|
||
}
|
||
|
||
// ── Stats ──────────────────────────────────────────────────────────────────
|
||
|
||
func (m Model) renderStats() string {
|
||
if m.statsLoading {
|
||
return "\n" + styleMuted.Render(" Loading statistics…")
|
||
}
|
||
return m.statsViewport.View()
|
||
}
|
||
|
||
// ── Content builders ───────────────────────────────────────────────────────
|
||
|
||
func buildDetailContent(alert api.Alert, comments []api.Comment, cursor, width int) string {
|
||
now := time.Now()
|
||
var b strings.Builder
|
||
contentW := width - 4
|
||
|
||
// Name + status header
|
||
name := styleAlertName.Render(alert.Name)
|
||
var statusStr string
|
||
if alert.Status == "firing" {
|
||
statusStr = styleFiring.Render("● FIRING")
|
||
} else {
|
||
statusStr = styleResolved.Render("✓ RESOLVED")
|
||
}
|
||
nameGap := contentW - lipgloss.Width(name) - lipgloss.Width(statusStr)
|
||
if nameGap < 1 {
|
||
nameGap = 1
|
||
}
|
||
b.WriteString("\n " + name + strings.Repeat(" ", nameGap) + statusStr + "\n\n")
|
||
|
||
// Timeline
|
||
b.WriteString(fmt.Sprintf(" Started: %s (%s)\n",
|
||
alert.StartsAt.UTC().Format("2006-01-02 15:04 UTC"), humanAgo(now, alert.StartsAt)))
|
||
if alert.EndsAt != nil {
|
||
b.WriteString(fmt.Sprintf(" Ended: %s\n", alert.EndsAt.UTC().Format("2006-01-02 15:04 UTC")))
|
||
}
|
||
if alert.GeneratorURL != "" {
|
||
url := alert.GeneratorURL
|
||
if len(url) > contentW-12 {
|
||
url = url[:contentW-15] + "…"
|
||
}
|
||
b.WriteString(fmt.Sprintf(" Source: %s\n", url))
|
||
}
|
||
b.WriteString("\n")
|
||
|
||
// Labels
|
||
if len(alert.Labels) > 0 {
|
||
b.WriteString(divider("Labels", width))
|
||
for _, k := range sortedKeys(alert.Labels) {
|
||
v := alert.Labels[k]
|
||
if len(v) > contentW-24 {
|
||
v = v[:contentW-27] + "…"
|
||
}
|
||
b.WriteString(fmt.Sprintf(" %-22s %s\n", k, v))
|
||
}
|
||
b.WriteString("\n")
|
||
}
|
||
|
||
// Annotations
|
||
if len(alert.Annotations) > 0 {
|
||
b.WriteString(divider("Annotations", width))
|
||
for _, k := range sortedKeys(alert.Annotations) {
|
||
v := alert.Annotations[k]
|
||
if len(v) > contentW-24 {
|
||
v = v[:contentW-27] + "…"
|
||
}
|
||
b.WriteString(fmt.Sprintf(" %-22s %s\n", k, v))
|
||
}
|
||
b.WriteString("\n")
|
||
}
|
||
|
||
// Acknowledgement
|
||
b.WriteString(divider("Acknowledgement", width))
|
||
if alert.AcknowledgedByID != nil {
|
||
ackAt := ""
|
||
if alert.AcknowledgedAt != nil {
|
||
ackAt = " at " + alert.AcknowledgedAt.UTC().Format("2006-01-02 15:04 UTC")
|
||
}
|
||
b.WriteString(styleResolved.Render(fmt.Sprintf(" ✓ Acknowledged by %s%s\n", alert.AcknowledgedBy, ackAt)))
|
||
} else {
|
||
b.WriteString(styleMuted.Render(" Not acknowledged\n"))
|
||
}
|
||
b.WriteString("\n")
|
||
|
||
// Comments
|
||
b.WriteString(divider(fmt.Sprintf("Comments (%d)", len(comments)), width))
|
||
if len(comments) == 0 {
|
||
b.WriteString(styleMuted.Render(" No comments yet.\n"))
|
||
} else {
|
||
for i, c := range comments {
|
||
prefix := " "
|
||
authorLine := fmt.Sprintf("%s%s • %s", prefix, styleBold.Render(c.Username), humanAgo(now, c.CreatedAt))
|
||
if i == cursor {
|
||
authorLine = styleSelected.Render("> ") + styleBold.Render(c.Username) +
|
||
styleMuted.Render(fmt.Sprintf(" • %s", humanAgo(now, c.CreatedAt)))
|
||
}
|
||
b.WriteString(authorLine + "\n")
|
||
b.WriteString(" " + c.Content + "\n\n")
|
||
}
|
||
}
|
||
|
||
return b.String()
|
||
}
|
||
|
||
func buildStatsContent(top []api.TopAlert, byHour []api.HourStat, byDay []api.DayStat, width int) string {
|
||
barWidth := width/2 - 10
|
||
if barWidth < 8 {
|
||
barWidth = 8
|
||
}
|
||
if barWidth > 40 {
|
||
barWidth = 40
|
||
}
|
||
|
||
var b strings.Builder
|
||
b.WriteString("\n")
|
||
|
||
// Top alerts
|
||
b.WriteString(divider("Top Alerts", width))
|
||
if len(top) == 0 {
|
||
b.WriteString(styleMuted.Render(" No data.\n"))
|
||
} else {
|
||
maxCount := top[0].Count
|
||
for i, a := range top {
|
||
bar := styleResolved.Render(strings.Repeat("█", renderBarWidth(a.Count, maxCount, barWidth)))
|
||
b.WriteString(fmt.Sprintf(" %2d. %-30s %s %d\n", i+1, truncate(a.Name, 30), bar, a.Count))
|
||
}
|
||
}
|
||
b.WriteString("\n")
|
||
|
||
// By hour
|
||
b.WriteString(divider("Alerts by Hour (UTC)", width))
|
||
if len(byHour) > 0 {
|
||
maxCount := 0
|
||
for _, h := range byHour {
|
||
if h.Count > maxCount {
|
||
maxCount = h.Count
|
||
}
|
||
}
|
||
for _, h := range byHour {
|
||
bar := styleFiring.Render(strings.Repeat("█", renderBarWidth(h.Count, maxCount, barWidth)))
|
||
b.WriteString(fmt.Sprintf(" %2dh %-*s %d\n", h.Hour, barWidth, bar, h.Count))
|
||
}
|
||
} else {
|
||
b.WriteString(styleMuted.Render(" No data.\n"))
|
||
}
|
||
b.WriteString("\n")
|
||
|
||
// By day
|
||
b.WriteString(divider("Alerts by Day", width))
|
||
if len(byDay) > 0 {
|
||
maxCount := 0
|
||
for _, d := range byDay {
|
||
if d.Count > maxCount {
|
||
maxCount = d.Count
|
||
}
|
||
}
|
||
for _, d := range byDay {
|
||
bar := styleAccent.Render(strings.Repeat("█", renderBarWidth(d.Count, maxCount, barWidth)))
|
||
b.WriteString(fmt.Sprintf(" %-4s %-*s %d\n", d.DayName[:3], barWidth, bar, d.Count))
|
||
}
|
||
} else {
|
||
b.WriteString(styleMuted.Render(" No data.\n"))
|
||
}
|
||
|
||
return b.String()
|
||
}
|
||
|
||
// ── Users ──────────────────────────────────────────────────────────────────
|
||
|
||
func (m Model) renderUsers() string {
|
||
if m.usersLoading {
|
||
return "\n" + styleMuted.Render(" Loading users…")
|
||
}
|
||
if len(m.users) == 0 {
|
||
return "\n" + styleMuted.Render(" No users found. Press n to create one.")
|
||
}
|
||
return "\n" + m.userManageTable.View()
|
||
}
|
||
|
||
func (m Model) renderUserCreate() string {
|
||
header := "\n " + styleBold.Render("Create new user") + "\n\n"
|
||
usernameLabel := " Username: "
|
||
emailLabel := " Email: "
|
||
if m.userFormFocus == 0 {
|
||
usernameLabel = styleSelected.Render(" Username: ")
|
||
} else {
|
||
emailLabel = styleSelected.Render(" Email: ")
|
||
}
|
||
return header +
|
||
usernameLabel + m.userFormInputs[0].View() + "\n" +
|
||
emailLabel + m.userFormInputs[1].View() + "\n"
|
||
}
|
||
|
||
func (m Model) renderAPIKeyMenu() string {
|
||
header := fmt.Sprintf("\n API keys for %s\n", styleBold.Render(m.selectedUser.Username))
|
||
warning := styleMuted.Render(" Keys cannot be listed — only new keys can be created,\n or existing ones revoked by their integer ID.\n")
|
||
options := "\n" +
|
||
styleAccent.Render(" n") + " · create a new API key\n" +
|
||
styleAccent.Render(" r") + " · revoke a key by ID\n"
|
||
return header + "\n" + warning + options
|
||
}
|
||
|
||
func (m Model) renderAPIKeyCreate() string {
|
||
header := fmt.Sprintf("\n New API key for %s\n\n", styleBold.Render(m.selectedUser.Username))
|
||
label := styleSelected.Render(" Key name: ")
|
||
return header + label + m.apiKeyNameInput.View() + "\n"
|
||
}
|
||
|
||
func (m Model) renderAPIKeyReveal() string {
|
||
sep := styleMuted.Render(strings.Repeat("─", m.width))
|
||
warn := styleError.Render(" !! COPY NOW — this key will NEVER be shown again !!")
|
||
nameLine := fmt.Sprintf(" Key name: %s", styleBold.Render(m.revealedAPIKey.Name))
|
||
idLine := fmt.Sprintf(" Key ID: %s %s",
|
||
styleBold.Render(fmt.Sprintf("%d", m.revealedAPIKey.ID)),
|
||
styleMuted.Render("(save this — needed for future revocation)"))
|
||
|
||
keyLine := styleResolved.Render(" " + m.revealedAPIKey.Key)
|
||
|
||
return "\n" + sep + "\n\n" +
|
||
warn + "\n\n" +
|
||
nameLine + "\n" +
|
||
idLine + "\n\n" +
|
||
styleMuted.Render(" Key value:") + "\n" +
|
||
keyLine + "\n\n" +
|
||
sep + "\n"
|
||
}
|
||
|
||
func (m Model) renderAPIKeyRevokeByID() string {
|
||
header := fmt.Sprintf("\n Revoke API key for %s\n", styleBold.Render(m.selectedUser.Username))
|
||
hint := styleMuted.Render(" Enter the integer key ID (shown when the key was created).\n")
|
||
label := styleSelected.Render(" Key ID: ")
|
||
return header + "\n" + hint + "\n" + label + m.apiKeyRevokeInput.View() + "\n"
|
||
}
|
||
|
||
// ── Helpers ────────────────────────────────────────────────────────────────
|
||
|
||
func divider(title string, width int) string {
|
||
prefix := "── " + title + " "
|
||
remaining := width - len(prefix) - 2
|
||
if remaining > 0 {
|
||
prefix += strings.Repeat("─", remaining)
|
||
}
|
||
return styleMuted.Render(prefix) + "\n"
|
||
}
|
||
|
||
func sortedKeys(m map[string]string) []string {
|
||
keys := make([]string, 0, len(m))
|
||
for k := range m {
|
||
keys = append(keys, k)
|
||
}
|
||
sort.Strings(keys)
|
||
return keys
|
||
}
|
||
|
||
func renderBarWidth(count, maxCount, maxWidth int) int {
|
||
if maxCount == 0 {
|
||
return 0
|
||
}
|
||
w := count * maxWidth / maxCount
|
||
if w == 0 && count > 0 {
|
||
w = 1
|
||
}
|
||
return w
|
||
}
|
||
|
||
func truncate(s string, max int) string {
|
||
if len(s) <= max {
|
||
return s
|
||
}
|
||
return s[:max-1] + "…"
|
||
}
|