feat: add delete and update method in areas domain

dto/coveragearea.go

@@ -104,4 +104,16 @@ func NewCoverageSubdistrictCreateRequest(coverageAreaID, coverageDistrictId, sub
 		CoverageDistrictId: coverageDistrictId,
 		Subdistrict:        subdistrict,
 	}
+}
+
+type CoverageAreaUpdateRequest struct {
+	Province string `json:"province" validate:"required"`
+}
+
+type CoverageDistrictUpdateRequest struct {
+	District string `json:"district" validate:"required"`
+}
+
+type CoverageSubdistrictUpdateRequest struct {
+	Subdistrict string `json:"subdistrict" validate:"required"`
 }

internal/api/routes.go

@@ -7,62 +7,68 @@ import (
 )
 
 func AppRouter(app *fiber.App) {
-	// # api group domain endpoint
+	// # api group domain endpoint #
 	api := app.Group("/apirijikid")
 
-	// # API Secure
+	// # API Secure #
 	api.Use(middleware.APIKeyMiddleware)
 
-	// # user initial coint
+	// # user initial coint #
 	api.Get("/user/initial-coint", controllers.GetUserInitialCoint)
 	api.Get("/user/initial-coint/:id", controllers.GetUserInitialCointById)
 	api.Post("/user/initial-coint", controllers.CreatePoint)
 	api.Put("/user/initial-coint/:id", controllers.UpdatePoint)
 	api.Delete("/user/initial-coint/:id", controllers.DeletePoint)
 
-	//# coverage area
+	//# coverage area #
 	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-district", controllers.CreateCoverageDistrict)
 	api.Post("/coverage-areas-subdistrict", controllers.CreateCoverageSubdistrict)
+	api.Put("/coverage-areas/:id", controllers.UpdateCoverageArea)
+	api.Put("/coverage-areas-district/:id", controllers.UpdateCoverageDistrict)
+	api.Put("/coverage-areas-subdistrict/:id", controllers.UpdateCoverageSubdistrict)
+	api.Delete("/coverage-areas/:id", controllers.DeleteCoverageArea)
+	api.Delete("/coverage-areas-district/:id", controllers.DeleteCoverageDistrict)
+	api.Delete("/coverage-areas-subdistrict/:id", controllers.DeleteCoverageSubdistrict)
 
-	// # role
+	// # role #
 	api.Get("/roles", controllers.GetAllUserRoles)
 	api.Get("/role/:id", controllers.GetUserRoleByID)
 
-	// # authentication
+	// # authentication #
 	api.Post("/register", controllers.Register)
 	api.Post("/login", controllers.Login)
 
-	// # userinfo
+	// # userinfo #
 	api.Get("/user", middleware.AuthMiddleware, controllers.GetUserInfo)
 	api.Post("/user/update-password", middleware.AuthMiddleware, controllers.UpdatePassword)
 	api.Put("/user/update-user", middleware.AuthMiddleware, controllers.UpdateUser)
 
-	// # user set pin
+	// # user set pin #
 	api.Get("/user/verif-pin", middleware.AuthMiddleware, controllers.GetPin)
 	api.Get("/user/cek-pin-status", middleware.AuthMiddleware, controllers.GetPinStatus)
 	api.Post("/user/set-pin", middleware.AuthMiddleware, controllers.CreatePin)
 	api.Put("/user/update-pin", middleware.AuthMiddleware, controllers.UpdatePin)
 	api.Put("/user/update-pin", middleware.AuthMiddleware, controllers.UpdatePin)
 
-	// # address routing
+	// # address routing #
 	api.Get("/addresses", middleware.AuthMiddleware, controllers.GetListAddress)
 	api.Get("/address/:id", middleware.AuthMiddleware, controllers.GetAddressByID)
 	api.Post("/address/create-address", middleware.AuthMiddleware, controllers.CreateAddress)
 	api.Put("/address/update-address/:id", middleware.AuthMiddleware, controllers.UpdateAddress)
 	api.Delete("/address/delete-address/:id", middleware.AuthMiddleware, controllers.DeleteAddress)
 
-	// # article
+	// # article #
 	api.Get("/articles", middleware.AuthMiddleware, controllers.GetArticles)
 	api.Get("/article/:id", middleware.AuthMiddleware, controllers.GetArticleByID)
 	api.Post("/article/create-article", middleware.AuthMiddleware, controllers.CreateArticle)
 	api.Put("/article/update-article/:id", middleware.AuthMiddleware, controllers.UpdateArticle)
 	api.Delete("/article/delete-article/:id", middleware.AuthMiddleware, controllers.DeleteArticle)
 
-	// # trash type
+	// # trash type #
 	api.Get("/trash-categorys", controllers.GetTrashCategories)
 	api.Get("/trash-category/:id", controllers.GetTrashCategoryDetail)
 	api.Post("/trash-category/create-trash-category", controllers.CreateTrashCategory)
@@ -72,7 +78,7 @@ func AppRouter(app *fiber.App) {
 	api.Delete("/trash-category/delete-trash-category/:id", controllers.DeleteTrashCategory)
 	api.Delete("/trash-category/delete-trash-detail/:id", controllers.DeleteTrashDetail)
 
-	// # banner
+	// # banner #
 	api.Get("/banners", controllers.GetBanners)
 	api.Get("/banner/:id", controllers.GetBannerByID)
 	api.Post("/banner/create-banner", controllers.CreateBanner)

internal/controllers/coveragearea.go

@@ -2,6 +2,7 @@ package controllers
 
 import (
 	"github.com/gofiber/fiber/v2"
+	"github.com/pahmiudahgede/senggoldong/domain"
 	"github.com/pahmiudahgede/senggoldong/dto"
 	"github.com/pahmiudahgede/senggoldong/internal/services"
 	"github.com/pahmiudahgede/senggoldong/utils"
@@ -241,3 +242,168 @@ func CreateCoverageSubdistrict(c *fiber.Ctx) error {
 		coverageSubdistrictResponse,
 	))
 }
+
+func UpdateCoverageArea(c *fiber.Ctx) error {
+	id := c.Params("id")
+
+	var request dto.CoverageAreaUpdateRequest
+	if err := c.BodyParser(&request); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
+			fiber.StatusBadRequest,
+			"Invalid request payload",
+			nil,
+		))
+	}
+
+	coverageArea, err := services.UpdateCoverageArea(id, domain.CoverageArea{
+		Province: request.Province,
+	})
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to update coverage area",
+			nil,
+		))
+	}
+
+	coverageAreaResponse := dto.NewCoverageAreaResponse(
+		coverageArea.ID,
+		coverageArea.Province,
+		utils.FormatDateToIndonesianFormat(coverageArea.CreatedAt),
+		utils.FormatDateToIndonesianFormat(coverageArea.UpdatedAt),
+	)
+
+	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
+		fiber.StatusOK,
+		"Coverage area has been updated",
+		coverageAreaResponse,
+	))
+}
+
+func UpdateCoverageDistrict(c *fiber.Ctx) error {
+	id := c.Params("id")
+
+	var request dto.CoverageDistrictUpdateRequest
+	if err := c.BodyParser(&request); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
+			fiber.StatusBadRequest,
+			"Invalid request payload",
+			nil,
+		))
+	}
+
+	coverageDistrict, err := services.UpdateCoverageDistrict(id, domain.CoverageDistric{
+		District: request.District,
+	})
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to update coverage district",
+			nil,
+		))
+	}
+
+	coverageDistrictResponse := dto.NewCoverageAreaResponse(
+		coverageDistrict.ID,
+		coverageDistrict.District,
+		utils.FormatDateToIndonesianFormat(coverageDistrict.CreatedAt),
+		utils.FormatDateToIndonesianFormat(coverageDistrict.UpdatedAt),
+	)
+
+	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
+		fiber.StatusOK,
+		"Coverage district has been updated",
+		coverageDistrictResponse,
+	))
+}
+
+func UpdateCoverageSubdistrict(c *fiber.Ctx) error {
+	id := c.Params("id")
+
+	var request dto.CoverageSubdistrictUpdateRequest
+	if err := c.BodyParser(&request); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
+			fiber.StatusBadRequest,
+			"Invalid request payload",
+			nil,
+		))
+	}
+
+	coverageSubdistrict, err := services.UpdateCoverageSubdistrict(id, domain.CoverageSubdistrict{
+		Subdistrict: request.Subdistrict,
+	})
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to update coverage subdistrict",
+			nil,
+		))
+	}
+
+	coverageSubdistrictResponse := dto.NewSubdistrictResponse(
+		coverageSubdistrict.ID,
+		coverageSubdistrict.Subdistrict,
+		utils.FormatDateToIndonesianFormat(coverageSubdistrict.CreatedAt),
+		utils.FormatDateToIndonesianFormat(coverageSubdistrict.UpdatedAt),
+	)
+
+	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
+		fiber.StatusOK,
+		"Coverage subdistrict has been updated",
+		coverageSubdistrictResponse,
+	))
+}
+
+func DeleteCoverageArea(c *fiber.Ctx) error {
+	id := c.Params("id")
+
+	if err := services.DeleteCoverageArea(id); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to delete coverage area",
+			nil,
+		))
+	}
+
+	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
+		fiber.StatusOK,
+		"Coverage area has been deleted",
+		nil,
+	))
+}
+
+func DeleteCoverageDistrict(c *fiber.Ctx) error {
+	id := c.Params("id")
+
+	if err := services.DeleteCoverageDistrict(id); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to delete coverage district",
+			nil,
+		))
+	}
+
+	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
+		fiber.StatusOK,
+		"Coverage district has been deleted",
+		nil,
+	))
+}
+
+func DeleteCoverageSubdistrict(c *fiber.Ctx) error {
+	id := c.Params("id")
+
+	if err := services.DeleteCoverageSubdistrict(id); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to delete coverage subdistrict",
+			nil,
+		))
+	}
+
+	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
+		fiber.StatusOK,
+		"Coverage subdistrict has been deleted",
+		nil,
+	))
+}

internal/repositories/coveragearea.go

@@ -64,4 +64,85 @@ func CreateCoverageSubdistrict(coverageSubdistrict *domain.CoverageSubdistrict)
 		return err
 	}
 	return nil
-}
+}
+
+func UpdateCoverageArea(id string, coverageArea domain.CoverageArea) (domain.CoverageArea, error) {
+	var existingCoverageArea domain.CoverageArea
+	if err := config.DB.Where("id = ?", id).First(&existingCoverageArea).Error; err != nil {
+		return existingCoverageArea, err
+	}
+
+	existingCoverageArea.Province = coverageArea.Province
+	if err := config.DB.Save(&existingCoverageArea).Error; err != nil {
+		return existingCoverageArea, err
+	}
+
+	return existingCoverageArea, nil
+}
+
+func UpdateCoverageDistrict(id string, coverageDistrict domain.CoverageDistric) (domain.CoverageDistric, error) {
+	var existingCoverageDistrict domain.CoverageDistric
+	if err := config.DB.Where("id = ?", id).First(&existingCoverageDistrict).Error; err != nil {
+		return existingCoverageDistrict, err
+	}
+
+	existingCoverageDistrict.District = coverageDistrict.District
+	if err := config.DB.Save(&existingCoverageDistrict).Error; err != nil {
+		return existingCoverageDistrict, err
+	}
+
+	return existingCoverageDistrict, nil
+}
+
+func UpdateCoverageSubdistrict(id string, coverageSubdistrict domain.CoverageSubdistrict) (domain.CoverageSubdistrict, error) {
+	var existingCoverageSubdistrict domain.CoverageSubdistrict
+	if err := config.DB.Where("id = ?", id).First(&existingCoverageSubdistrict).Error; err != nil {
+		return existingCoverageSubdistrict, err
+	}
+
+	existingCoverageSubdistrict.Subdistrict = coverageSubdistrict.Subdistrict
+	if err := config.DB.Save(&existingCoverageSubdistrict).Error; err != nil {
+		return existingCoverageSubdistrict, err
+	}
+
+	return existingCoverageSubdistrict, nil
+}
+
+func DeleteCoverageArea(id string) error {
+	var coverageArea domain.CoverageArea
+	if err := config.DB.Where("id = ?", id).First(&coverageArea).Error; err != nil {
+		return err
+	}
+
+	if err := config.DB.Delete(&coverageArea).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteCoverageDistrict(id string) error {
+	var coverageDistrict domain.CoverageDistric
+	if err := config.DB.Where("id = ?", id).First(&coverageDistrict).Error; err != nil {
+		return err
+	}
+
+	if err := config.DB.Delete(&coverageDistrict).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DeleteCoverageSubdistrict(id string) error {
+	var coverageSubdistrict domain.CoverageSubdistrict
+	if err := config.DB.Where("id = ?", id).First(&coverageSubdistrict).Error; err != nil {
+		return err
+	}
+
+	if err := config.DB.Delete(&coverageSubdistrict).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

internal/services/coveragearea.go

@@ -62,4 +62,28 @@ func CreateCoverageSubdistrict(coverageAreaID, coverageDistrictId, subdistrict s
 	}
 
 	return coverageSubdistrict, nil
+}
+
+func UpdateCoverageArea(id string, request domain.CoverageArea) (domain.CoverageArea, error) {
+	return repositories.UpdateCoverageArea(id, request)
+}
+
+func UpdateCoverageDistrict(id string, request domain.CoverageDistric) (domain.CoverageDistric, error) {
+	return repositories.UpdateCoverageDistrict(id, request)
+}
+
+func UpdateCoverageSubdistrict(id string, request domain.CoverageSubdistrict) (domain.CoverageSubdistrict, error) {
+	return repositories.UpdateCoverageSubdistrict(id, request)
+}
+
+func DeleteCoverageArea(id string) error {
+	return repositories.DeleteCoverageArea(id)
+}
+
+func DeleteCoverageDistrict(id string) error {
+	return repositories.DeleteCoverageDistrict(id)
+}
+
+func DeleteCoverageSubdistrict(id string) error {
+	return repositories.DeleteCoverageSubdistrict(id)
 }