feat(khira): enterprise suite overhaul with analytics dashboard, bulk actions, command palette, SLA monitoring, and zero-FOUT vector icons

This commit is contained in:
2026-10-27 17:17:40 +05:30
parent 9376e74846
commit dc11be2ffa
9 changed files with 3227 additions and 641 deletions
+50
View File
@@ -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);
+685
View File
@@ -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
}
+65 -2
View File
@@ -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()})
+475
View File
@@ -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
View File
@@ -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
View File
@@ -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