infra-dashboard/Http/package.go

package http

import (
	"encoding/json"
	"gopkg.in/guregu/null.v4"
	db "infra-dashboard/Database"
	"io"
	"log"
	"net/http"
	"strconv"
	"time"

	"github.com/gorilla/mux"
)

func GetAllPackages(w http.ResponseWriter, r *http.Request) {
	var list []db.Package
	var err error

	t := time.Now()
	status := 200

	db_conn := db.GetDatabaseConnection()
	defer db_conn.Close()
	list, err = db.GetPackage(db_conn)
	if err != nil {
		log.Println("Error getting Package list")
		status = 500
	}
	logRequest(t, r, status)
	w.Header().Set("Content-Type", "application/json")
	err = json.NewEncoder(w).Encode(list)
	if err != nil {
		log.Println("Error encoding response")
		return
	}
}

func GetPackagebyID(w http.ResponseWriter, r *http.Request) {
	var pkg db.Package
	var err error

	t := time.Now()
	status := 200

	params := mux.Vars(r)
	dbConn := db.GetDatabaseConnection()
	defer dbConn.Close()
	id, err := strconv.ParseInt(params["id"], 10, 64)
	if err != nil {
		log.Println("Error converting ID", err)
		status = 500
	}
	pkg, err = db.GetPackagebyID(dbConn, int64(id))
	if err != nil {
		log.Println("Error getting Package")
		status = 500
	}
	logRequest(t, r, status)
	w.Header().Set("Content-Type", "application/json")
	err = json.NewEncoder(w).Encode(pkg)
	if err != nil {
		log.Println("Error encoding response")
		return
	}
}

func CreatePackage(w http.ResponseWriter, r *http.Request) {
	var pkg db.Package
	var err error
	t := time.Now()
	status := 200

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
	}

	params := make(map[string]null.String)
	err = json.Unmarshal(body, &params)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
		return
	}
	pkg.Name = params["name"]
	dbConn := db.GetDatabaseConnection()
	defer dbConn.Close()
	err = db.CreatePackage(pkg, dbConn)
	if err != nil {
		log.Println("Error creating package", pkg.Name)
		status = 500
	}
	logRequest(t, r, status)
	w.WriteHeader(status)
}

func DisablePackage(w http.ResponseWriter, r *http.Request) {
	var pkg db.Package
	var err error
	var status int
	t := time.Now()

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
	}

	params := make(map[string]null.String)
	err = json.Unmarshal(body, &params)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
		return
	}
	pkg.Name = params["name"]
	dbConn := db.GetDatabaseConnection()
	defer dbConn.Close()
	status, err = db.DisablePackage(pkg, dbConn)
	if err != nil {
		log.Println(err.Error(), "Error disabling package", pkg.Name)
	}
	logRequest(t, r, status)
	w.WriteHeader(status)
}

func EnablePackage(w http.ResponseWriter, r *http.Request) {
	var pkg db.Package
	var err error
	var status int
	t := time.Now()

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
	}

	params := make(map[string]null.String)
	err = json.Unmarshal(body, &params)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
		return
	}
	pkg.Name = params["name"]
	dbConn := db.GetDatabaseConnection()
	defer dbConn.Close()
	status, err = db.EnablePackage(pkg, dbConn)
	if err != nil {
		log.Println(err.Error(), "Error enabling package", pkg.Name)
	}
	logRequest(t, r, status)
	w.WriteHeader(status)
}

func DeletePackage(w http.ResponseWriter, r *http.Request) {
	var pkg db.Package
	var err error
	var status int
	t := time.Now()

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
	}

	params := make(map[string]null.String)
	err = json.Unmarshal(body, &params)
	if err != nil {
		log.Println(err.Error(), "Error reading request body")
		return
	}
	pkg.Name = params["name"]
	dbConn := db.GetDatabaseConnection()
	defer dbConn.Close()
	status, err = db.DeletePackage(pkg, dbConn)
	if err != nil {
		log.Println(err.Error(), "Error deleting package", pkg.Name)
	}
	logRequest(t, r, status)
	w.WriteHeader(status)
}