chronorunner/server/src/modules/database/handlers.go

package database

import (
	"database/sql"
	"errors"
	"fmt"
	"ghostrunner-server/modules/encrypt"
	"ghostrunner-server/modules/utilities"
	"log"
	"strings"
	"time"
)

func insertAdminToken(token string, hmacKey []byte) error {
	var adminTokenName string = "Self-Generated Admin Token"
	adminTokenName = strings.ToLower(adminTokenName)
	hashedToken := encrypt.CreateHMAC(token, hmacKey)

	_, err := db.Exec(declStat.AdminTokenCreate, adminTokenName, hashedToken)
	if err != nil {
		return fmt.Errorf("failed to insert admin token: %w", err)
	}

	return nil
}

func InsertToken(tokenName, securedToken string) error {
	_, err := db.Exec(declStat.CreateToken, tokenName, securedToken)
	return err
}

func RemoveToken(tokenName string) error {
	var tokenID int
	err := db.QueryRow(declStat.GetTokenID, tokenName).Scan(&tokenID)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return fmt.Errorf("token not found")
		}
		return fmt.Errorf("failed to retrieve token ID: %w", err)
	}

	if tokenID == 0 { //TRYING TO REMOVE THE ADMIN TOKEN! NOT ALLOWED!
		return fmt.Errorf("not abiding the removal of the admin token, program resisted")
	}

	_, err = db.Exec(declStat.DeleteToken, tokenName)
	if err != nil {
		return fmt.Errorf("failed to delete token: %w", err)
	}

	return nil
}

func RetrieveTokens() []string {
	rows, err := db.Query(declStat.RetrieveTokens)
	if err != nil {
		log.Println(utilities.ErrTag, err)
		return []string{}
	}
	defer rows.Close()

	var tokens []string
	for rows.Next() {
		var singleToken string
		err = rows.Scan(&singleToken)
		if err != nil {
			log.Println(utilities.ErrTag, err)
		}

		tokens = append(tokens, singleToken)
	}
	return tokens
}

func RetrieveTokenNames() []string {
	rows, err := db.Query(declStat.RetrieveTokenNames)
	if err != nil {
		log.Println(utilities.ErrTag, err)
		return []string{}
	}
	defer rows.Close()

	var tokenNames []string
	for rows.Next() {
		var singleTokenName string
		err = rows.Scan(&singleTokenName)
		if err != nil {
			log.Println(utilities.ErrTag, err)
		}

		tokenNames = append(tokenNames, singleTokenName)
	}
	return tokenNames
}

func InsertTask(name, uuid, command string, nodeids []string, date string, expire time.Time) error {
	log.Println(name, uuid, command, nodeids, date, expire)

	/*
		for _, singleNodeid := range nodeids {
			var count int
			err := db.QueryRow(declStat.CountDuplTasks, command, singleNodeid).Scan(&count)
			if err != nil {
				return fmt.Errorf("failed to count the task occurence: %w", err)
			}

			if count > 0 {
				log.Println(WarnTag, "Skipped creation of a task because its a duplicate.")
				log.Println(WarnTag, fmt.Sprintf("Details: NodeID: %s, Task name: %s", singleNodeid, name))
			} else {
				formattedExpire := expire.Format(utilities.ExtLayout) // Safe format for DB

				_, err = db.Exec(declStat.CreateTask, name, uuid, command, singleNodeid, date, formattedExpire)
				if err != nil {
					return fmt.Errorf("failed to create task: %w", err)
				}
			}
		}
	*/
	return nil
}

func RemoveTask(name, nodeid string) error {
	var count int
	err := db.QueryRow(declStat.CountTasks, name).Scan(&count)
	if err != nil {
		return fmt.Errorf("failed to count the task occurence: %w", err)
	}

	if count == 0 {
		return fmt.Errorf("task '%s' not found", name)
	}

	if _, err = db.Exec(declStat.DeleteTask, name, nodeid); err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return fmt.Errorf("token not found")
		}
		return fmt.Errorf("failed to retrieve token ID: %w", err)
	}

	return nil
}

func RetrieveTasks() []utilities.InternalQueueTaskData {
	rows, err := db.Query(declStat.ListAllTasks)
	if err != nil {
		log.Println("Query error:", err)
		return []utilities.InternalQueueTaskData{}
	}
	defer rows.Close()

	var tasks []utilities.InternalQueueTaskData

	for rows.Next() {
		var task utilities.InternalQueueTaskData

		err := rows.Scan(&task.Name, &task.UUID, &task.Command, &task.Nodeid, &task.Creation, &task.Expire)
		if err != nil {
			log.Println("Row scan error:", err)
			continue
		}

		tasks = append(tasks, task)
	}

	if err := rows.Err(); err != nil {
		log.Println("Rows error:", err)
	}

	return tasks
}