633 lines
18 KiB
Go
633 lines
18 KiB
Go
package controller
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"users_management/m/config"
|
|
"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 DeviceController struct {
|
|
du usecase.DeviceUseCase
|
|
rg *gin.RouterGroup
|
|
cfg *config.Config
|
|
}
|
|
|
|
func NewDeviceController(du usecase.DeviceUseCase, rg *gin.RouterGroup, cfg *config.Config) *DeviceController {
|
|
return &DeviceController{
|
|
du: du,
|
|
rg: rg,
|
|
cfg: cfg,
|
|
}
|
|
}
|
|
|
|
func (dc *DeviceController) Route() {
|
|
rg := dc.rg.Group("/devices")
|
|
rg.Use(middleware.ConditionalRequireAnyRole(dc.cfg, "Teknisi", "Admin", "Super Admin"))
|
|
{
|
|
rg.POST("", dc.CreateDevice())
|
|
rg.GET("", dc.GetAllDevices())
|
|
rg.GET("/:uuid", dc.GetDeviceByID())
|
|
rg.PUT("/:uuid", dc.UpdateDevice())
|
|
|
|
// Bulk operations
|
|
rg.POST("/bulk-create", dc.BulkCreateDevices())
|
|
rg.PUT("/bulk-update", dc.BulkUpdateDevices())
|
|
rg.DELETE("/bulk-delete", dc.BulkDeleteDevices())
|
|
|
|
rg.POST("/bulk-upload-images", dc.BulkUploadImages())
|
|
}
|
|
}
|
|
|
|
func (dc *DeviceController) BulkUploadImages() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
// Parse multipart form
|
|
err := c.Request.ParseMultipartForm(100 << 20) // 100MB for bulk upload
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Failed to parse multipart form")
|
|
return
|
|
}
|
|
|
|
// Get device data from form
|
|
deviceDataStr := c.PostForm("devices")
|
|
if deviceDataStr == "" {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "devices data is required")
|
|
return
|
|
}
|
|
|
|
// Parse device data
|
|
var devicesData []req.BulkDeviceImageUploadDTO
|
|
if err := json.Unmarshal([]byte(deviceDataStr), &devicesData); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid devices data format")
|
|
return
|
|
}
|
|
|
|
// Get all image files
|
|
form := c.Request.MultipartForm
|
|
allFiles := form.File["images"]
|
|
|
|
if len(allFiles) == 0 {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "No image files provided")
|
|
return
|
|
}
|
|
|
|
// Parse file distribution from form data
|
|
fileDistributionStr := c.PostForm("file_distribution")
|
|
var fileDistribution []int
|
|
|
|
if fileDistributionStr != "" {
|
|
if err := json.Unmarshal([]byte(fileDistributionStr), &fileDistribution); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid file_distribution format")
|
|
return
|
|
}
|
|
} else {
|
|
// Default: distribute files evenly
|
|
filesPerDevice := len(allFiles) / len(devicesData)
|
|
remainder := len(allFiles) % len(devicesData)
|
|
|
|
fileDistribution = make([]int, len(devicesData))
|
|
for i := range fileDistribution {
|
|
fileDistribution[i] = filesPerDevice
|
|
if i < remainder {
|
|
fileDistribution[i]++
|
|
}
|
|
}
|
|
}
|
|
|
|
// Validate file distribution
|
|
if len(fileDistribution) != len(devicesData) {
|
|
common.ErrorResponses(c, http.StatusBadRequest,
|
|
fmt.Sprintf("File distribution count (%d) must match device count (%d)",
|
|
len(fileDistribution), len(devicesData)))
|
|
return
|
|
}
|
|
|
|
totalExpectedFiles := 0
|
|
for _, count := range fileDistribution {
|
|
totalExpectedFiles += count
|
|
}
|
|
if totalExpectedFiles != len(allFiles) {
|
|
common.ErrorResponses(c, http.StatusBadRequest,
|
|
fmt.Sprintf("Total files (%d) must match file distribution sum (%d)",
|
|
len(allFiles), totalExpectedFiles))
|
|
return
|
|
}
|
|
|
|
// Call use case
|
|
err = dc.du.BulkUploadImagesMultiple(devicesData, allFiles, fileDistribution)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
totalImages := len(allFiles)
|
|
common.SingleResponses(c, fmt.Sprintf("%d images uploaded successfully for %d devices", totalImages, len(devicesData)), nil)
|
|
}
|
|
}
|
|
func (dc *DeviceController) CreateDevice() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
contentType := c.GetHeader("Content-Type")
|
|
|
|
// Handle JSON request (no images)
|
|
if strings.Contains(contentType, "application/json") {
|
|
var deviceDTO req.DeviceDTO
|
|
err := c.ShouldBindJSON(&deviceDTO)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
err = dc.du.CreateDevice(deviceDTO)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
common.SingleResponses(c, "Device has been created", nil)
|
|
return
|
|
}
|
|
|
|
// Parse multipart form
|
|
err := c.Request.ParseMultipartForm(50 << 20) // 50MB for multiple images
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Failed to parse multipart form")
|
|
return
|
|
}
|
|
|
|
// Extract form data for device
|
|
deviceCode := c.PostForm("device_code")
|
|
deviceType := c.PostForm("device_type")
|
|
longitudeStr := c.PostForm("longitude")
|
|
latitudeStr := c.PostForm("latitude")
|
|
portAmountStr := c.PostForm("port_amount")
|
|
status := c.PostForm("status")
|
|
province := c.PostForm("province")
|
|
city := c.PostForm("city")
|
|
district := c.PostForm("district")
|
|
|
|
// Validate required fields
|
|
if deviceCode == "" || deviceType == "" || longitudeStr == "" || latitudeStr == "" || status == "" {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Missing required fields")
|
|
return
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// Parse port amount
|
|
portAmount := 0
|
|
if portAmountStr != "" {
|
|
portAmount, err = strconv.Atoi(portAmountStr)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid port amount")
|
|
return
|
|
}
|
|
}
|
|
|
|
var towerID *uuid.UUID
|
|
if towerIDStr := c.PostForm("tower_id"); towerIDStr != "" {
|
|
if parsedTowerID, err := uuid.Parse(towerIDStr); err == nil {
|
|
towerID = &parsedTowerID
|
|
} else {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid tower ID format")
|
|
return
|
|
}
|
|
}
|
|
|
|
// Handle OLTID in form data
|
|
var oltID *uuid.UUID
|
|
if oltIDStr := c.PostForm("olt_id"); oltIDStr != "" {
|
|
if parsedOLTID, err := uuid.Parse(oltIDStr); err == nil {
|
|
oltID = &parsedOLTID
|
|
} else {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid OLT ID format")
|
|
return
|
|
}
|
|
}
|
|
|
|
// Create DTO
|
|
deviceDTO := req.DeviceDTO{
|
|
DeviceCode: deviceCode,
|
|
DeviceType: deviceType,
|
|
Longitude: longitude,
|
|
Latitude: latitude,
|
|
PortAmount: portAmount,
|
|
Status: status,
|
|
TowerID: towerID, // Add TowerID
|
|
OLTID: oltID, // Add OLTID
|
|
}
|
|
|
|
// Handle optional string fields
|
|
if province != "" {
|
|
deviceDTO.Province = &province
|
|
}
|
|
if city != "" {
|
|
deviceDTO.City = &city
|
|
}
|
|
if district != "" {
|
|
deviceDTO.District = &district
|
|
}
|
|
|
|
// Get multiple image files
|
|
form := c.Request.MultipartForm
|
|
imageFiles := form.File["images"] // Multiple images
|
|
|
|
// Also support single image upload for backward compatibility
|
|
if len(imageFiles) == 0 {
|
|
if singleImage, err := c.FormFile("image"); err == nil {
|
|
imageFiles = []*multipart.FileHeader{singleImage}
|
|
}
|
|
}
|
|
|
|
err = dc.du.CreateDeviceWithMultipleImages(deviceDTO, imageFiles)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
common.SingleResponses(c, "Device has been created", nil)
|
|
}
|
|
}
|
|
func (dc *DeviceController) GetAllDevices() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
|
|
deviceType := c.Query("type")
|
|
if deviceType != "" {
|
|
deviceResp, err := dc.du.GetByType(deviceType)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Device type not found")
|
|
return
|
|
}
|
|
common.SingleResponses(c, "Success", deviceResp)
|
|
return
|
|
}
|
|
|
|
devices, err := dc.du.GetAllDevices()
|
|
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "something went wrong")
|
|
return
|
|
}
|
|
|
|
common.SingleResponses(c, "Success", devices)
|
|
}
|
|
}
|
|
|
|
func (dc *DeviceController) GetDeviceByID() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
id := c.Param("uuid")
|
|
uuid, err := uuid.Parse(id)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadGateway, "Invalid UUID")
|
|
return
|
|
}
|
|
device, err := dc.du.GetByID(uuid)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Device not found")
|
|
return
|
|
}
|
|
|
|
common.SingleResponses(c, "Success", device)
|
|
}
|
|
}
|
|
|
|
func (dc *DeviceController) UpdateDevice() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
id := c.Param("uuid")
|
|
deviceUUID, err := uuid.Parse(id) // Change variable name from 'uuid' to 'deviceUUID'
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid UUID")
|
|
return
|
|
}
|
|
|
|
contentType := c.GetHeader("Content-Type")
|
|
|
|
// Handle JSON request (no images)
|
|
if strings.Contains(contentType, "application/json") {
|
|
var deviceDTO req.UpdateDeviceDTO
|
|
err = c.ShouldBindJSON(&deviceDTO)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid request")
|
|
return
|
|
}
|
|
|
|
err = dc.du.UpdateDevice(deviceUUID, deviceDTO) // Use the new variable name
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error()) // Also fix error message
|
|
return
|
|
}
|
|
|
|
common.SingleResponses(c, "Device has been updated", nil)
|
|
return
|
|
}
|
|
|
|
// Handle multipart form request
|
|
err = c.Request.ParseMultipartForm(50 << 20) // 50MB for multiple images
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Failed to parse multipart form")
|
|
return
|
|
}
|
|
|
|
// Create update DTO from form data
|
|
deviceUpdateDTO := req.UpdateDeviceDTO{}
|
|
|
|
if deviceCode := c.PostForm("device_code"); deviceCode != "" {
|
|
deviceUpdateDTO.DeviceCode = &deviceCode
|
|
}
|
|
if deviceType := c.PostForm("device_type"); deviceType != "" {
|
|
deviceUpdateDTO.DeviceType = &deviceType
|
|
}
|
|
if longitudeStr := c.PostForm("longitude"); longitudeStr != "" {
|
|
if longitude, err := strconv.ParseFloat(longitudeStr, 64); err == nil {
|
|
deviceUpdateDTO.Longitude = &longitude
|
|
} else {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid longitude format")
|
|
return
|
|
}
|
|
}
|
|
if latitudeStr := c.PostForm("latitude"); latitudeStr != "" {
|
|
if latitude, err := strconv.ParseFloat(latitudeStr, 64); err == nil {
|
|
deviceUpdateDTO.Latitude = &latitude
|
|
} else {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid latitude format")
|
|
return
|
|
}
|
|
}
|
|
if portAmountStr := c.PostForm("port_amount"); portAmountStr != "" {
|
|
if portAmount, err := strconv.Atoi(portAmountStr); err == nil {
|
|
deviceUpdateDTO.PortAmount = &portAmount
|
|
} else {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid port amount format")
|
|
return
|
|
}
|
|
}
|
|
if status := c.PostForm("status"); status != "" {
|
|
deviceUpdateDTO.Status = &status
|
|
}
|
|
if province := c.PostForm("province"); province != "" {
|
|
deviceUpdateDTO.Province = &province
|
|
}
|
|
if city := c.PostForm("city"); city != "" {
|
|
deviceUpdateDTO.City = &city
|
|
}
|
|
if district := c.PostForm("district"); district != "" {
|
|
deviceUpdateDTO.District = &district
|
|
}
|
|
|
|
// Handle TowerID in form data
|
|
if towerIDStr := c.PostForm("tower_id"); towerIDStr != "" {
|
|
if towerID, err := uuid.Parse(towerIDStr); err == nil {
|
|
deviceUpdateDTO.TowerID = &towerID
|
|
} else {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid tower ID format")
|
|
return
|
|
}
|
|
}
|
|
|
|
// Handle OLTID in form data
|
|
if oltIDStr := c.PostForm("olt_id"); oltIDStr != "" {
|
|
if oltID, err := uuid.Parse(oltIDStr); err == nil {
|
|
deviceUpdateDTO.OLTID = &oltID
|
|
} else {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid OLT ID format")
|
|
return
|
|
}
|
|
}
|
|
|
|
// Get multiple image files
|
|
form := c.Request.MultipartForm
|
|
imageFiles := form.File["images"] // Support multiple images
|
|
|
|
// Also support single image upload for backward compatibility
|
|
if len(imageFiles) == 0 {
|
|
if singleImage, err := c.FormFile("image"); err == nil {
|
|
imageFiles = []*multipart.FileHeader{singleImage}
|
|
}
|
|
}
|
|
|
|
// Handle replace_images flag
|
|
replaceImages := c.PostForm("replace_images") == "true"
|
|
|
|
err = dc.du.UpdateDeviceWithMultipleImages(deviceUUID, deviceUpdateDTO, imageFiles, replaceImages) // Use the new variable name
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
common.SingleResponses(c, "Device has been updated", nil)
|
|
}
|
|
}
|
|
|
|
// BulkCreateDevices creates multiple devices at once
|
|
func (dc *DeviceController) BulkCreateDevices() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
contentType := c.GetHeader("Content-Type")
|
|
|
|
// Handle multipart/form-data with images
|
|
if strings.Contains(contentType, "multipart/form-data") {
|
|
err := c.Request.ParseMultipartForm(100 << 20) // 100MB for bulk images
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Failed to parse multipart form")
|
|
return
|
|
}
|
|
|
|
// Parse devices JSON from form field
|
|
devicesJSON := c.PostForm("devices")
|
|
if devicesJSON == "" {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Devices data is required")
|
|
return
|
|
}
|
|
|
|
var request req.BulkCreateDeviceDTO
|
|
if err := json.Unmarshal([]byte(devicesJSON), &request); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid devices JSON: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Parse image_indexes from form field
|
|
imageIndexesJSON := c.PostForm("image_indexes")
|
|
if imageIndexesJSON == "" {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "image_indexes is required")
|
|
return
|
|
}
|
|
|
|
var imageIndexes []int
|
|
if err := json.Unmarshal([]byte(imageIndexesJSON), &imageIndexes); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid image_indexes JSON: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Get all image files
|
|
form := c.Request.MultipartForm
|
|
imageFiles := form.File["images"]
|
|
|
|
// Call usecase with images
|
|
result, err := dc.du.BulkCreateDevicesWithImages(request, imageFiles, imageIndexes)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
message := fmt.Sprintf("Bulk create completed: %d successful, %d failed out of %d requested (with %d images)",
|
|
result.Successful, result.Failed, result.TotalRequested, len(imageFiles))
|
|
common.SingleResponses(c, message, result)
|
|
return
|
|
}
|
|
|
|
// Handle JSON request (no images)
|
|
var request req.BulkCreateDeviceDTO
|
|
if err := c.ShouldBindJSON(&request); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
result, err := dc.du.BulkCreateDevices(request)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
message := fmt.Sprintf("Bulk create completed: %d successful, %d failed out of %d requested",
|
|
result.Successful, result.Failed, result.TotalRequested)
|
|
common.SingleResponses(c, message, result)
|
|
}
|
|
}
|
|
|
|
// BulkUpdateDevices updates multiple devices with the same values
|
|
func (dc *DeviceController) BulkUpdateDevices() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
contentType := c.GetHeader("Content-Type")
|
|
|
|
// Handle multipart/form-data with images
|
|
if strings.Contains(contentType, "multipart/form-data") {
|
|
err := c.Request.ParseMultipartForm(100 << 20) // 100MB for bulk images
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Failed to parse multipart form")
|
|
return
|
|
}
|
|
|
|
// Parse device_ids JSON from form field
|
|
deviceIDsJSON := c.PostForm("device_ids")
|
|
if deviceIDsJSON == "" {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "device_ids is required")
|
|
return
|
|
}
|
|
|
|
var deviceIDs []uuid.UUID
|
|
if err := json.Unmarshal([]byte(deviceIDsJSON), &deviceIDs); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid device_ids JSON: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Parse updates JSON from form field
|
|
updatesJSON := c.PostForm("updates")
|
|
if updatesJSON == "" {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "updates is required")
|
|
return
|
|
}
|
|
|
|
var updates req.UpdateDeviceDTO
|
|
if err := json.Unmarshal([]byte(updatesJSON), &updates); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid updates JSON: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Parse image_indexes from form field
|
|
imageIndexesJSON := c.PostForm("image_indexes")
|
|
if imageIndexesJSON == "" {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "image_indexes is required")
|
|
return
|
|
}
|
|
|
|
var imageIndexes []int
|
|
if err := json.Unmarshal([]byte(imageIndexesJSON), &imageIndexes); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, "Invalid image_indexes JSON: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Get replace_images flag
|
|
replaceImages := c.PostForm("replace_images") == "true"
|
|
|
|
// Get all image files
|
|
form := c.Request.MultipartForm
|
|
imageFiles := form.File["images"]
|
|
|
|
// Build request
|
|
request := req.BulkUpdateDeviceDTO{
|
|
DeviceIDs: deviceIDs,
|
|
Updates: updates,
|
|
}
|
|
|
|
// Call usecase with images
|
|
result, err := dc.du.BulkUpdateDevicesWithImages(request, imageFiles, imageIndexes, replaceImages)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
message := fmt.Sprintf("Bulk update completed: %d successful, %d failed out of %d requested (with %d images)",
|
|
result.Successful, result.Failed, result.TotalRequested, len(imageFiles))
|
|
common.SingleResponses(c, message, result)
|
|
return
|
|
}
|
|
|
|
// Handle JSON request (no images)
|
|
var request req.BulkUpdateDeviceDTO
|
|
if err := c.ShouldBindJSON(&request); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
result, err := dc.du.BulkUpdateDevices(request)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
message := fmt.Sprintf("Bulk update completed: %d successful, %d failed out of %d requested",
|
|
result.Successful, result.Failed, result.TotalRequested)
|
|
common.SingleResponses(c, message, result)
|
|
}
|
|
}
|
|
|
|
// BulkDeleteDevices deletes multiple devices
|
|
func (dc *DeviceController) BulkDeleteDevices() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
var request req.BulkDeleteDeviceDTO
|
|
if err := c.ShouldBindJSON(&request); err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
result, err := dc.du.BulkDeleteDevices(request)
|
|
if err != nil {
|
|
common.ErrorResponses(c, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
message := fmt.Sprintf("Bulk delete completed: %d successful, %d failed out of %d requested",
|
|
result.Successful, result.Failed, result.TotalRequested)
|
|
common.SingleResponses(c, message, result)
|
|
}
|
|
}
|