753 lines
26 KiB
Go
753 lines
26 KiB
Go
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 '',
|
|
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 '',
|
|
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 {
|
|
defaultUsers := []struct {
|
|
username string
|
|
name string
|
|
pass string
|
|
role string
|
|
roleDisplay string
|
|
avatar string
|
|
}{
|
|
{"admin", "System Administrator", "admin", "team_lead", "Team Lead", "⚡"},
|
|
{"alice", "Alice Sharma", "alice123", "frontend_dev", "Frontend Dev", "👩💻"},
|
|
{"bob", "Bob Anderson", "bob123", "backend_dev", "Backend Dev", "👨💻"},
|
|
{"charlie", "Charlie Diaz", "charlie123", "tester", "Tester", "🕵️♂️"},
|
|
}
|
|
|
|
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"
|
|
hash := hashPassword("admin")
|
|
_, _ = db.Exec("UPDATE users SET password_hash = $1 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, 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, 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)
|
|
`)
|
|
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.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.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, 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, 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)
|
|
`)
|
|
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.FirstSeen,
|
|
); 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.FirstSeen,
|
|
); 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, 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, 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)
|
|
`)
|
|
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.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.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, 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, 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)
|
|
`)
|
|
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.FirstSeen,
|
|
); 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.FirstSeen,
|
|
); 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
|
|
}
|