Files
Unified_Dashboard_Suite_Go/internal/khira/enterprise.go
T

686 lines
19 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
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
}