NAM-APJATEL-BACKEND/delivery/controller/tower_controller.go

package controller

import (
	"net/http"
	"strconv"
	"users_management/m/middleware"
	"users_management/m/model/dto/req"
	"users_management/m/usecase"
	"users_management/m/utils/common"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

type TowerController struct {
	tu usecase.TowerUseCase
	rg *gin.RouterGroup
}

func (tc *TowerController) Route() {
	rg := tc.rg.Group("/tower")
    rg.Use(middleware.RequireAnyRole("Teknisi", "Admin", "Superadmin")) // Apply middleware to all routes
	{
		rg.GET("", tc.GetTower())
		rg.POST("", tc.CreateTower())

		rg.GET("/:uuid", tc.GetTowerByID())
		rg.PUT("/:uuid", tc.UpdateTower())
	}
}

func NewTowerController(tu usecase.TowerUseCase, rg *gin.RouterGroup) *TowerController {
	return &TowerController{
		tu: tu,
		rg: rg,
	}
}

func (tc *TowerController) GetTower() gin.HandlerFunc {
	return func(c *gin.Context) {
		towers, err := tc.tu.GetAll()

		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
			return
		}

		common.SingleResponses(c, "Success", towers)
	}
}

func (tc *TowerController) CreateTower() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Parse multipart form
        err := c.Request.ParseMultipartForm(10 << 20) // 10MB max
        if err != nil {
            common.ErrorResponses(c, http.StatusBadRequest, "Failed to parse multipart form")
            return
        }

        // Extract form data
        deviceIDStr := c.PostForm("dev_id")
        towerCode := c.PostForm("tower_code")
        longitudeStr := c.PostForm("longitude")
        latitudeStr := c.PostForm("latitude")
        externalTowerStr := c.PostForm("external_tower")

        // Validate required fields
        if towerCode == "" || longitudeStr == "" || latitudeStr == "" {
            common.ErrorResponses(c, http.StatusBadRequest, "Missing required fields")
            return
        }

        var deviceID *uuid.UUID
        if deviceIDStr != "" {
            parsedDeviceID, err := uuid.Parse(deviceIDStr)
            if err != nil {
                common.ErrorResponses(c, http.StatusBadRequest, "Invalid device ID")
                return
            }
            deviceID = &parsedDeviceID
        }

        // Parse coordinates
        longitude, err := strconv.ParseFloat(longitudeStr, 64)
        if err != nil {
            common.ErrorResponses(c, http.StatusBadRequest, "Invalid longitude")
            return
        }

        latitude, err := strconv.ParseFloat(latitudeStr, 64)
        if err != nil {
            common.ErrorResponses(c, http.StatusBadRequest, "Invalid latitude")
            return
        }

        var externalTower *bool
        if externalTowerStr != "" {
            parsedExternalTower, err := strconv.ParseBool(externalTowerStr)
            if err != nil {
                common.ErrorResponses(c, http.StatusBadRequest, "Invalid external_tower value")
                return
            }
            externalTower = &parsedExternalTower
        }

        // Create DTO
        towerDTO := req.TowerDTO{
            DeviceID:      deviceID,
            TowerCode:     towerCode,
            Longitude:     longitude,
            Latitude:      latitude,
            ExternalTower: externalTower,
        }

        // Get image file (optional)
        imageFile, _ := c.FormFile("image")

        err = tc.tu.Post(towerDTO, imageFile)
        if err != nil {
            common.ErrorResponses(c, http.StatusBadRequest, err.Error())
            return
        }

        common.SingleResponses(c, "Tower has been created", nil)
    }
}

func (tc *TowerController) GetTowerByID() gin.HandlerFunc {
	return func(c *gin.Context) {
		id := c.Param("uuid")
		uuid, err := uuid.Parse(id)
		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
			return
		}
		tower, err := tc.tu.GetByID(uuid)

		if err != nil {
			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
			return
		}

		common.SingleResponses(c, "Success", tower)
	}
}

func (tc *TowerController) UpdateTower() gin.HandlerFunc {
    return func(c *gin.Context) {
        id := c.Param("uuid")
		
        tower_uuid, err := uuid.Parse(id)
        if err != nil {
            common.ErrorResponses(c, http.StatusBadRequest, err.Error())
            return
        }

        // Parse multipart form
        err = c.Request.ParseMultipartForm(10 << 20) // 10MB max
        if err != nil {
            common.ErrorResponses(c, http.StatusBadRequest, "Failed to parse multipart form")
            return
        }

        // Create update DTO
        towerUpdateDTO := req.UpdateTowerDTO{}

        // Optional fields
        if deviceIDStr := c.PostForm("device_id"); deviceIDStr != "" {
            if deviceID, err := uuid.Parse(deviceIDStr); err == nil {
                towerUpdateDTO.DeviceID = &deviceID
            }
        }

        if towerCode := c.PostForm("tower_code"); towerCode != "" {
            towerUpdateDTO.TowerCode = &towerCode
        }

        if longitudeStr := c.PostForm("longitude"); longitudeStr != "" {
            if longitude, err := strconv.ParseFloat(longitudeStr, 64); err == nil {
                towerUpdateDTO.Longitude = &longitude
            }
        }

        if latitudeStr := c.PostForm("latitude"); latitudeStr != "" {
            if latitude, err := strconv.ParseFloat(latitudeStr, 64); err == nil {
                towerUpdateDTO.Latitude = &latitude
            }
        }

        // Get image file (optional)
        imageFile, _ := c.FormFile("image")

        err = tc.tu.UpdateTower(tower_uuid, towerUpdateDTO, imageFile)
        if err != nil {
            common.ErrorResponses(c, http.StatusBadRequest, err.Error())
            return
        }

        common.SingleResponses(c, "Tower has been updated", nil)
    }
}