feat(khira): enterprise suite overhaul with analytics dashboard, bulk actions, command palette, SLA monitoring, and zero-FOUT vector icons
This commit is contained in:
@@ -132,10 +132,60 @@ CREATE TABLE IF NOT EXISTS khira_sequences (
|
||||
val INT NOT NULL DEFAULT 100
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS ticket_tags (
|
||||
ticket_id VARCHAR(32) NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
|
||||
tag VARCHAR(64) NOT NULL,
|
||||
PRIMARY KEY (ticket_id, tag)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS error_tags (
|
||||
error_id VARCHAR(32) NOT NULL REFERENCES errors(id) ON DELETE CASCADE,
|
||||
tag VARCHAR(64) NOT NULL,
|
||||
PRIMARY KEY (error_id, tag)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS ticket_relations (
|
||||
id SERIAL PRIMARY KEY,
|
||||
ticket_a VARCHAR(32) NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
|
||||
ticket_b VARCHAR(32) NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
|
||||
relation_type VARCHAR(32) NOT NULL DEFAULT 'related',
|
||||
created_by VARCHAR(64) NOT NULL DEFAULT '',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
|
||||
UNIQUE(ticket_a, ticket_b)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS saved_filters (
|
||||
id VARCHAR(64) PRIMARY KEY,
|
||||
user_id VARCHAR(64) NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
name VARCHAR(128) NOT NULL,
|
||||
filter_json TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS api_tokens (
|
||||
id VARCHAR(64) PRIMARY KEY,
|
||||
user_id VARCHAR(64) NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
name VARCHAR(128) NOT NULL,
|
||||
token_hash VARCHAR(128) NOT NULL UNIQUE,
|
||||
scopes TEXT NOT NULL DEFAULT 'errors:write',
|
||||
last_used_at TIMESTAMPTZ,
|
||||
revoked BOOLEAN NOT NULL DEFAULT FALSE,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
ALTER TABLE tickets ADD COLUMN IF NOT EXISTS due_date TIMESTAMPTZ;
|
||||
ALTER TABLE tickets ADD COLUMN IF NOT EXISTS sla_hours INT NOT NULL DEFAULT 0;
|
||||
ALTER TABLE tickets ADD COLUMN IF NOT EXISTS sla_breached BOOLEAN NOT NULL DEFAULT FALSE;
|
||||
|
||||
ALTER TABLE users ADD COLUMN IF NOT EXISTS active BOOLEAN NOT NULL DEFAULT TRUE;
|
||||
ALTER TABLE users ADD COLUMN IF NOT EXISTS last_active_at TIMESTAMPTZ;
|
||||
ALTER TABLE users ADD COLUMN IF NOT EXISTS deactivated_at TIMESTAMPTZ;
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_tickets_assigned_to ON tickets(assigned_to);
|
||||
CREATE INDEX IF NOT EXISTS idx_tickets_status ON tickets(status);
|
||||
CREATE INDEX IF NOT EXISTS idx_tickets_created_at ON tickets(created_at DESC);
|
||||
CREATE INDEX IF NOT EXISTS idx_ticket_remarks_ticket_id ON ticket_remarks(ticket_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_ticket_tags_tag ON ticket_tags(tag);
|
||||
CREATE INDEX IF NOT EXISTS idx_errors_status ON errors(status);
|
||||
CREATE INDEX IF NOT EXISTS idx_errors_last_seen ON errors(last_seen DESC);
|
||||
CREATE INDEX IF NOT EXISTS idx_notifications_user_read ON notifications(user_id, read);
|
||||
|
||||
@@ -0,0 +1,685 @@
|
||||
package khira
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
// Default SLA hours per priority
|
||||
var DefaultSLAHours = map[string]int{
|
||||
"critical": 4,
|
||||
"high": 24,
|
||||
"medium": 72,
|
||||
"low": 168,
|
||||
"p0": 4,
|
||||
"p1": 24,
|
||||
"p2": 72,
|
||||
"p3": 168,
|
||||
}
|
||||
|
||||
func calculateDefaultSLA(priority string) int {
|
||||
p := strings.ToLower(strings.TrimSpace(priority))
|
||||
if h, ok := DefaultSLAHours[p]; ok {
|
||||
return h
|
||||
}
|
||||
return 72
|
||||
}
|
||||
|
||||
// CheckSLABreaches inspects active tickets and flags overdue ones
|
||||
func (s *Store) CheckSLABreaches() (int, error) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
|
||||
rows, err := s.primaryDB.Query(`
|
||||
SELECT id, priority, assigned_to, created_by, due_date
|
||||
FROM tickets
|
||||
WHERE status IN ('open', 'in_progress', 'on_hold')
|
||||
AND due_date IS NOT NULL
|
||||
AND due_date < NOW()
|
||||
AND sla_breached = FALSE
|
||||
AND archived = FALSE
|
||||
`)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
type breachItem struct {
|
||||
id string
|
||||
priority string
|
||||
assignedTo string
|
||||
createdBy string
|
||||
dueDate time.Time
|
||||
}
|
||||
|
||||
var breaches []breachItem
|
||||
for rows.Next() {
|
||||
var b breachItem
|
||||
if err := rows.Scan(&b.id, &b.priority, &b.assignedTo, &b.createdBy, &b.dueDate); err == nil {
|
||||
breaches = append(breaches, b)
|
||||
}
|
||||
}
|
||||
|
||||
now := time.Now()
|
||||
for _, b := range breaches {
|
||||
_, _ = s.primaryDB.Exec(`UPDATE tickets SET sla_breached = TRUE, updated_at = $1 WHERE id = $2`, now, b.id)
|
||||
|
||||
// Record remark
|
||||
remID := uuid.New().String()
|
||||
_, _ = s.primaryDB.Exec(`
|
||||
INSERT INTO ticket_remarks (id, ticket_id, author_username, author_name, author_role, type, text, created_at)
|
||||
VALUES ($1, $2, 'system', 'SLA Monitor', 'System', 'sla_breach', $3, $4)
|
||||
`, remID, b.id, fmt.Sprintf("SLA breached! Due date (%s) has passed.", b.dueDate.Format("2006-01-02 15:04")), now)
|
||||
|
||||
// Notify assignee & creator
|
||||
if b.assignedTo != "" {
|
||||
s.addNotification(b.assignedTo, b.id, "SLA Breached", fmt.Sprintf("Ticket %s is overdue!", b.id), "sla_breach")
|
||||
}
|
||||
if b.createdBy != "" && !strings.EqualFold(b.createdBy, b.assignedTo) {
|
||||
s.addNotification(b.createdBy, b.id, "SLA Breached", fmt.Sprintf("Ticket %s is overdue!", b.id), "sla_breach")
|
||||
}
|
||||
}
|
||||
|
||||
return len(breaches), nil
|
||||
}
|
||||
|
||||
// StartSLAMonitor periodically evaluates SLA breaches in the background
|
||||
func (s *Store) StartSLAMonitor() {
|
||||
go func() {
|
||||
ticker := time.NewTicker(3 * time.Minute)
|
||||
defer ticker.Stop()
|
||||
for range ticker.C {
|
||||
_, _ = s.CheckSLABreaches()
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// GetAnalyticsData calculates comprehensive productivity, SLA, and error metrics
|
||||
func (s *Store) GetAnalyticsData() (*AnalyticsData, error) {
|
||||
data := &AnalyticsData{
|
||||
ByPriority: make(map[string]int),
|
||||
}
|
||||
|
||||
// 1. Summary Counts
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM tickets WHERE archived = FALSE`).Scan(&data.Summary.TotalTickets)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM tickets WHERE status = 'open' AND archived = FALSE`).Scan(&data.Summary.OpenTickets)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM tickets WHERE status = 'in_progress' AND archived = FALSE`).Scan(&data.Summary.InProgressTickets)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM tickets WHERE status = 'on_hold' AND archived = FALSE`).Scan(&data.Summary.OnHoldTickets)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM tickets WHERE status = 'completed' AND archived = FALSE`).Scan(&data.Summary.CompletedTickets)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM tickets WHERE archived = TRUE`).Scan(&data.Summary.ArchivedTickets)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM tickets WHERE sla_breached = TRUE AND archived = FALSE`).Scan(&data.Summary.SLABreachedTickets)
|
||||
|
||||
// Avg resolution time in hours
|
||||
var avgSeconds sql.NullFloat64
|
||||
_ = s.primaryDB.QueryRow(`
|
||||
SELECT AVG(EXTRACT(EPOCH FROM (completed_at - created_at)))
|
||||
FROM tickets
|
||||
WHERE status = 'completed' AND completed_at IS NOT NULL
|
||||
`).Scan(&avgSeconds)
|
||||
if avgSeconds.Valid && avgSeconds.Float64 > 0 {
|
||||
data.Summary.AvgResolutionHours = float64(int(avgSeconds.Float64/360.0)) / 10.0 // 1 decimal place
|
||||
}
|
||||
|
||||
// 2. Priority Breakdown
|
||||
pRows, err := s.primaryDB.Query(`
|
||||
SELECT LOWER(priority), count(*)
|
||||
FROM tickets
|
||||
WHERE archived = FALSE
|
||||
GROUP BY LOWER(priority)
|
||||
`)
|
||||
if err == nil {
|
||||
defer pRows.Close()
|
||||
for pRows.Next() {
|
||||
var p string
|
||||
var c int
|
||||
if err := pRows.Scan(&p, &c); err == nil {
|
||||
data.ByPriority[p] = c
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Weekly Velocity (past 8 weeks)
|
||||
for i := 7; i >= 0; i-- {
|
||||
start := time.Now().AddDate(0, 0, -7*(i+1))
|
||||
end := time.Now().AddDate(0, 0, -7*i)
|
||||
weekLabel := end.Format("01/02")
|
||||
|
||||
var createdCount, resolvedCount int
|
||||
_ = s.primaryDB.QueryRow(`
|
||||
SELECT count(*) FROM tickets WHERE created_at >= $1 AND created_at < $2
|
||||
`, start, end).Scan(&createdCount)
|
||||
|
||||
_ = s.primaryDB.QueryRow(`
|
||||
SELECT count(*) FROM tickets WHERE completed_at >= $1 AND completed_at < $2
|
||||
`, start, end).Scan(&resolvedCount)
|
||||
|
||||
data.Velocity = append(data.Velocity, VelocityPoint{
|
||||
Week: weekLabel,
|
||||
Created: createdCount,
|
||||
Resolved: resolvedCount,
|
||||
})
|
||||
}
|
||||
|
||||
// 4. Assignee Workload
|
||||
uRows, err := s.primaryDB.Query(`
|
||||
SELECT u.username, u.name, u.role, u.role_display, u.avatar,
|
||||
COUNT(CASE WHEN t.status = 'open' AND t.archived = FALSE THEN 1 END) AS open_cnt,
|
||||
COUNT(CASE WHEN t.status = 'in_progress' AND t.archived = FALSE THEN 1 END) AS in_prog_cnt,
|
||||
COUNT(CASE WHEN t.status = 'completed' AND t.archived = FALSE THEN 1 END) AS comp_cnt,
|
||||
COALESCE(AVG(CASE WHEN t.status = 'completed' AND t.completed_at IS NOT NULL THEN EXTRACT(EPOCH FROM (t.completed_at - t.created_at)) / 3600 END), 0) AS avg_h
|
||||
FROM users u
|
||||
LEFT JOIN tickets t ON LOWER(t.assigned_to) = LOWER(u.username)
|
||||
WHERE u.active = TRUE
|
||||
GROUP BY u.username, u.name, u.role, u.role_display, u.avatar
|
||||
ORDER BY COUNT(CASE WHEN t.status IN ('open', 'in_progress') AND t.archived = FALSE THEN 1 END) DESC, u.name ASC
|
||||
`)
|
||||
if err == nil {
|
||||
defer uRows.Close()
|
||||
for uRows.Next() {
|
||||
var w AssigneeWorkload
|
||||
if err := uRows.Scan(&w.Username, &w.Name, &w.Role, &w.RoleDisplay, &w.Avatar, &w.Open, &w.InProgress, &w.Completed, &w.AvgHours); err == nil {
|
||||
w.AvgHours = float64(int(w.AvgHours*10)) / 10.0
|
||||
data.ByAssignee = append(data.ByAssignee, w)
|
||||
}
|
||||
}
|
||||
}
|
||||
if data.ByAssignee == nil {
|
||||
data.ByAssignee = []AssigneeWorkload{}
|
||||
}
|
||||
|
||||
// 5. Error Summary
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM errors WHERE archived = FALSE`).Scan(&data.ErrorSummary.TotalErrors)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM errors WHERE status = 'unresolved' AND archived = FALSE`).Scan(&data.ErrorSummary.UnresolvedErrors)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM errors WHERE status = 'resolved' AND archived = FALSE`).Scan(&data.ErrorSummary.ResolvedErrors)
|
||||
_ = s.primaryDB.QueryRow(`SELECT count(*) FROM errors WHERE LOWER(severity) = 'critical' AND archived = FALSE`).Scan(&data.ErrorSummary.CriticalErrors)
|
||||
|
||||
// Top Apps by Errors
|
||||
appRows, err := s.primaryDB.Query(`
|
||||
SELECT app_name, count(*) as c
|
||||
FROM errors
|
||||
WHERE archived = FALSE AND app_name != ''
|
||||
GROUP BY app_name
|
||||
ORDER BY c DESC
|
||||
LIMIT 5
|
||||
`)
|
||||
if err == nil {
|
||||
defer appRows.Close()
|
||||
for appRows.Next() {
|
||||
var st AppErrorStat
|
||||
if err := appRows.Scan(&st.App, &st.Count); err == nil {
|
||||
data.TopAppsByErrors = append(data.TopAppsByErrors, st)
|
||||
}
|
||||
}
|
||||
}
|
||||
if data.TopAppsByErrors == nil {
|
||||
data.TopAppsByErrors = []AppErrorStat{}
|
||||
}
|
||||
|
||||
// 6. Recent Activity
|
||||
actRows, err := s.primaryDB.Query(`
|
||||
SELECT r.id, r.ticket_id, COALESCE(t.title, ''), r.type, r.author_username, r.author_name, r.author_role, r.text, r.created_at
|
||||
FROM ticket_remarks r
|
||||
LEFT JOIN tickets t ON r.ticket_id = t.id
|
||||
ORDER BY r.created_at DESC
|
||||
LIMIT 15
|
||||
`)
|
||||
if err == nil {
|
||||
defer actRows.Close()
|
||||
for actRows.Next() {
|
||||
var act ActivityItem
|
||||
if err := actRows.Scan(&act.ID, &act.TicketID, &act.Title, &act.Type, &act.Author, &act.Name, &act.Role, &act.Text, &act.CreatedAt); err == nil {
|
||||
data.RecentActivity = append(data.RecentActivity, act)
|
||||
}
|
||||
}
|
||||
}
|
||||
if data.RecentActivity == nil {
|
||||
data.RecentActivity = []ActivityItem{}
|
||||
}
|
||||
|
||||
return data, nil
|
||||
}
|
||||
|
||||
// BulkAction applies updates to a slice of ticket IDs
|
||||
func (s *Store) BulkAction(ids []string, action, value string, actor *User) (map[string]any, error) {
|
||||
if len(ids) == 0 {
|
||||
return map[string]any{"updated": 0, "skipped": 0}, nil
|
||||
}
|
||||
|
||||
updated := 0
|
||||
skipped := 0
|
||||
now := time.Now()
|
||||
|
||||
for _, id := range ids {
|
||||
id = strings.TrimSpace(id)
|
||||
if id == "" {
|
||||
continue
|
||||
}
|
||||
|
||||
switch strings.ToLower(action) {
|
||||
case "archive":
|
||||
_, err := s.ArchiveTicket(id, actor)
|
||||
if err == nil {
|
||||
updated++
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
case "unarchive":
|
||||
_, err := s.UnarchiveTicket(id, actor)
|
||||
if err == nil {
|
||||
updated++
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
case "delete":
|
||||
err := s.DeleteTicket(id, actor)
|
||||
if err == nil {
|
||||
updated++
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
case "assign":
|
||||
if strings.TrimSpace(value) == "" {
|
||||
skipped++
|
||||
continue
|
||||
}
|
||||
targetUser, _ := s.GetUser(value)
|
||||
targetName := value
|
||||
targetRole := ""
|
||||
if targetUser != nil {
|
||||
targetName = targetUser.Name
|
||||
targetRole = targetUser.RoleDisplay
|
||||
}
|
||||
res, err := s.primaryDB.Exec(`
|
||||
UPDATE tickets SET assigned_to = $1, assigned_to_name = $2, assigned_to_role = $3, updated_at = $4
|
||||
WHERE id = $5
|
||||
`, value, targetName, targetRole, now, id)
|
||||
if err == nil {
|
||||
if n, _ := res.RowsAffected(); n > 0 {
|
||||
remID := uuid.New().String()
|
||||
_, _ = s.primaryDB.Exec(`
|
||||
INSERT INTO ticket_remarks (id, ticket_id, author_username, author_name, author_role, type, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, 'reassign', $6, $7)
|
||||
`, remID, id, actor.Username, actor.Name, actor.RoleDisplay, fmt.Sprintf("Bulk reassigned ticket to %s.", targetName), now)
|
||||
s.addNotification(value, id, "Ticket Reassigned", fmt.Sprintf("Ticket %s assigned to you", id), "assignment")
|
||||
updated++
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
case "priority":
|
||||
p := strings.ToLower(strings.TrimSpace(value))
|
||||
if p != "critical" && p != "high" && p != "medium" && p != "low" {
|
||||
skipped++
|
||||
continue
|
||||
}
|
||||
res, err := s.primaryDB.Exec(`UPDATE tickets SET priority = $1, updated_at = $2 WHERE id = $3`, p, now, id)
|
||||
if err == nil {
|
||||
if n, _ := res.RowsAffected(); n > 0 {
|
||||
remID := uuid.New().String()
|
||||
_, _ = s.primaryDB.Exec(`
|
||||
INSERT INTO ticket_remarks (id, ticket_id, author_username, author_name, author_role, type, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, 'priority_change', $6, $7)
|
||||
`, remID, id, actor.Username, actor.Name, actor.RoleDisplay, fmt.Sprintf("Priority changed to %s.", strings.ToUpper(p)), now)
|
||||
updated++
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
case "status":
|
||||
st := strings.ToLower(strings.TrimSpace(value))
|
||||
if st == "completed" {
|
||||
_, err := s.CompleteTicket(id, actor, "Marked as completed via bulk action")
|
||||
if err == nil {
|
||||
updated++
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
} else if st == "open" || st == "in_progress" {
|
||||
res, err := s.primaryDB.Exec(`UPDATE tickets SET status = $1, updated_at = $2 WHERE id = $3`, st, now, id)
|
||||
if err == nil {
|
||||
if n, _ := res.RowsAffected(); n > 0 {
|
||||
updated++
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
} else {
|
||||
skipped++
|
||||
}
|
||||
default:
|
||||
skipped++
|
||||
}
|
||||
}
|
||||
|
||||
return map[string]any{
|
||||
"updated": updated,
|
||||
"skipped": skipped,
|
||||
"action": action,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Tag Management
|
||||
func (s *Store) AddTicketTag(ticketID, tag string) error {
|
||||
tag = strings.ToLower(strings.TrimSpace(tag))
|
||||
if tag == "" {
|
||||
return errors.New("tag cannot be empty")
|
||||
}
|
||||
_, err := s.primaryDB.Exec(`
|
||||
INSERT INTO ticket_tags (ticket_id, tag) VALUES ($1, $2)
|
||||
ON CONFLICT (ticket_id, tag) DO NOTHING
|
||||
`, ticketID, tag)
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Store) RemoveTicketTag(ticketID, tag string) error {
|
||||
tag = strings.ToLower(strings.TrimSpace(tag))
|
||||
_, err := s.primaryDB.Exec(`DELETE FROM ticket_tags WHERE ticket_id = $1 AND tag = $2`, ticketID, tag)
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Store) ListAllTags() ([]map[string]any, error) {
|
||||
rows, err := s.primaryDB.Query(`
|
||||
SELECT tag, count(*) as count
|
||||
FROM ticket_tags
|
||||
GROUP BY tag
|
||||
ORDER BY count DESC, tag ASC
|
||||
`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var tags []map[string]any
|
||||
for rows.Next() {
|
||||
var tag string
|
||||
var count int
|
||||
if err := rows.Scan(&tag, &count); err == nil {
|
||||
tags = append(tags, map[string]any{"tag": tag, "count": count})
|
||||
}
|
||||
}
|
||||
if tags == nil {
|
||||
tags = []map[string]any{}
|
||||
}
|
||||
return tags, nil
|
||||
}
|
||||
|
||||
// Ticket Relations
|
||||
func (s *Store) LinkTickets(ticketA, ticketB, relType string, actor *User) error {
|
||||
if ticketA == ticketB {
|
||||
return errors.New("cannot link a ticket to itself")
|
||||
}
|
||||
if relType == "" {
|
||||
relType = "related"
|
||||
}
|
||||
|
||||
actorUser := ""
|
||||
if actor != nil {
|
||||
actorUser = actor.Username
|
||||
}
|
||||
|
||||
_, err := s.primaryDB.Exec(`
|
||||
INSERT INTO ticket_relations (ticket_a, ticket_b, relation_type, created_by, created_at)
|
||||
VALUES ($1, $2, $3, $4, NOW())
|
||||
ON CONFLICT (ticket_a, ticket_b) DO UPDATE SET relation_type = $3
|
||||
`, ticketA, ticketB, relType, actorUser)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Add remark to ticket A
|
||||
remID := uuid.New().String()
|
||||
_, _ = s.primaryDB.Exec(`
|
||||
INSERT INTO ticket_remarks (id, ticket_id, author_username, author_name, author_role, type, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, 'link', $6, NOW())
|
||||
`, remID, ticketA, actor.Username, actor.Name, actor.RoleDisplay, fmt.Sprintf("Linked related ticket %s.", ticketB))
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Store) UnlinkTickets(ticketA, ticketB string) error {
|
||||
_, err := s.primaryDB.Exec(`
|
||||
DELETE FROM ticket_relations
|
||||
WHERE (ticket_a = $1 AND ticket_b = $2) OR (ticket_a = $2 AND ticket_b = $1)
|
||||
`, ticketA, ticketB)
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Store) GetRelatedTickets(ticketID string) ([]string, error) {
|
||||
rows, err := s.primaryDB.Query(`
|
||||
SELECT ticket_b FROM ticket_relations WHERE ticket_a = $1
|
||||
UNION
|
||||
SELECT ticket_a FROM ticket_relations WHERE ticket_b = $1
|
||||
`, ticketID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var related []string
|
||||
for rows.Next() {
|
||||
var id string
|
||||
if err := rows.Scan(&id); err == nil {
|
||||
related = append(related, id)
|
||||
}
|
||||
}
|
||||
if related == nil {
|
||||
related = []string{}
|
||||
}
|
||||
return related, nil
|
||||
}
|
||||
|
||||
// Saved Filters
|
||||
func (s *Store) GetSavedFilters(userID string) ([]SavedFilter, error) {
|
||||
rows, err := s.primaryDB.Query(`
|
||||
SELECT id, user_id, name, filter_json, created_at
|
||||
FROM saved_filters
|
||||
WHERE user_id = $1
|
||||
ORDER BY created_at DESC
|
||||
`, userID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var filters []SavedFilter
|
||||
for rows.Next() {
|
||||
var f SavedFilter
|
||||
if err := rows.Scan(&f.ID, &f.UserID, &f.Name, &f.FilterJSON, &f.CreatedAt); err == nil {
|
||||
filters = append(filters, f)
|
||||
}
|
||||
}
|
||||
if filters == nil {
|
||||
filters = []SavedFilter{}
|
||||
}
|
||||
return filters, nil
|
||||
}
|
||||
|
||||
func (s *Store) SaveFilter(userID, name, filterJSON string) (*SavedFilter, error) {
|
||||
id := uuid.New().String()
|
||||
now := time.Now()
|
||||
_, err := s.primaryDB.Exec(`
|
||||
INSERT INTO saved_filters (id, user_id, name, filter_json, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
`, id, userID, name, filterJSON, now)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &SavedFilter{
|
||||
ID: id,
|
||||
UserID: userID,
|
||||
Name: name,
|
||||
FilterJSON: filterJSON,
|
||||
CreatedAt: now,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *Store) DeleteSavedFilter(filterID, userID string) error {
|
||||
_, err := s.primaryDB.Exec(`DELETE FROM saved_filters WHERE id = $1 AND user_id = $2`, filterID, userID)
|
||||
return err
|
||||
}
|
||||
|
||||
// API Tokens
|
||||
func generateSecureToken() (string, string, error) {
|
||||
bytes := make([]byte, 24)
|
||||
if _, err := rand.Read(bytes); err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
raw := "khr_" + hex.EncodeToString(bytes)
|
||||
sum := sha256.Sum256([]byte(raw))
|
||||
hash := hex.EncodeToString(sum[:])
|
||||
return raw, hash, nil
|
||||
}
|
||||
|
||||
func (s *Store) CreateAPIToken(userID, name, scopes string) (string, *APIToken, error) {
|
||||
raw, hash, err := generateSecureToken()
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
|
||||
id := uuid.New().String()
|
||||
now := time.Now()
|
||||
if scopes == "" {
|
||||
scopes = "errors:write"
|
||||
}
|
||||
|
||||
_, err = s.primaryDB.Exec(`
|
||||
INSERT INTO api_tokens (id, user_id, name, token_hash, scopes, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, $6)
|
||||
`, id, userID, name, hash, scopes, now)
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
|
||||
tok := &APIToken{
|
||||
ID: id,
|
||||
UserID: userID,
|
||||
Name: name,
|
||||
Scopes: scopes,
|
||||
CreatedAt: now,
|
||||
}
|
||||
return raw, tok, nil
|
||||
}
|
||||
|
||||
func (s *Store) ListAPITokens(userID string) ([]APIToken, error) {
|
||||
rows, err := s.primaryDB.Query(`
|
||||
SELECT id, user_id, name, scopes, last_used_at, revoked, created_at
|
||||
FROM api_tokens
|
||||
WHERE user_id = $1 AND revoked = FALSE
|
||||
ORDER BY created_at DESC
|
||||
`, userID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var tokens []APIToken
|
||||
for rows.Next() {
|
||||
var tok APIToken
|
||||
if err := rows.Scan(&tok.ID, &tok.UserID, &tok.Name, &tok.Scopes, &tok.LastUsedAt, &tok.Revoked, &tok.CreatedAt); err == nil {
|
||||
tokens = append(tokens, tok)
|
||||
}
|
||||
}
|
||||
if tokens == nil {
|
||||
tokens = []APIToken{}
|
||||
}
|
||||
return tokens, nil
|
||||
}
|
||||
|
||||
func (s *Store) RevokeAPIToken(tokenID, userID string) error {
|
||||
_, err := s.primaryDB.Exec(`UPDATE api_tokens SET revoked = TRUE WHERE id = $1 AND user_id = $2`, tokenID, userID)
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Store) ValidateAPIToken(rawToken string) (*User, error) {
|
||||
sum := sha256.Sum256([]byte(strings.TrimSpace(rawToken)))
|
||||
hash := hex.EncodeToString(sum[:])
|
||||
|
||||
var userID string
|
||||
err := s.primaryDB.QueryRow(`
|
||||
SELECT user_id FROM api_tokens
|
||||
WHERE token_hash = $1 AND revoked = FALSE
|
||||
`, hash).Scan(&userID)
|
||||
if err != nil {
|
||||
return nil, errors.New("invalid or revoked token")
|
||||
}
|
||||
|
||||
// Update last used timestamp
|
||||
_, _ = s.primaryDB.Exec(`UPDATE api_tokens SET last_used_at = NOW() WHERE token_hash = $1`, hash)
|
||||
|
||||
u, _ := s.GetUser(userID)
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// Admin User Management
|
||||
func (s *Store) ListAllUsersAdmin() ([]*User, error) {
|
||||
rows, err := s.primaryDB.Query(`
|
||||
SELECT id, username, name, role, role_display, avatar, avatar_type, profile_image, active, last_active_at, created_at, updated_at
|
||||
FROM users
|
||||
ORDER BY role = 'team_lead' DESC, name ASC
|
||||
`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var users []*User
|
||||
for rows.Next() {
|
||||
var u User
|
||||
if err := rows.Scan(&u.ID, &u.Username, &u.Name, &u.Role, &u.RoleDisplay, &u.Avatar, &u.AvatarType, &u.ProfileImage, &u.Active, &u.LastActiveAt, &u.CreatedAt, &u.UpdatedAt); err == nil {
|
||||
users = append(users, &u)
|
||||
}
|
||||
}
|
||||
return users, nil
|
||||
}
|
||||
|
||||
func (s *Store) UpdateUserRoleAdmin(targetUsername, newRole string) error {
|
||||
r := Role(newRole)
|
||||
if !r.IsValid() {
|
||||
return errors.New("invalid role")
|
||||
}
|
||||
|
||||
_, err := s.primaryDB.Exec(`
|
||||
UPDATE users SET role = $1, role_display = $2, updated_at = NOW()
|
||||
WHERE LOWER(username) = LOWER($3)
|
||||
`, string(r), r.DisplayName(), targetUsername)
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Store) SetUserActiveStatus(targetUsername string, active bool) error {
|
||||
now := time.Now()
|
||||
var deactAt *time.Time
|
||||
if !active {
|
||||
deactAt = &now
|
||||
}
|
||||
_, err := s.primaryDB.Exec(`
|
||||
UPDATE users SET active = $1, deactivated_at = $2, updated_at = $3
|
||||
WHERE LOWER(username) = LOWER($4)
|
||||
`, active, deactAt, now, targetUsername)
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Store) ResetUserPasswordAdmin(targetUsername, newPassword string) error {
|
||||
if len(newPassword) < 4 {
|
||||
return errors.New("password must be at least 4 characters")
|
||||
}
|
||||
hash := hashPassword(newPassword)
|
||||
_, err := s.primaryDB.Exec(`
|
||||
UPDATE users SET password_hash = $1, updated_at = NOW()
|
||||
WHERE LOWER(username) = LOWER($2)
|
||||
`, hash, targetUsername)
|
||||
return err
|
||||
}
|
||||
@@ -29,10 +29,19 @@ func (s *Server) writeJSON(w http.ResponseWriter, status int, data any) {
|
||||
}
|
||||
|
||||
func (s *Server) getActor(r *http.Request) *User {
|
||||
// 1. Check custom header (useful for client SPA / API calls)
|
||||
// 1. Check Bearer API Token
|
||||
authHdr := r.Header.Get("Authorization")
|
||||
if strings.HasPrefix(strings.ToLower(authHdr), "bearer ") {
|
||||
tok := strings.TrimSpace(authHdr[7:])
|
||||
if u, err := s.Store.ValidateAPIToken(tok); err == nil && u != nil {
|
||||
return u
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Check custom header (useful for client SPA / API calls)
|
||||
username := r.Header.Get("X-Khira-User")
|
||||
if username == "" {
|
||||
// 2. Check cookie
|
||||
// 3. Check cookie
|
||||
if cookie, err := r.Cookie("khira_session_user"); err == nil && cookie.Value != "" {
|
||||
username = cookie.Value
|
||||
}
|
||||
@@ -145,6 +154,47 @@ func (s *Server) RegisterRoutes(r chi.Router) {
|
||||
api.Post("/admin/db/sync", s.handleDBSync)
|
||||
api.Post("/admin/db/rollback", s.handleDBRollback)
|
||||
api.Get("/admin/db/status", s.handleDBStatus)
|
||||
|
||||
// Enterprise Features
|
||||
// Analytics
|
||||
api.Get("/analytics", s.handleAnalytics)
|
||||
|
||||
// Bulk Actions
|
||||
api.Post("/tickets/bulk", s.handleBulkActions)
|
||||
|
||||
// Tags
|
||||
api.Get("/tags", s.handleListTags)
|
||||
api.Post("/tickets/{id}/tags", s.handleAddTag)
|
||||
api.Delete("/tickets/{id}/tags/{tag}", s.handleRemoveTag)
|
||||
|
||||
// Relations / Ticket Linking
|
||||
api.Post("/tickets/{id}/relations", s.handleLinkTickets)
|
||||
api.Delete("/tickets/{id}/relations/{target}", s.handleUnlinkTickets)
|
||||
|
||||
// Saved Filters
|
||||
api.Get("/filters", s.handleListSavedFilters)
|
||||
api.Post("/filters", s.handleCreateSavedFilter)
|
||||
api.Delete("/filters/{id}", s.handleDeleteSavedFilter)
|
||||
|
||||
// API Tokens
|
||||
api.Get("/tokens", s.handleListAPITokens)
|
||||
api.Post("/tokens", s.handleCreateAPIToken)
|
||||
api.Delete("/tokens/{id}", s.handleRevokeAPIToken)
|
||||
|
||||
// Admin User Management
|
||||
api.Get("/admin/users", s.handleAdminListUsers)
|
||||
api.Patch("/admin/users/{username}/role", s.handleAdminUpdateRole)
|
||||
api.Patch("/admin/users/{username}/status", s.handleAdminUpdateStatus)
|
||||
api.Post("/admin/users/{username}/reset-password", s.handleAdminResetPassword)
|
||||
|
||||
// Export CSV
|
||||
api.Get("/tickets/export", s.handleExportTickets)
|
||||
api.Get("/errors/export", s.handleExportErrors)
|
||||
|
||||
// Notifications Single Item Ops
|
||||
api.Delete("/notifications/{id}", s.handleDeleteNotification)
|
||||
api.Delete("/notifications", s.handleClearNotifications)
|
||||
api.Post("/notifications/{id}/read", s.handleMarkNotificationReadSingle)
|
||||
})
|
||||
}
|
||||
|
||||
@@ -387,6 +437,9 @@ func (s *Server) handleCreateTicket(w http.ResponseWriter, r *http.Request) {
|
||||
AssigneeUsername string `json:"assignee_username"`
|
||||
DeveloperAccount string `json:"developer_account"`
|
||||
ImageURL string `json:"image_url"`
|
||||
DueDate string `json:"due_date"`
|
||||
SLAHours int `json:"sla_hours"`
|
||||
Tags []string `json:"tags"`
|
||||
Attachments []Attachment `json:"attachments"`
|
||||
Links []string `json:"links"`
|
||||
}
|
||||
@@ -502,10 +555,20 @@ func (s *Server) handleCreateTicket(w http.ResponseWriter, r *http.Request) {
|
||||
AssistanceRequired: assistance,
|
||||
AdditionalInfo: additionalInfo,
|
||||
AssignedTo: assignedTo,
|
||||
SLAHours: req.SLAHours,
|
||||
Tags: req.Tags,
|
||||
Links: req.Links,
|
||||
Attachments: atts,
|
||||
}
|
||||
|
||||
if req.DueDate != "" {
|
||||
if parsed, err := time.Parse(time.RFC3339, req.DueDate); err == nil {
|
||||
ticket.DueDate = &parsed
|
||||
} else if parsed, err := time.Parse("2006-01-02", req.DueDate); err == nil {
|
||||
ticket.DueDate = &parsed
|
||||
}
|
||||
}
|
||||
|
||||
created, err := s.Store.CreateTicket(ticket, actor)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
|
||||
@@ -0,0 +1,475 @@
|
||||
package khira
|
||||
|
||||
import (
|
||||
"encoding/csv"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
)
|
||||
|
||||
// Analytics
|
||||
func (s *Server) handleAnalytics(w http.ResponseWriter, r *http.Request) {
|
||||
data, err := s.Store.GetAnalyticsData()
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, data)
|
||||
}
|
||||
|
||||
// Bulk Actions
|
||||
func (s *Server) handleBulkActions(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
|
||||
var req struct {
|
||||
IDs []string `json:"ids"`
|
||||
Action string `json:"action"`
|
||||
Value string `json:"value"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Invalid request body"})
|
||||
return
|
||||
}
|
||||
|
||||
res, err := s.Store.BulkAction(req.IDs, req.Action, req.Value, actor)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, res)
|
||||
}
|
||||
|
||||
// Tags
|
||||
func (s *Server) handleListTags(w http.ResponseWriter, r *http.Request) {
|
||||
tags, err := s.Store.ListAllTags()
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]any{"tags": tags})
|
||||
}
|
||||
|
||||
func (s *Server) handleAddTag(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
ticketID := chi.URLParam(r, "id")
|
||||
var req struct {
|
||||
Tag string `json:"tag"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Tag == "" {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Tag is required"})
|
||||
return
|
||||
}
|
||||
|
||||
if err := s.Store.AddTicketTag(ticketID, req.Tag); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "tag": req.Tag})
|
||||
}
|
||||
|
||||
func (s *Server) handleRemoveTag(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
ticketID := chi.URLParam(r, "id")
|
||||
tag := chi.URLParam(r, "tag")
|
||||
|
||||
if err := s.Store.RemoveTicketTag(ticketID, tag); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "removed": tag})
|
||||
}
|
||||
|
||||
// Ticket Relations
|
||||
func (s *Server) handleLinkTickets(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
ticketID := chi.URLParam(r, "id")
|
||||
|
||||
var req struct {
|
||||
TargetID string `json:"target_id"`
|
||||
Type string `json:"type"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.TargetID == "" {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Target ticket ID is required"})
|
||||
return
|
||||
}
|
||||
|
||||
if err := s.Store.LinkTickets(ticketID, req.TargetID, req.Type, actor); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "linked": req.TargetID})
|
||||
}
|
||||
|
||||
func (s *Server) handleUnlinkTickets(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
ticketID := chi.URLParam(r, "id")
|
||||
targetID := chi.URLParam(r, "target")
|
||||
|
||||
if err := s.Store.UnlinkTickets(ticketID, targetID); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "unlinked": targetID})
|
||||
}
|
||||
|
||||
// Saved Filters
|
||||
func (s *Server) handleListSavedFilters(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
filters, err := s.Store.GetSavedFilters(actor.Username)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]any{"filters": filters})
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateSavedFilter(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
|
||||
var req struct {
|
||||
Name string `json:"name"`
|
||||
FilterJSON string `json:"filter_json"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Name == "" {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Filter name is required"})
|
||||
return
|
||||
}
|
||||
|
||||
sf, err := s.Store.SaveFilter(actor.Username, req.Name, req.FilterJSON)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusCreated, sf)
|
||||
}
|
||||
|
||||
func (s *Server) handleDeleteSavedFilter(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
filterID := chi.URLParam(r, "id")
|
||||
if err := s.Store.DeleteSavedFilter(filterID, actor.Username); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
// API Tokens
|
||||
func (s *Server) handleListAPITokens(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
tokens, err := s.Store.ListAPITokens(actor.Username)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]any{"tokens": tokens})
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateAPIToken(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
|
||||
var req struct {
|
||||
Name string `json:"name"`
|
||||
Scopes string `json:"scopes"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Name == "" {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Token name is required"})
|
||||
return
|
||||
}
|
||||
|
||||
raw, tok, err := s.Store.CreateAPIToken(actor.Username, req.Name, req.Scopes)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
s.writeJSON(w, http.StatusCreated, map[string]any{
|
||||
"token": raw,
|
||||
"meta": tok,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) handleRevokeAPIToken(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
tokenID := chi.URLParam(r, "id")
|
||||
if err := s.Store.RevokeAPIToken(tokenID, actor.Username); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
// Admin Management
|
||||
func (s *Server) handleAdminListUsers(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if !s.isAdmin(actor) {
|
||||
s.writeJSON(w, http.StatusForbidden, map[string]string{"error": "Admin access required"})
|
||||
return
|
||||
}
|
||||
|
||||
users, err := s.Store.ListAllUsersAdmin()
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]any{"users": users})
|
||||
}
|
||||
|
||||
func (s *Server) handleAdminUpdateRole(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if !s.isAdmin(actor) {
|
||||
s.writeJSON(w, http.StatusForbidden, map[string]string{"error": "Admin access required"})
|
||||
return
|
||||
}
|
||||
|
||||
target := chi.URLParam(r, "username")
|
||||
var req struct {
|
||||
Role string `json:"role"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Role == "" {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Role is required"})
|
||||
return
|
||||
}
|
||||
|
||||
if err := s.Store.UpdateUserRoleAdmin(target, req.Role); err != nil {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "message": "User role updated"})
|
||||
}
|
||||
|
||||
func (s *Server) handleAdminUpdateStatus(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if !s.isAdmin(actor) {
|
||||
s.writeJSON(w, http.StatusForbidden, map[string]string{"error": "Admin access required"})
|
||||
return
|
||||
}
|
||||
|
||||
target := chi.URLParam(r, "username")
|
||||
if strings.EqualFold(target, actor.Username) {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Cannot deactivate your own account"})
|
||||
return
|
||||
}
|
||||
|
||||
var req struct {
|
||||
Active bool `json:"active"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Active flag is required"})
|
||||
return
|
||||
}
|
||||
|
||||
if err := s.Store.SetUserActiveStatus(target, req.Active); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "message": "User active status updated"})
|
||||
}
|
||||
|
||||
func (s *Server) handleAdminResetPassword(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if !s.isAdmin(actor) {
|
||||
s.writeJSON(w, http.StatusForbidden, map[string]string{"error": "Admin access required"})
|
||||
return
|
||||
}
|
||||
|
||||
target := chi.URLParam(r, "username")
|
||||
var req struct {
|
||||
NewPassword string `json:"new_password"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || len(req.NewPassword) < 4 {
|
||||
s.writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Password must be at least 4 characters"})
|
||||
return
|
||||
}
|
||||
|
||||
if err := s.Store.ResetUserPasswordAdmin(target, req.NewPassword); err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "message": "Password reset successfully"})
|
||||
}
|
||||
|
||||
// Export (CSV)
|
||||
func (s *Server) handleExportTickets(w http.ResponseWriter, r *http.Request) {
|
||||
status := r.URL.Query().Get("status")
|
||||
priority := r.URL.Query().Get("priority")
|
||||
assignee := r.URL.Query().Get("assignee")
|
||||
reporter := r.URL.Query().Get("reporter")
|
||||
q := r.URL.Query().Get("q")
|
||||
|
||||
tickets := s.Store.ListTickets(status, priority, "", assignee, reporter, q, "")
|
||||
|
||||
w.Header().Set("Content-Type", "text/csv; charset=utf-8")
|
||||
w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=khira_tickets_%s.csv", time.Now().Format("2006-01-02_1504")))
|
||||
|
||||
writer := csv.NewWriter(w)
|
||||
defer writer.Flush()
|
||||
|
||||
// Header row
|
||||
_ = writer.Write([]string{
|
||||
"Ticket ID", "Type", "Title", "App Name", "Version", "Feature",
|
||||
"Priority", "Status", "Created By", "Assigned To", "Created At",
|
||||
"Due Date", "SLA Breached", "Tags", "Archived",
|
||||
})
|
||||
|
||||
for _, t := range tickets {
|
||||
dueDateStr := ""
|
||||
if t.DueDate != nil {
|
||||
dueDateStr = t.DueDate.Format("2006-01-02 15:04")
|
||||
}
|
||||
tagsStr := strings.Join(t.Tags, ", ")
|
||||
_ = writer.Write([]string{
|
||||
t.ID,
|
||||
t.TicketType,
|
||||
t.Title,
|
||||
t.AppName,
|
||||
t.Version,
|
||||
t.FeatureName,
|
||||
t.Priority,
|
||||
t.Status,
|
||||
t.CreatedByName,
|
||||
t.AssignedToName,
|
||||
t.CreatedAt.Format("2006-01-02 15:04"),
|
||||
dueDateStr,
|
||||
strconv.FormatBool(t.SLABreached),
|
||||
tagsStr,
|
||||
strconv.FormatBool(t.Archived),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Server) handleExportErrors(w http.ResponseWriter, r *http.Request) {
|
||||
status := r.URL.Query().Get("status")
|
||||
severity := r.URL.Query().Get("severity")
|
||||
app := r.URL.Query().Get("app")
|
||||
q := r.URL.Query().Get("q")
|
||||
|
||||
errorsList := s.Store.ListErrors(status, severity, app, q)
|
||||
|
||||
w.Header().Set("Content-Type", "text/csv; charset=utf-8")
|
||||
w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=khira_errors_%s.csv", time.Now().Format("2006-01-02_1504")))
|
||||
|
||||
writer := csv.NewWriter(w)
|
||||
defer writer.Flush()
|
||||
|
||||
// Header row
|
||||
_ = writer.Write([]string{
|
||||
"Error ID", "App Name", "Version", "Environment", "Service", "Endpoint",
|
||||
"Exception Type", "Message", "Severity", "Status", "Occurrences",
|
||||
"First Seen", "Last Seen", "Escalated Ticket", "Archived",
|
||||
})
|
||||
|
||||
for _, e := range errorsList {
|
||||
_ = writer.Write([]string{
|
||||
e.ID,
|
||||
e.AppName,
|
||||
e.Version,
|
||||
e.Environment,
|
||||
e.Service,
|
||||
e.Endpoint,
|
||||
e.ExceptionType,
|
||||
e.Message,
|
||||
e.Severity,
|
||||
e.Status,
|
||||
strconv.Itoa(e.Occurrences),
|
||||
e.FirstSeen.Format("2006-01-02 15:04"),
|
||||
e.LastSeen.Format("2006-01-02 15:04"),
|
||||
e.LinkedTicketID,
|
||||
strconv.FormatBool(e.Archived),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Notifications single item operations
|
||||
func (s *Server) handleDeleteNotification(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
id := chi.URLParam(r, "id")
|
||||
_, err := s.Store.primaryDB.Exec(`DELETE FROM notifications WHERE id = $1 AND user_id = $2`, id, actor.Username)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (s *Server) handleClearNotifications(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
_, err := s.Store.primaryDB.Exec(`DELETE FROM notifications WHERE user_id = $1`, actor.Username)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (s *Server) handleMarkNotificationReadSingle(w http.ResponseWriter, r *http.Request) {
|
||||
actor := s.getActor(r)
|
||||
if actor == nil {
|
||||
s.writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "Authentication required"})
|
||||
return
|
||||
}
|
||||
id := chi.URLParam(r, "id")
|
||||
_, err := s.Store.primaryDB.Exec(`UPDATE notifications SET read = TRUE WHERE id = $1 AND user_id = $2`, id, actor.Username)
|
||||
if err != nil {
|
||||
s.writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
s.writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
+108
-12
@@ -44,17 +44,20 @@ func (r Role) IsValid() bool {
|
||||
}
|
||||
|
||||
type User struct {
|
||||
ID string `json:"id"`
|
||||
Username string `json:"username"`
|
||||
Name string `json:"name"`
|
||||
PasswordHash string `json:"password_hash,omitempty"`
|
||||
Role string `json:"role"`
|
||||
RoleDisplay string `json:"role_display"`
|
||||
Avatar string `json:"avatar"`
|
||||
AvatarType string `json:"avatar_type"`
|
||||
ProfileImage string `json:"profile_image"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
ID string `json:"id"`
|
||||
Username string `json:"username"`
|
||||
Name string `json:"name"`
|
||||
PasswordHash string `json:"password_hash,omitempty"`
|
||||
Role string `json:"role"`
|
||||
RoleDisplay string `json:"role_display"`
|
||||
Avatar string `json:"avatar"`
|
||||
AvatarType string `json:"avatar_type"`
|
||||
ProfileImage string `json:"profile_image"`
|
||||
Active bool `json:"active"`
|
||||
LastActiveAt *time.Time `json:"last_active_at,omitempty"`
|
||||
DeactivatedAt *time.Time `json:"deactivated_at,omitempty"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
}
|
||||
|
||||
func (u *User) Public() *User {
|
||||
@@ -138,6 +141,11 @@ type Ticket struct {
|
||||
Links []string `json:"links,omitempty"`
|
||||
LinkedErrorID string `json:"linked_error_id,omitempty"`
|
||||
Archived bool `json:"archived"`
|
||||
DueDate *time.Time `json:"due_date,omitempty"`
|
||||
SLAHours int `json:"sla_hours"`
|
||||
SLABreached bool `json:"sla_breached"`
|
||||
Tags []string `json:"tags,omitempty"`
|
||||
RelatedTicketIDs []string `json:"related_ticket_ids,omitempty"`
|
||||
Remarks []Remark `json:"remarks"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
@@ -194,7 +202,95 @@ type Notification struct {
|
||||
TicketID string `json:"ticket_id"`
|
||||
Title string `json:"title"`
|
||||
Message string `json:"message"`
|
||||
Type string `json:"type"` // assignment, status_change, hold, complete, remark
|
||||
Type string `json:"type"` // assignment, status_change, hold, complete, remark, mention, sla_breach
|
||||
Read bool `json:"read"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
type SavedFilter struct {
|
||||
ID string `json:"id"`
|
||||
UserID string `json:"user_id"`
|
||||
Name string `json:"name"`
|
||||
FilterJSON string `json:"filter_json"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
type APIToken struct {
|
||||
ID string `json:"id"`
|
||||
UserID string `json:"user_id"`
|
||||
Name string `json:"name"`
|
||||
TokenHash string `json:"-"`
|
||||
Scopes string `json:"scopes"`
|
||||
LastUsedAt *time.Time `json:"last_used_at,omitempty"`
|
||||
Revoked bool `json:"revoked"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
type TicketRelation struct {
|
||||
ID int `json:"id"`
|
||||
TicketA string `json:"ticket_a"`
|
||||
TicketB string `json:"ticket_b"`
|
||||
RelationType string `json:"relation_type"`
|
||||
CreatedBy string `json:"created_by"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
type AnalyticsData struct {
|
||||
Summary struct {
|
||||
TotalTickets int `json:"total_tickets"`
|
||||
OpenTickets int `json:"open_tickets"`
|
||||
InProgressTickets int `json:"in_progress_tickets"`
|
||||
OnHoldTickets int `json:"on_hold_tickets"`
|
||||
CompletedTickets int `json:"completed_tickets"`
|
||||
ArchivedTickets int `json:"archived_tickets"`
|
||||
SLABreachedTickets int `json:"sla_breached_tickets"`
|
||||
AvgResolutionHours float64 `json:"avg_resolution_hours"`
|
||||
} `json:"summary"`
|
||||
Velocity []VelocityPoint `json:"velocity"`
|
||||
ByPriority map[string]int `json:"by_priority"`
|
||||
ByAssignee []AssigneeWorkload `json:"by_assignee"`
|
||||
ErrorSummary struct {
|
||||
TotalErrors int `json:"total_errors"`
|
||||
UnresolvedErrors int `json:"unresolved_errors"`
|
||||
ResolvedErrors int `json:"resolved_errors"`
|
||||
CriticalErrors int `json:"critical_errors"`
|
||||
} `json:"error_summary"`
|
||||
TopAppsByErrors []AppErrorStat `json:"top_apps_by_errors"`
|
||||
RecentActivity []ActivityItem `json:"recent_activity"`
|
||||
}
|
||||
|
||||
type VelocityPoint struct {
|
||||
Week string `json:"week"`
|
||||
Created int `json:"created"`
|
||||
Resolved int `json:"resolved"`
|
||||
}
|
||||
|
||||
type AssigneeWorkload struct {
|
||||
Username string `json:"username"`
|
||||
Name string `json:"name"`
|
||||
Role string `json:"role"`
|
||||
RoleDisplay string `json:"role_display"`
|
||||
Avatar string `json:"avatar"`
|
||||
Open int `json:"open"`
|
||||
InProgress int `json:"in_progress"`
|
||||
Completed int `json:"completed"`
|
||||
AvgHours float64 `json:"avg_hours"`
|
||||
}
|
||||
|
||||
type AppErrorStat struct {
|
||||
App string `json:"app"`
|
||||
Count int `json:"count"`
|
||||
}
|
||||
|
||||
type ActivityItem struct {
|
||||
ID string `json:"id"`
|
||||
TicketID string `json:"ticket_id"`
|
||||
Title string `json:"title"`
|
||||
Type string `json:"type"`
|
||||
Author string `json:"author"`
|
||||
Name string `json:"name"`
|
||||
Role string `json:"role"`
|
||||
Text string `json:"text"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
|
||||
+64
-7
@@ -78,6 +78,9 @@ func NewStore(dataDir string) (*Store, error) {
|
||||
}
|
||||
}
|
||||
|
||||
// Start background SLA monitor
|
||||
s.StartSLAMonitor()
|
||||
|
||||
return s, nil
|
||||
}
|
||||
|
||||
@@ -317,6 +320,14 @@ func (s *Store) CreateTicket(t *Ticket, actor *User) (*Ticket, error) {
|
||||
t.AssignedToRole = role
|
||||
}
|
||||
|
||||
if t.SLAHours <= 0 {
|
||||
t.SLAHours = calculateDefaultSLA(t.Priority)
|
||||
}
|
||||
if t.DueDate == nil {
|
||||
d := t.CreatedAt.Add(time.Duration(t.SLAHours) * time.Hour)
|
||||
t.DueDate = &d
|
||||
}
|
||||
|
||||
tx, err := s.primaryDB.Begin()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -327,15 +338,23 @@ func (s *Store) CreateTicket(t *Ticket, actor *User) (*Ticket, error) {
|
||||
INSERT INTO tickets (
|
||||
id, ticket_type, title, general_category, department, app_name, version, feature_name, api_key, issue_type,
|
||||
priority, status, description, assistance_required, additional_info, created_by, created_by_name, created_by_role,
|
||||
assigned_to, assigned_to_name, assigned_to_role, linked_error_id, created_at, updated_at
|
||||
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24)
|
||||
assigned_to, assigned_to_name, assigned_to_role, linked_error_id, created_at, updated_at, due_date, sla_hours, sla_breached
|
||||
) VALUES ($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)
|
||||
`, t.ID, t.TicketType, t.Title, t.GeneralCategory, t.Department, t.AppName, t.Version, t.FeatureName, t.APIKey, t.IssueType,
|
||||
t.Priority, t.Status, t.Description, t.AssistanceRequired, t.AdditionalInfo, t.CreatedBy, t.CreatedByName, t.CreatedByRole,
|
||||
t.AssignedTo, t.AssignedToName, t.AssignedToRole, t.LinkedErrorID, t.CreatedAt, t.UpdatedAt)
|
||||
t.AssignedTo, t.AssignedToName, t.AssignedToRole, t.LinkedErrorID, t.CreatedAt, t.UpdatedAt, t.DueDate, t.SLAHours, t.SLABreached)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to insert ticket: %w", err)
|
||||
}
|
||||
|
||||
// Insert tags if present
|
||||
for _, tg := range t.Tags {
|
||||
tg = strings.ToLower(strings.TrimSpace(tg))
|
||||
if tg != "" {
|
||||
_, _ = tx.Exec(`INSERT INTO ticket_tags (ticket_id, tag) VALUES ($1, $2) ON CONFLICT DO NOTHING`, t.ID, tg)
|
||||
}
|
||||
}
|
||||
|
||||
// Add creation remark
|
||||
createRemarkText := fmt.Sprintf("Created ticket with priority %s.", strings.ToUpper(t.Priority))
|
||||
if t.AssignedToName != "" {
|
||||
@@ -398,13 +417,13 @@ func (s *Store) GetTicket(id string) (*Ticket, error) {
|
||||
SELECT id, ticket_type, title, general_category, department, app_name, version, feature_name, api_key, issue_type,
|
||||
priority, status, description, assistance_required, additional_info, created_by, created_by_name, created_by_role,
|
||||
assigned_to, assigned_to_name, assigned_to_role, hold_reason, held_by, held_at, completion_remarks, completed_by,
|
||||
completed_at, linked_error_id, archived, created_at, updated_at
|
||||
completed_at, linked_error_id, archived, created_at, updated_at, due_date, sla_hours, sla_breached
|
||||
FROM tickets WHERE id = $1
|
||||
`, id).Scan(
|
||||
&t.ID, &t.TicketType, &t.Title, &t.GeneralCategory, &t.Department, &t.AppName, &t.Version, &t.FeatureName, &t.APIKey, &t.IssueType,
|
||||
&t.Priority, &t.Status, &t.Description, &t.AssistanceRequired, &t.AdditionalInfo, &t.CreatedBy, &t.CreatedByName, &t.CreatedByRole,
|
||||
&t.AssignedTo, &t.AssignedToName, &t.AssignedToRole, &t.HoldReason, &t.HeldBy, &t.HeldAt, &t.CompletionRemarks, &t.CompletedBy,
|
||||
&t.CompletedAt, &t.LinkedErrorID, &t.Archived, &t.CreatedAt, &t.UpdatedAt,
|
||||
&t.CompletedAt, &t.LinkedErrorID, &t.Archived, &t.CreatedAt, &t.UpdatedAt, &t.DueDate, &t.SLAHours, &t.SLABreached,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, errors.New("ticket not found")
|
||||
@@ -461,6 +480,27 @@ func (s *Store) GetTicket(id string) (*Ticket, error) {
|
||||
t.Links = []string{}
|
||||
}
|
||||
|
||||
// Tags
|
||||
tagRows, err := s.primaryDB.Query(`SELECT tag FROM ticket_tags WHERE ticket_id = $1 ORDER BY tag ASC`, id)
|
||||
if err == nil {
|
||||
defer tagRows.Close()
|
||||
for tagRows.Next() {
|
||||
var tg string
|
||||
if err := tagRows.Scan(&tg); err == nil {
|
||||
t.Tags = append(t.Tags, tg)
|
||||
}
|
||||
}
|
||||
}
|
||||
if t.Tags == nil {
|
||||
t.Tags = []string{}
|
||||
}
|
||||
|
||||
// Relations
|
||||
t.RelatedTicketIDs, _ = s.GetRelatedTickets(id)
|
||||
if t.RelatedTicketIDs == nil {
|
||||
t.RelatedTicketIDs = []string{}
|
||||
}
|
||||
|
||||
return &t, nil
|
||||
}
|
||||
|
||||
@@ -703,7 +743,7 @@ func (s *Store) ListTickets(status, priority, app, assignee, reporter, query, ti
|
||||
SELECT id, ticket_type, title, general_category, department, app_name, version, feature_name, api_key, issue_type,
|
||||
priority, status, description, assistance_required, additional_info, created_by, created_by_name, created_by_role,
|
||||
assigned_to, assigned_to_name, assigned_to_role, hold_reason, held_by, held_at, completion_remarks, completed_by,
|
||||
completed_at, linked_error_id, archived, created_at, updated_at
|
||||
completed_at, linked_error_id, archived, created_at, updated_at, due_date, sla_hours, sla_breached
|
||||
FROM tickets
|
||||
%s
|
||||
ORDER BY created_at DESC
|
||||
@@ -722,11 +762,12 @@ func (s *Store) ListTickets(status, priority, app, assignee, reporter, query, ti
|
||||
&t.ID, &t.TicketType, &t.Title, &t.GeneralCategory, &t.Department, &t.AppName, &t.Version, &t.FeatureName, &t.APIKey, &t.IssueType,
|
||||
&t.Priority, &t.Status, &t.Description, &t.AssistanceRequired, &t.AdditionalInfo, &t.CreatedBy, &t.CreatedByName, &t.CreatedByRole,
|
||||
&t.AssignedTo, &t.AssignedToName, &t.AssignedToRole, &t.HoldReason, &t.HeldBy, &t.HeldAt, &t.CompletionRemarks, &t.CompletedBy,
|
||||
&t.CompletedAt, &t.LinkedErrorID, &t.Archived, &t.CreatedAt, &t.UpdatedAt,
|
||||
&t.CompletedAt, &t.LinkedErrorID, &t.Archived, &t.CreatedAt, &t.UpdatedAt, &t.DueDate, &t.SLAHours, &t.SLABreached,
|
||||
); err == nil {
|
||||
t.Remarks = []Remark{}
|
||||
t.Attachments = []Attachment{}
|
||||
t.Links = []string{}
|
||||
t.Tags = []string{}
|
||||
list = append(list, &t)
|
||||
}
|
||||
}
|
||||
@@ -756,6 +797,22 @@ func (s *Store) ListTickets(status, priority, app, assignee, reporter, query, ti
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fetch tags for listed tickets
|
||||
tagRows, err := s.primaryDB.Query(fmt.Sprintf(`
|
||||
SELECT ticket_id, tag FROM ticket_tags WHERE ticket_id IN (%s)
|
||||
`, inClause))
|
||||
if err == nil {
|
||||
defer tagRows.Close()
|
||||
for tagRows.Next() {
|
||||
var tid, tg string
|
||||
if err := tagRows.Scan(&tid, &tg); err == nil {
|
||||
if t, exists := tIdxMap[tid]; exists {
|
||||
t.Tags = append(t.Tags, tg)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return list
|
||||
|
||||
Reference in New Issue
Block a user