edit responses api for better responses (backbone and devices)

delivery/controller/devices_controller.go

@@ -59,10 +59,22 @@ func (dc *DeviceController) CreateDevice() gin.HandlerFunc {
 
 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, err.Error())
+			common.ErrorResponses(c, http.StatusBadRequest, "something went wrong")
 			return
 		}
 
@@ -75,12 +87,12 @@ func (dc *DeviceController) GetDeviceByID() gin.HandlerFunc {
 		id := c.Param("uuid")
 		uuid, err := uuid.Parse(id)
 		if err != nil{
-			common.ErrorResponses(c, http.StatusBadGateway, err.Error())
+			common.ErrorResponses(c, http.StatusBadGateway,"Invalid UUID")
 			return
 		}
 		device, err := dc.du.GetByID(uuid)
 		if err != nil {
-			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
+			common.ErrorResponses(c, http.StatusBadRequest, "Device not found")
 			return
 		}
 
@@ -93,7 +105,7 @@ func (dc *DeviceController) UpdateDevice() gin.HandlerFunc {
 		id := c.Param("uuid")
 		uuid, err := uuid.Parse(id)
 		if err != nil {
-			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
+			common.ErrorResponses(c, http.StatusBadRequest, "Invalid UUID")
 			return
 		}
 
@@ -101,14 +113,14 @@ func (dc *DeviceController) UpdateDevice() gin.HandlerFunc {
 		err = c.ShouldBindJSON(&deviceDTO)
 
 		if err != nil {
-			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
+			common.ErrorResponses(c, http.StatusBadRequest, "Invalid request")
 			return
 		}
 
 		err = dc.du.UpdateDevice(uuid, deviceDTO)
 
 		if err != nil {
-			common.ErrorResponses(c, http.StatusBadRequest, err.Error())
+			common.ErrorResponses(c, http.StatusBadRequest, "Device not found")	
 			return
 		}
 

manager/usecase_manager.go

@@ -39,7 +39,7 @@ func (um *usecaseManager) NewDeviceUsecase() usecase.DeviceUseCase {
 }
 
 func (um *usecaseManager) NewBackboneUsecase() usecase.BackboneUseCase {
-	return usecase.NewBackboneUseCase(um.repo.NewBackboneRepository())
+	return usecase.NewBackboneUseCase(um.repo.NewBackboneRepository(),um.repo.NewFishboneRepository())
 }
 
 func (um *usecaseManager) NewFishboneUsecase() usecase.FishboneUseCase {

model/dto/res/backbone_res.go

@@ -0,0 +1,17 @@
+package res
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type BackboneResponse struct {
+	ID uuid.UUID `json:"id"`
+	DevStart string `json:"dev_start"`
+	DevEnd string `json:"dev_end"`
+	CoreAmount int `json:"core_amount"`
+	TotalFishbone int `json:"total_fishbone"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}

model/dto/res/deviceType_res.go

@@ -0,0 +1,9 @@
+package res
+
+import "github.com/google/uuid"
+
+type DeviceTypeResponse struct {
+	ID uuid.UUID `json:"id"`
+	DeviceType string `json:"device_type"`
+	DeviceCode string `json:"device_code"`
+}

repository/backbone_repo.go

@@ -11,7 +11,6 @@ type BackboneRepo interface {
 	Post(backbone entity.Backbone) error
 	GetAll() ([]entity.Backbone, error)
 	Update(id uuid.UUID, updates map[string]interface{}) error
-
 	GetByID(id uuid.UUID) (entity.Backbone, error)
 }
 
@@ -58,4 +57,4 @@ func (r *backboneRepo) GetByID(id uuid.UUID) (entity.Backbone, error) {
 		return backbone, err
 	}
 	return backbone, nil
-}
+}

repository/devices_repo.go

@@ -13,6 +13,7 @@ type DevicesRepo interface {
 	Update(id uuid.UUID,updates map[string]interface{}) error
 
 	GetByID(id uuid.UUID) (entity.Device, error)
+	GetByType(deviceType string) ([]entity.Device, error)
 }
 
 type devicesRepo struct {
@@ -57,3 +58,12 @@ func (r *devicesRepo) GetByID(id uuid.UUID) (entity.Device, error) {
 	}
 	return device, nil
 }
+
+func (r *devicesRepo) GetByType(deviceType string) ([]entity.Device, error) {
+	var devices []entity.Device
+	err := r.db.Where("device_type = ?", deviceType).Find(&devices).Error
+	if err != nil {
+		return devices, err
+	}
+	return devices, nil
+}

repository/fishbone_repo.go

@@ -13,6 +13,9 @@ type FishboneRepo interface {
 	Update(id uuid.UUID,updates map[string]interface{}) error
 
     GetByID(id uuid.UUID) (entity.Fishbone, error)
+    CountFishbone() (map[uuid.UUID]int, error)
+
+    CountFishboneByBackboneID(backboneID uuid.UUID) (int, error)
 }
 
 type fishboneRepo struct {
@@ -57,4 +60,37 @@ func (r *fishboneRepo) GetByID(id uuid.UUID) (entity.Fishbone, error) {
         return fishbone, err
     }
     return fishbone, nil
+}
+func (r *fishboneRepo) CountFishbone() (map[uuid.UUID]int, error) {
+	type Result struct {
+		BackboneID uuid.UUID `gorm:"column:bb_id"`
+		Count      int      `gorm:"column:count"`
+	}
+
+	var results []Result
+
+    err := r.db.Model(&entity.Fishbone{}).
+        Select("bb_id, count(*) as count").
+        Group("bb_id").
+        Scan(&results).Error
+
+	if err != nil {
+		return nil, err
+	}
+
+	countMap := make(map[uuid.UUID]int)
+	for _, result := range results {
+		countMap[result.BackboneID] = result.Count
+	}
+
+	return countMap, nil
+}
+
+func (r *fishboneRepo) CountFishboneByBackboneID(backboneID uuid.UUID) (int, error) {
+    var count int64
+    err := r.db.Model(&entity.Fishbone{}).Where("bb_id = ?", backboneID).Count(&count).Error
+    if err != nil {
+        return 0, err
+    }
+    return int(count), nil
 }

usecase/backbone_usecase.go

@@ -4,8 +4,10 @@ import (
 	"fmt"
 	"time"
 	"users_management/m/model/dto/req"
+	"users_management/m/model/dto/res"
 	"users_management/m/model/entity"
 	"users_management/m/repository"
+	"users_management/m/utils/helper"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/google/uuid"
@@ -13,20 +15,22 @@ import (
 
 type BackboneUseCase interface {
 	CreateBackbone(backbone req.BackboneDTO) error
-	GetAllBackbone() ([]entity.Backbone, error)
+	GetAllBackbone() ([]res.BackboneResponse, error)
 
-	GetByID(id uuid.UUID) (entity.Backbone, error)
+	GetByID(id uuid.UUID) (res.BackboneResponse, error)
 	UpdateBackbone(id uuid.UUID, backbone req.UpdateBackboneDTO) error
 }
 
 type backboneUseCase struct {
 	backboneRepo repository.BackboneRepo
+	fishboneRepo repository.FishboneRepo
 	validate *validator.Validate
 }
 
-func NewBackboneUseCase(backboneRepo repository.BackboneRepo) BackboneUseCase {
+func NewBackboneUseCase(backboneRepo repository.BackboneRepo, fishboneRepo repository.FishboneRepo) BackboneUseCase {
 	return &backboneUseCase{
 		backboneRepo: backboneRepo,
+		fishboneRepo: fishboneRepo,
 		validate: validator.New(),
 	}
 }
@@ -50,20 +54,43 @@ func (u *backboneUseCase) CreateBackbone(backbone req.BackboneDTO) error {
 	return u.backboneRepo.Post(newBackbone)
 }
 
-func (u *backboneUseCase) GetAllBackbone() ([]entity.Backbone, error) {
+func (u *backboneUseCase) GetAllBackbone() ([]res.BackboneResponse, error) {
 	backbones, err := u.backboneRepo.GetAll()
 	if err != nil {
-		return backbones, err
+		return nil, err
 	}
-	return backbones, nil
+	totalFishbone,err := u.fishboneRepo.CountFishbone()
+	if err != nil {
+		return nil, err
+	}
+
+	backboneResp, err := helper.ConvertToBackboneResponses(backbones,totalFishbone)
+
+	if err != nil {
+		return nil, err
+	}
+	return backboneResp, nil
 }
 
-func (u *backboneUseCase) GetByID(id uuid.UUID) (entity.Backbone, error) {
+func (u *backboneUseCase) GetByID(id uuid.UUID) (res.BackboneResponse, error) {
 	backbone, err := u.backboneRepo.GetByID(id)
 	if err != nil {
-		return backbone, err
+		return res.BackboneResponse{}, err
 	}
-	return backbone, nil
+
+	fishboneCount, err := u.fishboneRepo.CountFishboneByBackboneID(backbone.ID)
+
+	if err != nil {
+		return res.BackboneResponse{}, err
+	}
+
+	backboneResp, err := helper.ConvertToBackboneRespId(backbone,fishboneCount)
+
+	if err != nil {
+		return res.BackboneResponse{}, err
+	}
+	
+	return backboneResp, nil
 }
 
 func (u *backboneUseCase) UpdateBackbone(id uuid.UUID, backbone req.UpdateBackboneDTO) error {

usecase/device_usecase.go

@@ -4,8 +4,10 @@ import (
 	"fmt"
 	"time"
 	"users_management/m/model/dto/req"
+	"users_management/m/model/dto/res"
 	"users_management/m/model/entity"
 	"users_management/m/repository"
+	"users_management/m/utils/helper"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/google/uuid"
@@ -17,6 +19,7 @@ type DeviceUseCase interface {
 
 	GetByID(id uuid.UUID) (entity.Device, error)
 	UpdateDevice(id uuid.UUID, device req.UpdateDeviceDTO) error
+	GetByType(deviceType string) ([]res.DeviceTypeResponse, error)
 }
 
 type deviceUseCase struct {
@@ -99,4 +102,13 @@ func (u *deviceUseCase) UpdateDevice(id uuid.UUID, device req.UpdateDeviceDTO) e
 	updates["UpdatedAt"] = time.Now()
 
 	return u.deviceRepo.Update(id, updates)
+}
+
+func (u *deviceUseCase) GetByType(deviceType string) ([]res.DeviceTypeResponse, error) {
+	devices, err := u.deviceRepo.GetByType(deviceType)
+	if err != nil {
+		return nil, err
+	}
+	deviceTypeResponses := helper.ConvertToDeviceTypeResponse(devices)
+	return deviceTypeResponses, nil
 }

usecase/fishbone_usecase.go

@@ -94,3 +94,4 @@ func (u *fishboneUsecase) UpdateFishbone(id uuid.UUID, fishbone req.UpdateFishbo
 
 	return u.fishboneRepo.Update(id, updates)
 }
+

utils/helper/backboneHelperRes.go

@@ -0,0 +1,44 @@
+package helper
+
+import (
+	"users_management/m/model/dto/res"
+	"users_management/m/model/entity"
+
+	"github.com/google/uuid"
+)
+
+func ConvertToBackboneResponses(backbone []entity.Backbone, totalFishbone map[uuid.UUID]int) ([]res.BackboneResponse, error) {
+	var responses []res.BackboneResponse
+	for _, backbone := range backbone {
+		count := 0
+		if fishboneCount, exist := totalFishbone[backbone.ID]; exist {
+			count = fishboneCount
+		}
+		backboneResp := res.BackboneResponse {
+			ID: backbone.ID,
+			DevStart: backbone.DeviceStart.DeviceCode,
+			DevEnd: backbone.DeviceEnd.DeviceCode,
+			CoreAmount: backbone.CoreAmount,
+			TotalFishbone: count,
+			CreatedAt: backbone.CreatedAt,
+			UpdatedAt: backbone.UpdatedAt,
+		}
+		responses = append(responses, backboneResp)
+	}
+
+	return responses, nil
+}
+
+func ConvertToBackboneRespId(backbone entity.Backbone, fishboneCount int) (res.BackboneResponse, error) {
+    backboneResp := res.BackboneResponse {
+        ID: backbone.ID,
+        DevStart: backbone.DeviceStart.DeviceCode,
+        DevEnd: backbone.DeviceEnd.DeviceCode,
+        CoreAmount: backbone.CoreAmount,
+        TotalFishbone: fishboneCount, 
+        CreatedAt: backbone.CreatedAt,
+        UpdatedAt: backbone.UpdatedAt,
+    }
+
+    return backboneResp, nil
+}

utils/helper/deviceHelperRes.go

@@ -0,0 +1,20 @@
+package helper
+
+import (
+	"users_management/m/model/dto/res"
+	"users_management/m/model/entity"
+)
+
+func ConvertToDeviceTypeResponse(devices []entity.Device) []res.DeviceTypeResponse {
+	var responses []res.DeviceTypeResponse
+	for _, devices := range devices {
+		deviceResp := res.DeviceTypeResponse{
+			ID: 	   devices.ID,
+			DeviceType: string(devices.DeviceType),
+			DeviceCode: devices.DeviceCode,
+		}
+		responses = append(responses, deviceResp)
+	}
+
+	return responses
+}