hostname-service/api/hostname_handlers.go

// Copyright 2024 Florian Beisel
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package api

import (
	"net/http"
	"strings"

	"git.beisel.it/florian/hostname-service/db"
	"git.beisel.it/florian/hostname-service/models"
	"github.com/gin-gonic/gin"
)

// @Summary		Return a single hostname by Category and Name
// @Description	Return details for a single hostname identified by its category
// @ID				get-hostname-by-category-and-name
// @Produce		json
// @Param			category	path		string			true	"Category of the hostname"
// @Param			hostname	path		string			true	"Category of the hostname"
// @Success		200			{object}	models.Hostname	"A single response object"
// @Security		Bearer
// @Tags			Querying Hostnames
// @Router			/{category}/{hostname} [get]
func GetHostnameByCategoryAndName(c *gin.Context) {
	category := c.Param("category")
	hostname := c.Param("hostname")

	hostinfo, err := db.GetHostnameByCategoryAndName(category, hostname)
	if err != nil {
		if strings.Contains(err.Error(), "no rows found") {
			c.JSON(http.StatusNotFound, gin.H{"error": "hostname not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Error retrieving hostname"})
		return
	}

	c.JSON(http.StatusOK, hostinfo)
}

// @Summary		Return a list of hosts and their details filtered by category
// @Description	List all details for a given category
// @ID				list-hostnames-by-category
// @Produce		json
// @Param			category	path	string			true	"Category of the hostname"
// @Success		200			{array}	models.Hostname	"An array of responses"
// @Security		Bearer
// @Tags			Querying Hostnames
// @Router			/{category} [get]
func ListHostnamesByCategory(c *gin.Context) {
	category := c.Param("category")

	hostnames, err := db.GetHostnamesByCategory(category)
	if err != nil {
		if strings.Contains(err.Error(), "no rows found") {
			c.JSON(http.StatusNotFound, gin.H{"error": "hostname not found"})
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Error retrieving hostnames"})
		return
	}

	c.JSON(http.StatusOK, hostnames)
}

// @Summary		Delete a hostname from the database
// @Description	List all details for a given category
// @ID				delete-hostnames-by-category-and-name
// @Produce		json
// @Param			category	path		string							true	"Category of the hostname"
// @Param			hostname	path		string							true	"Hostname to delete"
// @Success		200			{object}	models.SimpleHostnameResponse	"Hostname"
// @Security		Bearer
// @Tags			Manipulate existing Hostnames
// @Router			/{category}/{hostname} [delete]
func DeleteHostname(c *gin.Context) {
	category := c.Param("category")
	hostname := c.Param("hostname")

	err := db.DeleteHostname(category, hostname)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	response := models.SimpleHostnameResponse{Hostname: hostname}
	c.JSON(http.StatusOK, response)
}

func CreateOrUpdateHostname(c *gin.Context, isUpdate bool) {
	category := c.Param("category")
	var oldHostname string
	if isUpdate {
		oldHostname = c.Param("oldhostname")
	}

	var params map[string]interface{}
	if err := c.BindJSON(&params); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid parameters"})
		return
	}

	rule, err := getHostnameRuleByCategory(category)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	var hostname string
	if isUpdate {
		hostname, err = rule.Update(category, oldHostname, params)
	} else {
		hostname, err = rule.Insert(category, params)
	}

	if err != nil {
		if isUpdate && strings.Contains(err.Error(), "does not exist") {
			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
		} else {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		}
		return
	}

	response := models.SimpleHostnameResponse{Hostname: hostname}
	c.JSON(http.StatusOK, response)
}