fix: fixing domain area and fix get method for all endpoint

config/connection.go

@@ -63,8 +63,8 @@ func InitDatabase() {
 		&domain.TrashDetail{},
 		&domain.Banner{},
 		&domain.CoverageArea{},
-		&domain.CoverageDetail{},
+		&domain.CoverageDistric{},
-		&domain.LocationSpecific{},
+		&domain.CoverageSubdistrict{},
 	)
 	if err != nil {
 		log.Fatal("Error: Failed to auto migrate domain:", err)

domain/coveragearea.go

@@ -3,26 +3,27 @@ package domain
 import "time"
 
 type CoverageArea struct {
-	ID        string           `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
+	ID        string    `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
-	Province  string           `gorm:"not null" json:"province"`
+	Province  string    `gorm:"not null" json:"province"`
-	CreatedAt time.Time        `gorm:"default:current_timestamp" json:"createdAt"`
+	CreatedAt time.Time `gorm:"default:current_timestamp" json:"createdAt"`
-	UpdatedAt time.Time        `gorm:"default:current_timestamp" json:"updatedAt"`
+	UpdatedAt time.Time `gorm:"default:current_timestamp" json:"updatedAt"`
-	Details   []CoverageDetail `gorm:"foreignKey:CoverageAreaID;constraint:OnDelete:CASCADE;OnUpdate:CASCADE;" json:"coverage_area"`
+	CoverageDistrics []CoverageDistric `gorm:"foreignKey:CoverageAreaID" json:"coverage_districs"`
 }
 
-type CoverageDetail struct {
+type CoverageDistric struct {
-	ID               string             `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
+	ID             string    `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
-	CoverageAreaID   string             `gorm:"not null;constraint:OnDelete:CASCADE;OnUpdate:CASCADE;" json:"coverage_area_id"`
+	CoverageAreaID string    `gorm:"not null;constraint:OnDelete:CASCADE;OnUpdate:CASCADE;" json:"coverage_area_id"`
-	District         string             `gorm:"not null" json:"district"`
+	District       string    `gorm:"not null" json:"district"`
-	LocationSpecific []LocationSpecific `gorm:"foreignKey:CoverageDetailID;constraint:OnDelete:CASCADE;OnUpdate:CASCADE;" json:"location_specific"`
+	CreatedAt      time.Time `gorm:"default:current_timestamp" json:"createdAt"`
-	CreatedAt        time.Time          `gorm:"default:current_timestamp" json:"createdAt"`
+	UpdatedAt      time.Time `gorm:"default:current_timestamp" json:"updatedAt"`
-	UpdatedAt        time.Time          `gorm:"default:current_timestamp" json:"updatedAt"`
+	CoverageSubdistricts []CoverageSubdistrict `gorm:"foreignKey:CoverageDistrictId" json:"subdistricts"`
 }
 
-type LocationSpecific struct {
+type CoverageSubdistrict struct {
-	ID               string    `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
+	ID                 string    `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
-	CoverageDetailID string    `gorm:"not null;constraint:OnDelete:CASCADE;OnUpdate:CASCADE;" json:"coverage_detail_id"`
+	CoverageAreaID     string    `gorm:"not null" json:"coverage_area_id"`
-	Subdistrict      string    `gorm:"not null" json:"subdistrict"`
+	CoverageDistrictId string    `gorm:"not null;constraint:OnDelete:CASCADE;OnUpdate:CASCADE;" json:"coverage_district_id"`
-	CreatedAt        time.Time `gorm:"default:current_timestamp" json:"createdAt"`
+	Subdistrict        string    `gorm:"not null" json:"subdistrict"`
-	UpdatedAt        time.Time `gorm:"default:current_timestamp" json:"updatedAt"`
+	CreatedAt          time.Time `gorm:"default:current_timestamp" json:"createdAt"`
+	UpdatedAt          time.Time `gorm:"default:current_timestamp" json:"updatedAt"`
 }

dto/coveragearea.go

@@ -1,88 +1,71 @@
 package dto
 
 type CoverageAreaResponse struct {
-	ID       string `json:"id"`
+	ID        string `json:"id"`
-	Province string `json:"province"`
+	Province  string `json:"province"`
+	CreatedAt string `json:"createdAt"`
+	UpdatedAt string `json:"updatedAt"`
 }
 
 type CoverageAreaWithDistrictsResponse struct {
 	ID           string                 `json:"id"`
 	Province     string                 `json:"province"`
+	CreatedAt    string                 `json:"createdAt"`
+	UpdatedAt    string                 `json:"updatedAt"`
 	CoverageArea []CoverageAreaResponse `json:"coverage_area"`
 }
 
 type CoverageAreaDetailWithLocation struct {
-	ID               string                     `json:"id"`
+	ID          string                `json:"id"`
-	Province         string                     `json:"province"`
+	Province    string                `json:"province"`
-	District         string                     `json:"district"`
+	District    string                `json:"district"`
-	LocationSpecific []LocationSpecificResponse `json:"location_specific"`
+	CreatedAt   string                `json:"createdAt"`
+	UpdatedAt   string                `json:"updatedAt"`
+	Subdistrict []SubdistrictResponse `json:"subdistrict"`
 }
 
-type LocationSpecificResponse struct {
+type SubdistrictResponse struct {
 	ID          string `json:"id"`
 	Subdistrict string `json:"subdistrict"`
+	CreatedAt   string `json:"createdAt"`
+	UpdatedAt   string `json:"updatedAt"`
 }
 
-type CoverageDetailResponse struct {
+func NewCoverageAreaResponse(id, province, createdAt, updatedAt string) CoverageAreaResponse {
-	ID        string `json:"id"`
+	return CoverageAreaResponse{
-	Province  string `json:"province"`
-	District  string `json:"district"`
-	CreatedAt string `json:"createdAt"`
-	UpdatedAt string `json:"updatedAt"`
-}
-
-func NewCoverageDetailResponse(id, province, district, createdAt, updatedAt string) CoverageDetailResponse {
-	return CoverageDetailResponse{
 		ID:        id,
 		Province:  province,
-		District:  district,
 		CreatedAt: createdAt,
 		UpdatedAt: updatedAt,
 	}
 }
 
-func NewCoverageAreaResponse(id, province string) CoverageAreaResponse {
+func NewCoverageAreaWithDistrictsResponse(id, province, createdAt, updatedAt string, coverageArea []CoverageAreaResponse) CoverageAreaWithDistrictsResponse {
-	return CoverageAreaResponse{
-		ID:       id,
-		Province: province,
-	}
-}
-
-func NewLocationSpecificResponse(id, subdistrict string) LocationSpecificResponse {
-	return LocationSpecificResponse{
-		ID:          id,
-		Subdistrict: subdistrict,
-	}
-}
-
-func NewCoverageAreaWithDistrictsResponse(id, province string, coverageArea []CoverageAreaResponse) CoverageAreaWithDistrictsResponse {
 	return CoverageAreaWithDistrictsResponse{
 		ID:           id,
 		Province:     province,
+		CreatedAt:    createdAt,
+		UpdatedAt:    updatedAt,
 		CoverageArea: coverageArea,
 	}
 }
 
-func NewCoverageAreaDetailWithLocation(id, province, district string, locationSpecific []LocationSpecificResponse) CoverageAreaDetailWithLocation {
+func NewCoverageAreaDetailWithLocation(id, province, district, createdAt, updatedAt string, subdistricts []SubdistrictResponse) CoverageAreaDetailWithLocation {
 	return CoverageAreaDetailWithLocation{
-		ID:               id,
+		ID:          id,
-		Province:         province,
+		Province:    province,
-		District:         district,
+		District:    district,
-		LocationSpecific: locationSpecific,
+		CreatedAt:   createdAt,
+		UpdatedAt:   updatedAt,
+		Subdistrict: subdistricts,
 	}
 }
 
-type CoverageAreaRequest struct {
+func NewSubdistrictResponse(id, subdistrict, createdAt, updatedAt string) SubdistrictResponse {
-	Province string `json:"province" validate:"required"`
+	return SubdistrictResponse{
+		ID:          id,
+		Subdistrict: subdistrict,
+		CreatedAt:   createdAt,
+		UpdatedAt:   updatedAt,
+	}
 }
-
-type CoverageDetailRequest struct {
-	CoverageAreaID string `json:"coverage_area_id" validate:"required"`
-	Province       string `json:"province" validate:"required"`
-	District       string `json:"district" validate:"required"`
-}
-
-type LocationSpecificRequest struct {
-	CoverageDetailID string `json:"coverage_detail_id" validate:"required"`
-	Subdistrict      string `json:"subdistrict" validate:"required"`
-}

internal/api/routes.go

@@ -24,9 +24,9 @@ func AppRouter(app *fiber.App) {
 	api.Get("/coverage-areas", controllers.GetCoverageAreas)
 	api.Get("/coverage-areas-district/:id", controllers.GetCoverageAreaByIDProvince)
 	api.Get("/coverage-areas-subdistrict/:id", controllers.GetCoverageAreaByIDDistrict)
-	api.Post("/coverage-areas", controllers.CreateCoverageArea)
+	// api.Post("/coverage-areas", controllers.CreateCoverageArea)
-	api.Post("/coverage-areas-district", controllers.CreateCoverageDetail)
+	// api.Post("/coverage-areas-district", controllers.CreateCoverageDetail)
-	api.Post("/coverage-areas-subdistrict", controllers.CreateLocationSpecific)
+	// api.Post("/coverage-areas-subdistrict", controllers.CreateLocationSpecific)
 
 	// # role
 	api.Get("/roles", controllers.GetAllUserRoles)

internal/controllers/coveragearea.go

@@ -19,7 +19,12 @@ func GetCoverageAreas(c *fiber.Ctx) error {
 
 	var coverageAreaResponses []dto.CoverageAreaResponse
 	for _, area := range coverageAreas {
-		coverageAreaResponses = append(coverageAreaResponses, dto.NewCoverageAreaResponse(area.ID, area.Province))
+		coverageAreaResponses = append(coverageAreaResponses, dto.NewCoverageAreaResponse(
+			area.ID,
+			area.Province,
+			utils.FormatDateToIndonesianFormat(area.CreatedAt),
+			utils.FormatDateToIndonesianFormat(area.UpdatedAt),
+		))
 	}
 
 	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
@@ -44,10 +49,26 @@ func GetCoverageAreaByIDProvince(c *fiber.Ctx) error {
 	var coverageAreaResponse dto.CoverageAreaWithDistrictsResponse
 	coverageAreaResponse.ID = coverageArea.ID
 	coverageAreaResponse.Province = coverageArea.Province
+	coverageAreaResponse.CreatedAt = utils.FormatDateToIndonesianFormat(coverageArea.CreatedAt)
+	coverageAreaResponse.UpdatedAt = utils.FormatDateToIndonesianFormat(coverageArea.UpdatedAt)
+
+	districts, err := services.GetCoverageDistricsByCoverageAreaID(coverageArea.ID)
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to fetch coverage districts",
+			nil,
+		))
+	}
 
 	var coverageAreas []dto.CoverageAreaResponse
-	for _, detail := range coverageArea.Details {
+	for _, district := range districts {
-		coverageAreas = append(coverageAreas, dto.NewCoverageAreaResponse(detail.ID, detail.District))
+		coverageAreas = append(coverageAreas, dto.NewCoverageAreaResponse(
+			district.ID,
+			district.District,
+			utils.FormatDateToIndonesianFormat(district.CreatedAt),
+			utils.FormatDateToIndonesianFormat(district.UpdatedAt),
+		))
 	}
 
 	coverageAreaResponse.CoverageArea = coverageAreas
@@ -71,98 +92,46 @@ func GetCoverageAreaByIDDistrict(c *fiber.Ctx) error {
 		))
 	}
 
-	var locationSpecificResponses []dto.LocationSpecificResponse
+	coverageArea, err := services.GetCoverageAreaByID(coverageDetail.CoverageAreaID)
-	for _, loc := range coverageDetail.LocationSpecific {
+	if err != nil {
-		locationSpecificResponses = append(locationSpecificResponses, dto.NewLocationSpecificResponse(loc.ID, loc.Subdistrict))
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to fetch coverage area details by province",
+			nil,
+		))
 	}
 
-	coverageAreaResponse := dto.CoverageAreaDetailWithLocation{
+	subdistricts, err := services.GetSubdistrictsByCoverageDistrictID(coverageDetail.ID)
-		ID:               coverageDetail.ID,
+	if err != nil {
-		District:         coverageDetail.District,
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
-		LocationSpecific: locationSpecificResponses,
+			fiber.StatusInternalServerError,
+			"Failed to fetch subdistricts",
+			nil,
+		))
 	}
 
+	var subdistrictResponses []dto.SubdistrictResponse
+	for _, loc := range subdistricts {
+		subdistrictResponses = append(subdistrictResponses, dto.NewSubdistrictResponse(
+			loc.ID,
+			loc.Subdistrict,
+			utils.FormatDateToIndonesianFormat(loc.CreatedAt),
+			utils.FormatDateToIndonesianFormat(loc.UpdatedAt),
+		))
+	}
+
+	coverageAreaResponse := dto.NewCoverageAreaDetailWithLocation(
+		coverageDetail.ID,
+		coverageArea.Province,
+		coverageDetail.District,
+		utils.FormatDateToIndonesianFormat(coverageDetail.CreatedAt),
+		utils.FormatDateToIndonesianFormat(coverageDetail.UpdatedAt),
+		subdistrictResponses,
+	)
+
 	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
 		fiber.StatusOK,
 		"Coverage areas detail by district has been fetched",
 		coverageAreaResponse,
 	))
 }
-
-func CreateCoverageArea(c *fiber.Ctx) error {
-	var request dto.CoverageAreaRequest
-	if err := c.BodyParser(&request); err != nil {
-		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
-			fiber.StatusBadRequest,
-			"Invalid input data",
-			nil,
-		))
-	}
-
-	coverageArea, err := services.CreateCoverageArea(request.Province)
-	if err != nil {
-		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
-			fiber.StatusInternalServerError,
-			"Failed to create coverage area",
-			nil,
-		))
-	}
-
-	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
-		fiber.StatusOK,
-		"Coverage area has been created successfully",
-		coverageArea,
-	))
-}
-
-func CreateCoverageDetail(c *fiber.Ctx) error {
-	var request dto.CoverageDetailRequest
-	if err := c.BodyParser(&request); err != nil {
-		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
-			fiber.StatusBadRequest,
-			"Invalid input data",
-			nil,
-		))
-	}
-
-	coverageDetail, err := services.CreateCoverageDetail(request.CoverageAreaID, request.Province, request.District)
-	if err != nil {
-		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
-			fiber.StatusInternalServerError,
-			"Failed to create coverage detail",
-			nil,
-		))
-	}
-
-	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
-		fiber.StatusOK,
-		"Coverage detail has been created successfully",
-		coverageDetail,
-	))
-}
-
-func CreateLocationSpecific(c *fiber.Ctx) error {
-	var request dto.LocationSpecificRequest
-	if err := c.BodyParser(&request); err != nil {
-		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
-			fiber.StatusBadRequest,
-			"Invalid input data",
-			nil,
-		))
-	}
-
-	locationSpecific, err := services.CreateLocationSpecific(request.CoverageDetailID, request.Subdistrict)
-	if err != nil {
-		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
-			fiber.StatusInternalServerError,
-			"Failed to create location specific",
-			nil,
-		))
-	}
-
-	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
-		fiber.StatusOK,
-		"Location specific has been created successfully",
-		locationSpecific,
-	))
-}

internal/repositories/coveragearea.go

@@ -1,70 +1,46 @@
 package repositories
 
 import (
-	"errors"
-
 	"github.com/pahmiudahgede/senggoldong/config"
 	"github.com/pahmiudahgede/senggoldong/domain"
 )
 
 func GetCoverageAreas() ([]domain.CoverageArea, error) {
 	var coverageAreas []domain.CoverageArea
-	if err := config.DB.Preload("Details").Find(&coverageAreas).Error; err != nil {
+	if err := config.DB.Find(&coverageAreas).Error; err != nil {
 		return nil, err
 	}
 	return coverageAreas, nil
 }
 
+func GetCoverageDistricsByCoverageAreaID(areaID string) ([]domain.CoverageDistric, error) {
+	var districts []domain.CoverageDistric
+	if err := config.DB.Where("coverage_area_id = ?", areaID).Find(&districts).Error; err != nil {
+		return nil, err
+	}
+	return districts, nil
+}
+
+func GetCoverageAreaByDistrictID(id string) (domain.CoverageDistric, error) {
+	var coverageDistric domain.CoverageDistric
+	if err := config.DB.Where("id = ?", id).First(&coverageDistric).Error; err != nil {
+		return coverageDistric, err
+	}
+	return coverageDistric, nil
+}
+
 func GetCoverageAreaByID(id string) (domain.CoverageArea, error) {
 	var coverageArea domain.CoverageArea
-	if err := config.DB.Preload("Details").Where("id = ?", id).First(&coverageArea).Error; err != nil {
+	if err := config.DB.Where("id = ?", id).First(&coverageArea).Error; err != nil {
-		return coverageArea, errors.New("coverage area not found")
+		return coverageArea, err
 	}
 	return coverageArea, nil
 }
 
-func GetCoverageAreaByDistrictID(id string) (domain.CoverageDetail, error) {
+func GetSubdistrictsByCoverageDistrictID(districtID string) ([]domain.CoverageSubdistrict, error) {
-	var coverageDetail domain.CoverageDetail
+	var subdistricts []domain.CoverageSubdistrict
-	if err := config.DB.Preload("LocationSpecific").Where("id = ?", id).First(&coverageDetail).Error; err != nil {
+	if err := config.DB.Where("coverage_district_id = ?", districtID).Find(&subdistricts).Error; err != nil {
-		return coverageDetail, err
+		return nil, err
 	}
-	return coverageDetail, nil
+	return subdistricts, nil
-}
-
-func CreateCoverageArea(province string) (domain.CoverageArea, error) {
-	coverageArea := domain.CoverageArea{
-		Province: province,
-	}
-
-	if err := config.DB.Create(&coverageArea).Error; err != nil {
-		return domain.CoverageArea{}, err
-	}
-
-	return coverageArea, nil
-}
-
-func CreateCoverageDetail(coverageAreaID, province, district string) (domain.CoverageDetail, error) {
-	coverageDetail := domain.CoverageDetail{
-		CoverageAreaID: coverageAreaID,
-		District: district,
-	}
-
-	if err := config.DB.Create(&coverageDetail).Error; err != nil {
-		return domain.CoverageDetail{}, err
-	}
-
-	return coverageDetail, nil
-}
-
-func CreateLocationSpecific(coverageDetailID, subdistrict string) (domain.LocationSpecific, error) {
-	locationSpecific := domain.LocationSpecific{
-		CoverageDetailID: coverageDetailID,
-		Subdistrict:      subdistrict,
-	}
-
-	if err := config.DB.Create(&locationSpecific).Error; err != nil {
-		return domain.LocationSpecific{}, err
-	}
-
-	return locationSpecific, nil
 }

internal/services/coveragearea.go

@@ -9,22 +9,18 @@ func GetCoverageAreas() ([]domain.CoverageArea, error) {
 	return repositories.GetCoverageAreas()
 }
 
+func GetCoverageDistricsByCoverageAreaID(areaID string) ([]domain.CoverageDistric, error) {
+	return repositories.GetCoverageDistricsByCoverageAreaID(areaID)
+}
+
+func GetCoverageAreaByDistrictID(id string) (domain.CoverageDistric, error) {
+	return repositories.GetCoverageAreaByDistrictID(id)
+}
+
 func GetCoverageAreaByID(id string) (domain.CoverageArea, error) {
 	return repositories.GetCoverageAreaByID(id)
 }
 
-func GetCoverageAreaByDistrictID(id string) (domain.CoverageDetail, error) {
+func GetSubdistrictsByCoverageDistrictID(districtID string) ([]domain.CoverageSubdistrict, error) {
-	return repositories.GetCoverageAreaByDistrictID(id)
+	return repositories.GetSubdistrictsByCoverageDistrictID(districtID)
 }
-
-func CreateCoverageArea(province string) (domain.CoverageArea, error) {
-	return repositories.CreateCoverageArea(province)
-}
-
-func CreateCoverageDetail(coverageAreaID, province, district string) (domain.CoverageDetail, error) {
-	return repositories.CreateCoverageDetail(coverageAreaID, province, district)
-}
-
-func CreateLocationSpecific(coverageDetailID, subdistrict string) (domain.LocationSpecific, error) {
-	return repositories.CreateLocationSpecific(coverageDetailID, subdistrict)
-}