feat: add post method request pickup

domain/request_pickup.go

@@ -4,22 +4,20 @@ import "time"
 
 type RequestPickup struct {
 	ID            string        `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
-	UserID        string        `gorm:"not null" json:"userId"`
+	UserID        string        `gorm:"type:uuid;not null" json:"userId"`
-	User          User          `gorm:"foreignKey:UserID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;" json:"user"`
 	Request       []RequestItem `gorm:"foreignKey:RequestPickupID" json:"request"`
-	RequestTime   string        `json:"requestTime"`
+	RequestTime   string        `gorm:"type:text;not null" json:"requestTime"`
-	UserAddressID string        `json:"userAddressId"`
+	UserAddressID string        `gorm:"type:uuid;not null" json:"userAddressId"`
 	UserAddress   Address       `gorm:"foreignKey:UserAddressID" json:"userAddress"`
-	StatusRequest string        `json:"statusRequest"`
+	StatusRequest string        `gorm:"type:text;not null" json:"statusRequest"`
 	CreatedAt     time.Time     `gorm:"default:current_timestamp" json:"createdAt"`
 	UpdatedAt     time.Time     `gorm:"default:current_timestamp" json:"updatedAt"`
 }
 
 type RequestItem struct {
 	ID              string        `gorm:"primaryKey;type:uuid;default:uuid_generate_v4()" json:"id"`
+	RequestPickupID string        `gorm:"type:uuid;not null" json:"requestPickupId"`
 	TrashCategoryID string        `gorm:"type:uuid;not null" json:"trashCategoryId"`
 	TrashCategory   TrashCategory `gorm:"foreignKey:TrashCategoryID" json:"trashCategory"`
-	EstimatedAmount string        `gorm:"not null" json:"estimatedAmount"`
+	EstimatedAmount string        `gorm:"type:text;not null" json:"estimatedAmount"`
-	RequestPickupID string        `gorm:"type:uuid;not null" json:"requestPickupId"`
 }
-

dto/request_pickup.go

@@ -1,5 +1,11 @@
 package dto
 
+type RequestPickupRequest struct {
+	RequestItems  []RequestItemDTO `json:"request_items"`
+	RequestTime   string           `json:"requestTime"`
+	UserAddressID string           `json:"userAddressId"`
+}
+
 type RequestPickupResponse struct {
 	ID            string           `json:"id"`
 	UserID        string           `json:"userId"`
@@ -10,8 +16,8 @@ type RequestPickupResponse struct {
 }
 
 type RequestItemDTO struct {
-	TrashCategory   string `json:"trash_category"`
+	TrashCategory   string `json:"trashCategory"`
-	EstimatedAmount string `json:"estimated_quantity"`
+	EstimatedAmount string `json:"estimatedAmount"`
 }
 
 type UserAddressDTO struct {

internal/api/routes.go

@@ -97,5 +97,5 @@ func AppRouter(app *fiber.App) {
 
 	// # request pickup by user (masyarakat) #
 	api.Get("/requestpickup", middleware.AuthMiddleware, controllers.GetRequestPickupsByUser)
-	// api.Post("/addrequestpickup", middleware.AuthMiddleware, controllers.CreateRequestPickup)
+	api.Post("/addrequestpickup", middleware.AuthMiddleware, controllers.CreateRequestPickup)
 }

internal/controllers/request_pickup.go

@@ -2,15 +2,16 @@ package controllers
 
 import (
 	"github.com/gofiber/fiber/v2"
+	"github.com/pahmiudahgede/senggoldong/domain"
 	"github.com/pahmiudahgede/senggoldong/dto"
+	"github.com/pahmiudahgede/senggoldong/internal/repositories"
 	"github.com/pahmiudahgede/senggoldong/internal/services"
 	"github.com/pahmiudahgede/senggoldong/utils"
 )
 
 func GetRequestPickupsByUser(c *fiber.Ctx) error {
-
+	userID, ok := c.Locals("userID").(string)
-	userID := c.Locals("userID").(string)
+	if !ok || userID == "" {
-	if userID == "" {
 		return c.Status(fiber.StatusUnauthorized).JSON(utils.FormatResponse(
 			fiber.StatusUnauthorized,
 			"User not authenticated",
@@ -18,7 +19,9 @@ func GetRequestPickupsByUser(c *fiber.Ctx) error {
 		))
 	}
 
-	requestPickups, err := services.GetRequestPickupsByUser(userID)
+	service := services.NewRequestPickupService(repositories.NewRequestPickupRepository())
+
+	requestPickups, err := service.GetRequestPickupsByUser(userID)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
 			fiber.StatusInternalServerError,
@@ -29,14 +32,6 @@ func GetRequestPickupsByUser(c *fiber.Ctx) error {
 
 	var requestPickupResponses []dto.RequestPickupResponse
 	for _, requestPickup := range requestPickups {
-		var requestItems []dto.RequestItemDTO
-		for _, item := range requestPickup.Request {
-			requestItems = append(requestItems, dto.RequestItemDTO{
-				TrashCategory:   item.TrashCategory.Name,
-				EstimatedAmount: item.EstimatedAmount,
-			})
-		}
-
 		userAddress := dto.UserAddressDTO{
 			Province:    requestPickup.UserAddress.Province,
 			District:    requestPickup.UserAddress.District,
@@ -47,16 +42,22 @@ func GetRequestPickupsByUser(c *fiber.Ctx) error {
 			Geography:   requestPickup.UserAddress.Geography,
 		}
 
-		requestPickupResponse := dto.NewRequestPickupResponse(
+		var requestItems []dto.RequestItemDTO
+		for _, item := range requestPickup.Request {
+			requestItems = append(requestItems, dto.RequestItemDTO{
+				TrashCategory:   item.TrashCategory.Name,
+				EstimatedAmount: item.EstimatedAmount,
+			})
+		}
+
+		requestPickupResponses = append(requestPickupResponses, dto.NewRequestPickupResponse(
 			requestPickup.ID,
 			requestPickup.UserID,
 			requestPickup.RequestTime,
 			requestPickup.StatusRequest,
 			requestItems,
 			userAddress,
-		)
+		))
-
-		requestPickupResponses = append(requestPickupResponses, requestPickupResponse)
 	}
 
 	return c.Status(fiber.StatusOK).JSON(utils.FormatResponse(
@@ -65,3 +66,63 @@ func GetRequestPickupsByUser(c *fiber.Ctx) error {
 		requestPickupResponses,
 	))
 }
+
+func CreateRequestPickup(c *fiber.Ctx) error {
+
+	userID, ok := c.Locals("userID").(string)
+	if !ok || userID == "" {
+		return c.Status(fiber.StatusUnauthorized).JSON(utils.FormatResponse(
+			fiber.StatusUnauthorized,
+			"User not authenticated",
+			nil,
+		))
+	}
+
+	var req dto.RequestPickupRequest
+	if err := c.BodyParser(&req); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
+			fiber.StatusBadRequest,
+			"Invalid request body",
+			nil,
+		))
+	}
+
+	if req.UserAddressID == "" || len(req.RequestItems) == 0 {
+		return c.Status(fiber.StatusBadRequest).JSON(utils.FormatResponse(
+			fiber.StatusBadRequest,
+			"Missing required fields",
+			nil,
+		))
+	}
+
+	var requestItems []domain.RequestItem
+	for _, item := range req.RequestItems {
+		requestItems = append(requestItems, domain.RequestItem{
+			TrashCategoryID: item.TrashCategory,
+			EstimatedAmount: item.EstimatedAmount,
+		})
+	}
+
+	requestPickup := &domain.RequestPickup{
+		UserID:        userID,
+		Request:       requestItems,
+		RequestTime:   req.RequestTime,
+		UserAddressID: req.UserAddressID,
+		StatusRequest: "waiting driver",
+	}
+
+	service := services.NewRequestPickupService(repositories.NewRequestPickupRepository())
+	if err := service.CreateRequestPickup(requestPickup); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(utils.FormatResponse(
+			fiber.StatusInternalServerError,
+			"Failed to create request pickup",
+			nil,
+		))
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(utils.FormatResponse(
+		fiber.StatusCreated,
+		"Request pickup created successfully",
+		nil,
+	))
+}

internal/repositories/request_pickup.go

@@ -5,9 +5,23 @@ import (
 	"github.com/pahmiudahgede/senggoldong/domain"
 )
 
-func GetRequestPickupsByUser(userID string) ([]domain.RequestPickup, error) {
+type RequestPickupRepository interface {
-	var requestPickups []domain.RequestPickup
+	Create(request *domain.RequestPickup) error
+	GetByUserID(userID string) ([]domain.RequestPickup, error)
+}
 
+type requestPickupRepository struct {}
+
+func NewRequestPickupRepository() RequestPickupRepository {
+	return &requestPickupRepository{}
+}
+
+func (r *requestPickupRepository) Create(request *domain.RequestPickup) error {
+	return config.DB.Create(request).Error
+}
+
+func (r *requestPickupRepository) GetByUserID(userID string) ([]domain.RequestPickup, error) {
+	var requestPickups []domain.RequestPickup
 	err := config.DB.Preload("Request").
 		Preload("Request.TrashCategory").
 		Preload("UserAddress").
@@ -20,3 +34,4 @@ func GetRequestPickupsByUser(userID string) ([]domain.RequestPickup, error) {
 
 	return requestPickups, nil
 }
+

internal/services/request_pickup.go

@@ -5,7 +5,18 @@ import (
 	"github.com/pahmiudahgede/senggoldong/internal/repositories"
 )
 
-func GetRequestPickupsByUser(userID string) ([]domain.RequestPickup, error) {
+type RequestPickupService struct {
-
+	repository repositories.RequestPickupRepository
-	return repositories.GetRequestPickupsByUser(userID)
+}
+
+func NewRequestPickupService(repository repositories.RequestPickupRepository) *RequestPickupService {
+	return &RequestPickupService{repository: repository}
+}
+
+func (s *RequestPickupService) CreateRequestPickup(request *domain.RequestPickup) error {
+	return s.repository.Create(request)
+}
+
+func (s *RequestPickupService) GetRequestPickupsByUser(userID string) ([]domain.RequestPickup, error) {
+	return s.repository.GetByUserID(userID)
 }