923 lines
28 KiB
Go
923 lines
28 KiB
Go
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
|
|
// with strict corporate privacy scoping. Non-admins receive only their own scoped metrics.
|
|
func (s *Store) GetAnalyticsData(targetUser string, isOrgView bool, actor *User) (*AnalyticsData, error) {
|
|
if actor == nil {
|
|
return nil, errors.New("unauthorized: authentication required")
|
|
}
|
|
|
|
isAdmin := s.IsAdmin(actor)
|
|
if !isAdmin {
|
|
// Strictly enforce corporate privacy: non-admins cannot request org view or other users
|
|
isOrgView = false
|
|
targetUser = actor.Username
|
|
}
|
|
|
|
data := &AnalyticsData{
|
|
IsAdmin: isAdmin,
|
|
ByPriority: make(map[string]int),
|
|
}
|
|
|
|
if isOrgView {
|
|
data.Scope = "organization"
|
|
} else {
|
|
data.Scope = "personal"
|
|
data.TargetUser = targetUser
|
|
_ = s.primaryDB.QueryRow("SELECT name FROM users WHERE LOWER(username) = LOWER($1)", targetUser).Scan(&data.TargetName)
|
|
if data.TargetName == "" {
|
|
data.TargetName = targetUser
|
|
}
|
|
}
|
|
|
|
// For admins, populate the user list so they can easily switch to any team member's audit view
|
|
if isAdmin {
|
|
uRows, err := s.primaryDB.Query(`
|
|
SELECT username, name, role, role_display, avatar
|
|
FROM users
|
|
WHERE active = TRUE
|
|
ORDER BY name ASC
|
|
`)
|
|
if err == nil {
|
|
defer uRows.Close()
|
|
for uRows.Next() {
|
|
var opt AnalyticsUserOption
|
|
if err := uRows.Scan(&opt.Username, &opt.Name, &opt.Role, &opt.RoleDisplay, &opt.Avatar); err == nil {
|
|
data.AvailableUsers = append(data.AvailableUsers, opt)
|
|
}
|
|
}
|
|
}
|
|
if data.AvailableUsers == nil {
|
|
data.AvailableUsers = []AnalyticsUserOption{}
|
|
}
|
|
}
|
|
|
|
// 1. Summary Counts
|
|
if isOrgView {
|
|
_ = 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)
|
|
|
|
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
|
|
}
|
|
} else {
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets
|
|
WHERE archived = FALSE AND (LOWER(assigned_to) = LOWER($1) OR LOWER(created_by) = LOWER($1))
|
|
`, targetUser).Scan(&data.Summary.TotalTickets)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets
|
|
WHERE status = 'open' AND archived = FALSE AND LOWER(assigned_to) = LOWER($1)
|
|
`, targetUser).Scan(&data.Summary.OpenTickets)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets
|
|
WHERE status = 'in_progress' AND archived = FALSE AND LOWER(assigned_to) = LOWER($1)
|
|
`, targetUser).Scan(&data.Summary.InProgressTickets)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets
|
|
WHERE status = 'on_hold' AND archived = FALSE AND LOWER(assigned_to) = LOWER($1)
|
|
`, targetUser).Scan(&data.Summary.OnHoldTickets)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets
|
|
WHERE status = 'completed' AND archived = FALSE
|
|
AND (LOWER(assigned_to) = LOWER($1) OR LOWER(completed_by) = LOWER($1) OR LOWER(completed_by) = LOWER($2))
|
|
`, targetUser, data.TargetName).Scan(&data.Summary.CompletedTickets)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets
|
|
WHERE archived = TRUE AND (LOWER(assigned_to) = LOWER($1) OR LOWER(created_by) = LOWER($1))
|
|
`, targetUser).Scan(&data.Summary.ArchivedTickets)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets
|
|
WHERE sla_breached = TRUE AND archived = FALSE AND LOWER(assigned_to) = LOWER($1)
|
|
`, targetUser).Scan(&data.Summary.SLABreachedTickets)
|
|
|
|
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
|
|
AND (LOWER(assigned_to) = LOWER($1) OR LOWER(completed_by) = LOWER($1) OR LOWER(completed_by) = LOWER($2))
|
|
`, targetUser, data.TargetName).Scan(&avgSeconds)
|
|
if avgSeconds.Valid && avgSeconds.Float64 > 0 {
|
|
data.Summary.AvgResolutionHours = float64(int(avgSeconds.Float64/360.0)) / 10.0
|
|
}
|
|
}
|
|
|
|
// 2. Priority Breakdown
|
|
if isOrgView {
|
|
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
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
pRows, err := s.primaryDB.Query(`
|
|
SELECT LOWER(priority), count(*)
|
|
FROM tickets
|
|
WHERE archived = FALSE AND (LOWER(assigned_to) = LOWER($1) OR LOWER(created_by) = LOWER($1))
|
|
GROUP BY LOWER(priority)
|
|
`, targetUser)
|
|
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
|
|
if isOrgView {
|
|
_ = 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)
|
|
} else {
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets WHERE created_at >= $1 AND created_at < $2
|
|
AND (LOWER(created_by) = LOWER($3) OR LOWER(assigned_to) = LOWER($3))
|
|
`, start, end, targetUser).Scan(&createdCount)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM tickets WHERE completed_at >= $1 AND completed_at < $2
|
|
AND (LOWER(assigned_to) = LOWER($3) OR LOWER(completed_by) = LOWER($3) OR LOWER(completed_by) = LOWER($4))
|
|
`, start, end, targetUser, data.TargetName).Scan(&resolvedCount)
|
|
}
|
|
|
|
data.Velocity = append(data.Velocity, VelocityPoint{
|
|
Week: weekLabel,
|
|
Created: createdCount,
|
|
Resolved: resolvedCount,
|
|
})
|
|
}
|
|
|
|
// 4. Assignee Workload
|
|
if isOrgView {
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Personal view: ONLY this target user's workload is visible!
|
|
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 LOWER(u.username) = LOWER($1)
|
|
GROUP BY u.username, u.name, u.role, u.role_display, u.avatar
|
|
`, targetUser)
|
|
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
|
|
if isOrgView {
|
|
_ = 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)
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM errors e
|
|
INNER JOIN tickets t ON e.linked_ticket_id = t.id
|
|
WHERE e.archived = FALSE AND (LOWER(t.assigned_to) = LOWER($1) OR LOWER(t.created_by) = LOWER($1))
|
|
`, targetUser).Scan(&data.ErrorSummary.TotalErrors)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM errors e
|
|
INNER JOIN tickets t ON e.linked_ticket_id = t.id
|
|
WHERE e.status = 'unresolved' AND e.archived = FALSE AND (LOWER(t.assigned_to) = LOWER($1) OR LOWER(t.created_by) = LOWER($1))
|
|
`, targetUser).Scan(&data.ErrorSummary.UnresolvedErrors)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM errors e
|
|
INNER JOIN tickets t ON e.linked_ticket_id = t.id
|
|
WHERE e.status = 'resolved' AND e.archived = FALSE AND (LOWER(t.assigned_to) = LOWER($1) OR LOWER(t.created_by) = LOWER($1))
|
|
`, targetUser).Scan(&data.ErrorSummary.ResolvedErrors)
|
|
|
|
_ = s.primaryDB.QueryRow(`
|
|
SELECT count(*) FROM errors e
|
|
INNER JOIN tickets t ON e.linked_ticket_id = t.id
|
|
WHERE LOWER(e.severity) = 'critical' AND e.archived = FALSE AND (LOWER(t.assigned_to) = LOWER($1) OR LOWER(t.created_by) = LOWER($1))
|
|
`, targetUser).Scan(&data.ErrorSummary.CriticalErrors)
|
|
|
|
appRows, err := s.primaryDB.Query(`
|
|
SELECT e.app_name, count(*) as c
|
|
FROM errors e
|
|
INNER JOIN tickets t ON e.linked_ticket_id = t.id
|
|
WHERE e.archived = FALSE AND e.app_name != '' AND (LOWER(t.assigned_to) = LOWER($1) OR LOWER(t.created_by) = LOWER($1))
|
|
GROUP BY e.app_name
|
|
ORDER BY c DESC
|
|
LIMIT 5
|
|
`, targetUser)
|
|
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
|
|
if isOrgView {
|
|
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)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
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
|
|
WHERE LOWER(r.author_username) = LOWER($1)
|
|
OR LOWER(t.assigned_to) = LOWER($1)
|
|
OR LOWER(t.created_by) = LOWER($1)
|
|
ORDER BY r.created_at DESC
|
|
LIMIT 15
|
|
`, targetUser)
|
|
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++
|
|
}
|
|
}
|
|
|
|
if s.Broker != nil {
|
|
actorName := ""
|
|
if actor != nil {
|
|
actorName = actor.Username
|
|
}
|
|
s.Broker.Broadcast("tickets_bulk_updated", "", "", actorName, action, map[string]any{"updated": updated})
|
|
}
|
|
|
|
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)
|
|
if err == nil && s.Broker != nil {
|
|
s.Broker.Broadcast("ticket_tags_updated", ticketID, "", "", "tag_add", map[string]string{"tag": 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)
|
|
if err == nil && s.Broker != nil {
|
|
s.Broker.Broadcast("ticket_tags_updated", ticketID, "", "", "tag_remove", map[string]string{"tag": 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))
|
|
|
|
if s.Broker != nil {
|
|
s.Broker.Broadcast("ticket_relations_updated", ticketA, "", actorUser, "link", map[string]string{"target": 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)
|
|
if err == nil && s.Broker != nil {
|
|
s.Broker.Broadcast("ticket_relations_updated", ticketA, "", "", "unlink", map[string]string{"target": 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
|
|
}
|