Files
Unified_Dashboard_Suite_Go/internal/khira/db.go
T

762 lines
27 KiB
Go
Raw Normal View History

package khira
import (
"crypto/sha256"
"database/sql"
"errors"
"fmt"
"log/slog"
"time"
"github.com/google/uuid"
_ "github.com/lib/pq"
)
const ddlSchema = `
CREATE TABLE IF NOT EXISTS users (
id VARCHAR(64) PRIMARY KEY,
username VARCHAR(64) UNIQUE NOT NULL,
name VARCHAR(128) NOT NULL,
password_hash VARCHAR(128) NOT NULL,
role VARCHAR(64) NOT NULL,
role_display VARCHAR(64) NOT NULL,
avatar VARCHAR(64) NOT NULL DEFAULT '👤',
avatar_type VARCHAR(32) NOT NULL DEFAULT 'emoji',
profile_image TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS tickets (
id VARCHAR(32) PRIMARY KEY,
ticket_type VARCHAR(32) NOT NULL DEFAULT 'application',
title TEXT NOT NULL,
general_category VARCHAR(128) NOT NULL DEFAULT '',
department VARCHAR(128) NOT NULL DEFAULT '',
app_name VARCHAR(128) NOT NULL DEFAULT '',
version VARCHAR(64) NOT NULL DEFAULT '',
feature_name VARCHAR(128) NOT NULL DEFAULT '',
api_key VARCHAR(256) NOT NULL DEFAULT '',
issue_type VARCHAR(128) NOT NULL DEFAULT '',
priority VARCHAR(32) NOT NULL DEFAULT 'medium',
status VARCHAR(32) NOT NULL DEFAULT 'open',
description TEXT NOT NULL DEFAULT '',
assistance_required TEXT NOT NULL DEFAULT '',
additional_info TEXT NOT NULL DEFAULT '',
created_by VARCHAR(64) NOT NULL,
created_by_name VARCHAR(128) NOT NULL DEFAULT '',
created_by_role VARCHAR(64) NOT NULL DEFAULT '',
assigned_to VARCHAR(64) NOT NULL DEFAULT '',
assigned_to_name VARCHAR(128) NOT NULL DEFAULT '',
assigned_to_role VARCHAR(64) NOT NULL DEFAULT '',
hold_reason TEXT NOT NULL DEFAULT '',
held_by VARCHAR(64) NOT NULL DEFAULT '',
held_at TIMESTAMPTZ,
completion_remarks TEXT NOT NULL DEFAULT '',
completed_by VARCHAR(64) NOT NULL DEFAULT '',
completed_at TIMESTAMPTZ,
linked_error_id VARCHAR(32) NOT NULL DEFAULT '',
archived BOOLEAN NOT NULL DEFAULT FALSE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS ticket_remarks (
id VARCHAR(64) PRIMARY KEY,
ticket_id VARCHAR(32) NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
author_username VARCHAR(64) NOT NULL,
author_name VARCHAR(128) NOT NULL DEFAULT '',
author_role VARCHAR(64) NOT NULL DEFAULT '',
type VARCHAR(32) NOT NULL DEFAULT 'comment',
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS ticket_attachments (
id VARCHAR(64) PRIMARY KEY,
ticket_id VARCHAR(32) NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
name VARCHAR(256) NOT NULL,
url TEXT NOT NULL,
size BIGINT NOT NULL DEFAULT 0,
type VARCHAR(32) NOT NULL DEFAULT 'file',
uploaded_by VARCHAR(64) NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS ticket_links (
id SERIAL PRIMARY KEY,
ticket_id VARCHAR(32) NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
url TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS errors (
id VARCHAR(32) PRIMARY KEY,
fingerprint VARCHAR(128) NOT NULL DEFAULT '',
app_name VARCHAR(128) NOT NULL,
version VARCHAR(64) NOT NULL DEFAULT '',
environment VARCHAR(64) NOT NULL DEFAULT 'Production',
service VARCHAR(128) NOT NULL DEFAULT '',
endpoint VARCHAR(256) NOT NULL DEFAULT '',
exception_type VARCHAR(256) NOT NULL,
message TEXT NOT NULL,
stack_trace TEXT NOT NULL DEFAULT '',
severity VARCHAR(32) NOT NULL DEFAULT 'high',
status VARCHAR(32) NOT NULL DEFAULT 'unresolved',
occurrences INT NOT NULL DEFAULT 1,
first_seen TIMESTAMPTZ NOT NULL DEFAULT NOW(),
last_seen TIMESTAMPTZ NOT NULL DEFAULT NOW(),
resolved_at TIMESTAMPTZ,
resolved_by VARCHAR(64) NOT NULL DEFAULT '',
resolution_notes TEXT NOT NULL DEFAULT '',
linked_ticket_id VARCHAR(32) NOT NULL DEFAULT '',
created_by VARCHAR(64) NOT NULL DEFAULT '',
request_payload TEXT NOT NULL DEFAULT '',
archived BOOLEAN NOT NULL DEFAULT FALSE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS notifications (
id VARCHAR(64) PRIMARY KEY,
user_id VARCHAR(64) NOT NULL,
ticket_id VARCHAR(32) NOT NULL DEFAULT '',
title TEXT NOT NULL,
message TEXT NOT NULL DEFAULT '',
type VARCHAR(32) NOT NULL DEFAULT 'assignment',
read BOOLEAN NOT NULL DEFAULT FALSE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE TABLE IF NOT EXISTS khira_sequences (
name VARCHAR(32) PRIMARY KEY,
val INT NOT NULL DEFAULT 100
);
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_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);
`
func hashPassword(pass string) string {
sum := sha256.Sum256([]byte("khira_salt_2026:" + pass))
return fmt.Sprintf("%x", sum)
}
func connectDB(url string) (*sql.DB, error) {
db, err := sql.Open("postgres", url)
if err != nil {
return nil, err
}
db.SetMaxOpenConns(25)
db.SetMaxIdleConns(10)
db.SetConnMaxLifetime(5 * time.Minute)
if err := db.Ping(); err != nil {
db.Close()
return nil, err
}
return db, nil
}
func initSchema(db *sql.DB) error {
_, err := db.Exec(ddlSchema)
return err
}
func seedDefaultUsers(db *sql.DB) error {
// Normalize any legacy roles in database
_, _ = db.Exec(`UPDATE users SET role = 'ios_dev', role_display = 'iOS Dev' WHERE role IN ('frontend_dev', 'frontend')`)
_, _ = db.Exec(`UPDATE users SET role = 'backend_dev', role_display = 'Backend Dev' WHERE role IN ('engineer', 'backend')`)
_, _ = db.Exec(`UPDATE users SET role = 'tester', role_display = 'Tester' WHERE role = 'security'`)
defaultUsers := []struct {
username string
name string
pass string
role string
roleDisplay string
avatar string
}{
{"admin", "System Administrator", "admin", "team_lead", "Team Lead", "A"},
{"charlie", "Charlie Diaz", "charlie123", "tester", "Tester", "🕵️‍♂️"},
{"alice", "Alice Sharma", "alice123", "ios_dev", "iOS Dev", "👩‍💻"},
{"bob", "Bob Anderson", "bob123", "backend_dev", "Backend Dev", "👨‍💻"},
{"diana", "Diana Prince", "diana123", "android_dev", "Android Dev", "🤖"},
{"eva", "Eva Chen", "eva123", "designer", "Designer", "🎨"},
}
for _, u := range defaultUsers {
var exists bool
_ = db.QueryRow("SELECT EXISTS(SELECT 1 FROM users WHERE username = $1)", u.username).Scan(&exists)
if !exists {
id := uuid.New().String()
now := time.Now()
hash := hashPassword(u.pass)
_, err := db.Exec(`
INSERT INTO users (id, username, name, password_hash, role, role_display, avatar, avatar_type, profile_image, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, 'emoji', '', $8, $8)
`, id, u.username, u.name, hash, u.role, u.roleDisplay, u.avatar, now)
if err != nil {
slog.Error("failed to seed user", "username", u.username, "err", err)
}
} else if u.username == "admin" {
// Ensure admin password is "admin" and avatar is "A"
hash := hashPassword("admin")
_, _ = db.Exec("UPDATE users SET password_hash = $1, avatar = 'A' WHERE username = 'admin'", hash)
}
}
// Sequences
_, _ = db.Exec(`INSERT INTO khira_sequences (name, val) VALUES ('ticket_seq', 100) ON CONFLICT (name) DO NOTHING`)
_, _ = db.Exec(`INSERT INTO khira_sequences (name, val) VALUES ('error_seq', 100) ON CONFLICT (name) DO NOTHING`)
return nil
}
// SyncDatabases mirrors all records from primary to backup
func SyncDatabases(primaryDB, backupDB *sql.DB) (map[string]any, error) {
if primaryDB == nil || backupDB == nil {
return nil, errors.New("primary or backup database not connected")
}
tx, err := backupDB.Begin()
if err != nil {
return nil, fmt.Errorf("failed to begin backup transaction: %w", err)
}
defer tx.Rollback()
// Truncate backup tables
truncateQuery := `TRUNCATE ticket_attachments, ticket_links, ticket_remarks, tickets, notifications, errors, users, khira_sequences CASCADE;`
if _, err := tx.Exec(truncateQuery); err != nil {
return nil, fmt.Errorf("failed to truncate backup tables: %w", err)
}
stats := make(map[string]int)
// 1. Users
userRows, err := primaryDB.Query(`SELECT id, username, name, password_hash, role, role_display, avatar, avatar_type, profile_image, created_at, updated_at FROM users`)
if err != nil {
return nil, fmt.Errorf("failed to query primary users: %w", err)
}
defer userRows.Close()
userStmt, err := tx.Prepare(`INSERT INTO users (id, username, name, password_hash, role, role_display, avatar, avatar_type, profile_image, created_at, updated_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`)
if err != nil {
return nil, err
}
defer userStmt.Close()
for userRows.Next() {
var id, un, name, ph, role, rd, av, at, pi string
var ca, ua time.Time
if err := userRows.Scan(&id, &un, &name, &ph, &role, &rd, &av, &at, &pi, &ca, &ua); err != nil {
return nil, err
}
if _, err := userStmt.Exec(id, un, name, ph, role, rd, av, at, pi, ca, ua); err != nil {
return nil, err
}
stats["users"]++
}
// 2. Tickets
ticketRows, err := primaryDB.Query(`
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
FROM tickets
`)
if err != nil {
return nil, fmt.Errorf("failed to query primary tickets: %w", err)
}
defer ticketRows.Close()
ticketStmt, err := tx.Prepare(`
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, hold_reason, held_by, held_at, completion_remarks, completed_by,
completed_at, linked_error_id, archived, 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,$25,$26,$27,$28,$29,$30,$31)
`)
if err != nil {
return nil, err
}
defer ticketStmt.Close()
for ticketRows.Next() {
var t Ticket
if err := ticketRows.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,
); err != nil {
return nil, err
}
if _, err := ticketStmt.Exec(
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,
); err != nil {
return nil, err
}
stats["tickets"]++
}
// 3. Ticket Remarks
remarkRows, err := primaryDB.Query(`SELECT id, ticket_id, author_username, author_name, author_role, type, text, created_at FROM ticket_remarks`)
if err != nil {
return nil, err
}
defer remarkRows.Close()
remarkStmt, err := tx.Prepare(`INSERT INTO ticket_remarks (id, ticket_id, author_username, author_name, author_role, type, text, created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`)
if err != nil {
return nil, err
}
defer remarkStmt.Close()
for remarkRows.Next() {
var id, tid, un, name, role, typ, text string
var ca time.Time
if err := remarkRows.Scan(&id, &tid, &un, &name, &role, &typ, &text, &ca); err != nil {
return nil, err
}
if _, err := remarkStmt.Exec(id, tid, un, name, role, typ, text, ca); err != nil {
return nil, err
}
stats["remarks"]++
}
// 4. Attachments
attRows, err := primaryDB.Query(`SELECT id, ticket_id, name, url, size, type, uploaded_by, created_at FROM ticket_attachments`)
if err != nil {
return nil, err
}
defer attRows.Close()
attStmt, err := tx.Prepare(`INSERT INTO ticket_attachments (id, ticket_id, name, url, size, type, uploaded_by, created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`)
if err != nil {
return nil, err
}
defer attStmt.Close()
for attRows.Next() {
var id, tid, name, url, typ, ub string
var sz int64
var ca time.Time
if err := attRows.Scan(&id, &tid, &name, &url, &sz, &typ, &ub, &ca); err != nil {
return nil, err
}
if _, err := attStmt.Exec(id, tid, name, url, sz, typ, ub, ca); err != nil {
return nil, err
}
stats["attachments"]++
}
// 5. Links
linkRows, err := primaryDB.Query(`SELECT ticket_id, url, created_at FROM ticket_links`)
if err != nil {
return nil, err
}
defer linkRows.Close()
linkStmt, err := tx.Prepare(`INSERT INTO ticket_links (ticket_id, url, created_at) VALUES ($1,$2,$3)`)
if err != nil {
return nil, err
}
defer linkStmt.Close()
for linkRows.Next() {
var tid, url string
var ca time.Time
if err := linkRows.Scan(&tid, &url, &ca); err != nil {
return nil, err
}
if _, err := linkStmt.Exec(tid, url, ca); err != nil {
return nil, err
}
stats["links"]++
}
// 6. Errors
errRows, err := primaryDB.Query(`
SELECT id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_at
FROM errors
`)
if err != nil {
return nil, err
}
defer errRows.Close()
errStmt, err := tx.Prepare(`
INSERT INTO errors (id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_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)
`)
if err != nil {
return nil, err
}
defer errStmt.Close()
for errRows.Next() {
var e AppError
if err := errRows.Scan(
&e.ID, &e.Fingerprint, &e.AppName, &e.Version, &e.Environment, &e.Service, &e.Endpoint, &e.ExceptionType, &e.Message,
&e.StackTrace, &e.Severity, &e.Status, &e.Occurrences, &e.FirstSeen, &e.LastSeen, &e.ResolvedAt, &e.ResolvedBy,
&e.ResolutionNotes, &e.LinkedTicketID, &e.CreatedBy, &e.RequestPayload, &e.Archived, &e.CreatedAt,
); err != nil {
return nil, err
}
if _, err := errStmt.Exec(
e.ID, e.Fingerprint, e.AppName, e.Version, e.Environment, e.Service, e.Endpoint, e.ExceptionType, e.Message,
e.StackTrace, e.Severity, e.Status, e.Occurrences, e.FirstSeen, e.LastSeen, e.ResolvedAt, e.ResolvedBy,
e.ResolutionNotes, e.LinkedTicketID, e.CreatedBy, e.RequestPayload, e.Archived, e.CreatedAt,
); err != nil {
return nil, err
}
stats["errors"]++
}
// 7. Notifications
notifRows, err := primaryDB.Query(`SELECT id, user_id, ticket_id, title, message, type, read, created_at FROM notifications`)
if err != nil {
return nil, err
}
defer notifRows.Close()
notifStmt, err := tx.Prepare(`INSERT INTO notifications (id, user_id, ticket_id, title, message, type, read, created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`)
if err != nil {
return nil, err
}
defer notifStmt.Close()
for notifRows.Next() {
var n Notification
if err := notifRows.Scan(&n.ID, &n.UserID, &n.TicketID, &n.Title, &n.Message, &n.Type, &n.Read, &n.CreatedAt); err != nil {
return nil, err
}
if _, err := notifStmt.Exec(n.ID, n.UserID, n.TicketID, n.Title, n.Message, n.Type, n.Read, n.CreatedAt); err != nil {
return nil, err
}
stats["notifications"]++
}
// 8. Sequences
seqRows, err := primaryDB.Query(`SELECT name, val FROM khira_sequences`)
if err != nil {
return nil, err
}
defer seqRows.Close()
for seqRows.Next() {
var name string
var val int
if err := seqRows.Scan(&name, &val); err != nil {
return nil, err
}
if _, err := tx.Exec(`INSERT INTO khira_sequences (name, val) VALUES ($1, $2) ON CONFLICT (name) DO UPDATE SET val = $2`, name, val); err != nil {
return nil, err
}
}
if err := tx.Commit(); err != nil {
return nil, fmt.Errorf("failed to commit backup transaction: %w", err)
}
return map[string]any{
"status": "ok",
"message": fmt.Sprintf("Backup DB successfully synced (%d tickets, %d users, %d errors)", stats["tickets"], stats["users"], stats["errors"]),
"synced_at": time.Now().Format(time.RFC3339),
"stats": stats,
}, nil
}
// RollbackDatabases restores all records from backup to primary
func RollbackDatabases(primaryDB, backupDB *sql.DB) (map[string]any, error) {
if primaryDB == nil || backupDB == nil {
return nil, errors.New("primary or backup database not connected")
}
// Check if backup has data
var userCount int
if err := backupDB.QueryRow(`SELECT count(*) FROM users`).Scan(&userCount); err != nil || userCount == 0 {
return nil, errors.New("cannot rollback: backup database has no user records")
}
tx, err := primaryDB.Begin()
if err != nil {
return nil, fmt.Errorf("failed to begin rollback transaction: %w", err)
}
defer tx.Rollback()
// Truncate primary tables
truncateQuery := `TRUNCATE ticket_attachments, ticket_links, ticket_remarks, tickets, notifications, errors, users, khira_sequences CASCADE;`
if _, err := tx.Exec(truncateQuery); err != nil {
return nil, fmt.Errorf("failed to truncate primary tables: %w", err)
}
stats := make(map[string]int)
// 1. Users from backup
userRows, err := backupDB.Query(`SELECT id, username, name, password_hash, role, role_display, avatar, avatar_type, profile_image, created_at, updated_at FROM users`)
if err != nil {
return nil, err
}
defer userRows.Close()
userStmt, err := tx.Prepare(`INSERT INTO users (id, username, name, password_hash, role, role_display, avatar, avatar_type, profile_image, created_at, updated_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`)
if err != nil {
return nil, err
}
defer userStmt.Close()
for userRows.Next() {
var id, un, name, ph, role, rd, av, at, pi string
var ca, ua time.Time
if err := userRows.Scan(&id, &un, &name, &ph, &role, &rd, &av, &at, &pi, &ca, &ua); err != nil {
return nil, err
}
if _, err := userStmt.Exec(id, un, name, ph, role, rd, av, at, pi, ca, ua); err != nil {
return nil, err
}
stats["users"]++
}
// 2. Tickets from backup
ticketRows, err := backupDB.Query(`
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
FROM tickets
`)
if err != nil {
return nil, err
}
defer ticketRows.Close()
ticketStmt, err := tx.Prepare(`
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, hold_reason, held_by, held_at, completion_remarks, completed_by,
completed_at, linked_error_id, archived, 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,$25,$26,$27,$28,$29,$30,$31)
`)
if err != nil {
return nil, err
}
defer ticketStmt.Close()
for ticketRows.Next() {
var t Ticket
if err := ticketRows.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,
); err != nil {
return nil, err
}
if _, err := ticketStmt.Exec(
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,
); err != nil {
return nil, err
}
stats["tickets"]++
}
// 3. Ticket Remarks from backup
remarkRows, err := backupDB.Query(`SELECT id, ticket_id, author_username, author_name, author_role, type, text, created_at FROM ticket_remarks`)
if err != nil {
return nil, err
}
defer remarkRows.Close()
remarkStmt, err := tx.Prepare(`INSERT INTO ticket_remarks (id, ticket_id, author_username, author_name, author_role, type, text, created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`)
if err != nil {
return nil, err
}
defer remarkStmt.Close()
for remarkRows.Next() {
var id, tid, un, name, role, typ, text string
var ca time.Time
if err := remarkRows.Scan(&id, &tid, &un, &name, &role, &typ, &text, &ca); err != nil {
return nil, err
}
if _, err := remarkStmt.Exec(id, tid, un, name, role, typ, text, ca); err != nil {
return nil, err
}
stats["remarks"]++
}
// 4. Attachments from backup
attRows, err := backupDB.Query(`SELECT id, ticket_id, name, url, size, type, uploaded_by, created_at FROM ticket_attachments`)
if err != nil {
return nil, err
}
defer attRows.Close()
attStmt, err := tx.Prepare(`INSERT INTO ticket_attachments (id, ticket_id, name, url, size, type, uploaded_by, created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`)
if err != nil {
return nil, err
}
defer attStmt.Close()
for attRows.Next() {
var id, tid, name, url, typ, ub string
var sz int64
var ca time.Time
if err := attRows.Scan(&id, &tid, &name, &url, &sz, &typ, &ub, &ca); err != nil {
return nil, err
}
if _, err := attStmt.Exec(id, tid, name, url, sz, typ, ub, ca); err != nil {
return nil, err
}
stats["attachments"]++
}
// 5. Links from backup
linkRows, err := backupDB.Query(`SELECT ticket_id, url, created_at FROM ticket_links`)
if err != nil {
return nil, err
}
defer linkRows.Close()
linkStmt, err := tx.Prepare(`INSERT INTO ticket_links (ticket_id, url, created_at) VALUES ($1,$2,$3)`)
if err != nil {
return nil, err
}
defer linkStmt.Close()
for linkRows.Next() {
var tid, url string
var ca time.Time
if err := linkRows.Scan(&tid, &url, &ca); err != nil {
return nil, err
}
if _, err := linkStmt.Exec(tid, url, ca); err != nil {
return nil, err
}
stats["links"]++
}
// 6. Errors from backup
errRows, err := backupDB.Query(`
SELECT id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_at
FROM errors
`)
if err != nil {
return nil, err
}
defer errRows.Close()
errStmt, err := tx.Prepare(`
INSERT INTO errors (id, fingerprint, app_name, version, environment, service, endpoint, exception_type, message,
stack_trace, severity, status, occurrences, first_seen, last_seen, resolved_at, resolved_by,
resolution_notes, linked_ticket_id, created_by, request_payload, archived, created_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)
`)
if err != nil {
return nil, err
}
defer errStmt.Close()
for errRows.Next() {
var e AppError
if err := errRows.Scan(
&e.ID, &e.Fingerprint, &e.AppName, &e.Version, &e.Environment, &e.Service, &e.Endpoint, &e.ExceptionType, &e.Message,
&e.StackTrace, &e.Severity, &e.Status, &e.Occurrences, &e.FirstSeen, &e.LastSeen, &e.ResolvedAt, &e.ResolvedBy,
&e.ResolutionNotes, &e.LinkedTicketID, &e.CreatedBy, &e.RequestPayload, &e.Archived, &e.CreatedAt,
); err != nil {
return nil, err
}
if _, err := errStmt.Exec(
e.ID, e.Fingerprint, e.AppName, e.Version, e.Environment, e.Service, e.Endpoint, e.ExceptionType, e.Message,
e.StackTrace, e.Severity, e.Status, e.Occurrences, e.FirstSeen, e.LastSeen, e.ResolvedAt, e.ResolvedBy,
e.ResolutionNotes, e.LinkedTicketID, e.CreatedBy, e.RequestPayload, e.Archived, e.CreatedAt,
); err != nil {
return nil, err
}
stats["errors"]++
}
// 7. Notifications from backup
notifRows, err := backupDB.Query(`SELECT id, user_id, ticket_id, title, message, type, read, created_at FROM notifications`)
if err != nil {
return nil, err
}
defer notifRows.Close()
notifStmt, err := tx.Prepare(`INSERT INTO notifications (id, user_id, ticket_id, title, message, type, read, created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`)
if err != nil {
return nil, err
}
defer notifStmt.Close()
for notifRows.Next() {
var n Notification
if err := notifRows.Scan(&n.ID, &n.UserID, &n.TicketID, &n.Title, &n.Message, &n.Type, &n.Read, &n.CreatedAt); err != nil {
return nil, err
}
if _, err := notifStmt.Exec(n.ID, n.UserID, n.TicketID, n.Title, n.Message, n.Type, n.Read, n.CreatedAt); err != nil {
return nil, err
}
stats["notifications"]++
}
// 8. Sequences from backup
seqRows, err := backupDB.Query(`SELECT name, val FROM khira_sequences`)
if err != nil {
return nil, err
}
defer seqRows.Close()
for seqRows.Next() {
var name string
var val int
if err := seqRows.Scan(&name, &val); err != nil {
return nil, err
}
if _, err := tx.Exec(`INSERT INTO khira_sequences (name, val) VALUES ($1, $2) ON CONFLICT (name) DO UPDATE SET val = $2`, name, val); err != nil {
return nil, err
}
}
if err := tx.Commit(); err != nil {
return nil, fmt.Errorf("failed to commit rollback transaction: %w", err)
}
return map[string]any{
"status": "ok",
"message": fmt.Sprintf("Primary DB successfully rolled back from Backup DB (%d tickets, %d users, %d errors restored)", stats["tickets"], stats["users"], stats["errors"]),
"rolled_back_at": time.Now().Format(time.RFC3339),
"stats": stats,
}, nil
}
func getTableCounts(db *sql.DB) map[string]int {
counts := make(map[string]int)
tables := []string{"users", "tickets", "ticket_remarks", "errors", "notifications"}
for _, t := range tables {
var c int
_ = db.QueryRow(fmt.Sprintf("SELECT count(*) FROM %s", t)).Scan(&c)
counts[t] = c
}
return counts
}