pahmiudahgede
/
MIF_E31222379_BE
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refact: tidy up code

This commit is contained in:
pahmiudahgede 2025-05-22 12:40:27 +07:00
parent ab6f282235
commit 29b04db0cb
12 changed files with 14 additions and 804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
dto/identitycard_dto.go
View File

@ -47,11 +47,6 @@ func (r *RequestIdentityCardDTO) ValidateIdentityCardInput() (map[string][]strin
errors := make(map[string][]string)
isValid := true
// if strings.TrimSpace(r.UserID) == "" {
// errors["userId"] = append(errors["userId"], "UserID harus diisi")
// isValid = false
// }
if strings.TrimSpace(r.Identificationumber) == "" {
errors["identificationumber"] = append(errors["identificationumber"], "Nomor identifikasi harus diisi")
isValid = false
@ -117,10 +112,5 @@ func (r *RequestIdentityCardDTO) ValidateIdentityCardInput() (map[string][]strin
isValid = false
}
// if strings.TrimSpace(r.Cardphoto) == "" {
// errors["cardphoto"] = append(errors["cardphoto"], "Foto KTP harus diisi")
// isValid = false
// }
return errors, isValid
}

13
dto/request_pickup_dto.go
View File

@ -4,17 +4,6 @@ import (
"strings"
)
// type NearbyCollectorDTO struct {
// CollectorID string `json:"collector_id"`
// Name string `json:"name"`
// Phone string `json:"phone"`
// Rating float32 `json:"rating"`
// Latitude float64 `json:"latitude"`
// Longitude float64 `json:"longitude"`
// DistanceKm float64 `json:"distance_km"`
// MatchedTrash []string `json:"matched_trash_ids"`
// }
type SelectCollectorDTO struct {
CollectorID string `json:"collector_id"`
}
@ -62,7 +51,7 @@ type PickupRequestForCollectorDTO struct {
type RequestPickupDTO struct {
AddressID string `json:"address_id"`
RequestMethod string `json:"request_method"` // "manual" atau "otomatis"
RequestMethod string `json:"request_method"`
Notes string `json:"notes,omitempty"`
}

2
dto/trashcart_dto.go
View File

@ -31,8 +31,6 @@ type ResponseCartDTO struct {
CartItems []ResponseCartItemDTO `json:"cart_items"`
}
// ==== VALIDATION ====
func (r *RequestCartDTO) ValidateRequestCartDTO() (map[string][]string, bool) {
errors := make(map[string][]string)

6
internal/handler/cart_handler.go
View File

@ -25,7 +25,6 @@ func NewCartHandler(service services.CartService) CartHandler {
return &cartHandler{service: service}
}
// GET /cart
func (h *cartHandler) GetCart(c *fiber.Ctx) error {
userID := c.Locals("userID").(string)
@ -37,7 +36,6 @@ func (h *cartHandler) GetCart(c *fiber.Ctx) error {
return utils.SuccessResponse(c, cart, "Data cart berhasil diambil")
}
// POST /cart/item
func (h *cartHandler) AddOrUpdateCartItem(c *fiber.Ctx) error {
userID := c.Locals("userID").(string)
@ -60,7 +58,6 @@ func (h *cartHandler) AddOrUpdateCartItem(c *fiber.Ctx) error {
return utils.SuccessResponse(c, nil, "Item berhasil ditambahkan/diupdate di cart")
}
// POST /cart/items
func (h *cartHandler) AddMultipleCartItems(c *fiber.Ctx) error {
userID := c.Locals("userID").(string)
@ -84,8 +81,6 @@ func (h *cartHandler) AddMultipleCartItems(c *fiber.Ctx) error {
return utils.SuccessResponse(c, nil, "Semua item berhasil ditambahkan/diupdate ke cart")
}
// DELETE /cart/item/:trashID
func (h *cartHandler) DeleteCartItem(c *fiber.Ctx) error {
userID := c.Locals("userID").(string)
trashID := c.Params("trashID")
@ -102,7 +97,6 @@ func (h *cartHandler) DeleteCartItem(c *fiber.Ctx) error {
return utils.SuccessResponse(c, nil, "Item berhasil dihapus dari cart")
}
// DELETE /cart
func (h *cartHandler) ClearCart(c *fiber.Ctx) error {
userID := c.Locals("userID").(string)

60
internal/handler/collector_handler.go
View File

@ -27,58 +27,6 @@ func NewCollectorHandler(service services.CollectorService) CollectorHandler {
return &collectorHandler{service: service}
}
// func (h *CollectorHandler) ConfirmRequestPickup(c *fiber.Ctx) error {
// collectorId, ok := c.Locals("userID").(string)
// if !ok || collectorId == "" {
// return utils.GenericResponse(c, fiber.StatusUnauthorized, "Unauthorized: User session not found")
// }
// requestPickupId := c.Params("id")
// if requestPickupId == "" {
// return utils.ErrorResponse(c, "RequestPickup ID is required")
// }
// req, err := h.service.ConfirmRequestPickup(requestPickupId, collectorId)
// if err != nil {
// return utils.ErrorResponse(c, err.Error())
// }
// return utils.SuccessResponse(c, req, "Request pickup confirmed successfully")
// }
// func (h *CollectorHandler) GetAvaibleCollector(c *fiber.Ctx) error {
// userId := c.Locals("userID").(string)
// requests, err := h.service.FindCollectorsNearby(userId)
// if err != nil {
// return utils.ErrorResponse(c, err.Error())
// }
// return utils.SuccessResponse(c, requests, "menampilkan data collector terdekat")
// }
// func (h *CollectorHandler) ConfirmRequestManualPickup(c *fiber.Ctx) error {
// userId := c.Locals("userID").(string)
// requestId := c.Params("request_id")
// if requestId == "" {
// fmt.Println("requestid dibutuhkan")
// }
// var request dto.SelectCollectorRequest
// if err := c.BodyParser(&request); err != nil {
// return fmt.Errorf("error parsing request body: %v", err)
// }
// message, err := h.service.ConfirmRequestManualPickup(requestId, userId)
// if err != nil {
// return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Error confirming pickup: %v", err))
// }
// return utils.SuccessResponse(c, message, "berhasil konfirmasi request")
// }
func (h *collectorHandler) CreateCollector(c *fiber.Ctx) error {
var req dto.RequestCollectorDTO
if err := c.BodyParser(&req); err != nil {
@ -100,7 +48,6 @@ func (h *collectorHandler) CreateCollector(c *fiber.Ctx) error {
return utils.CreateResponse(c, nil, "Collector berhasil dibuat")
}
// POST /collectors/:id/trash
func (h *collectorHandler) AddTrashToCollector(c *fiber.Ctx) error {
collectorID := c.Params("id")
var req dto.RequestAddAvaibleTrash
@ -123,7 +70,6 @@ func (h *collectorHandler) AddTrashToCollector(c *fiber.Ctx) error {
return utils.SuccessResponse(c, nil, "Trash berhasil ditambahkan")
}
// GET /collectors/:id
func (h *collectorHandler) GetCollectorByID(c *fiber.Ctx) error {
collectorID := c.Params("id")
result, err := h.service.GetCollectorByID(context.Background(), collectorID)
@ -133,7 +79,7 @@ func (h *collectorHandler) GetCollectorByID(c *fiber.Ctx) error {
return utils.SuccessResponse(c, result, "Data collector berhasil diambil")
}
func (h *collectorHandler) GetCollectorByUserID(c *fiber.Ctx) error {
// collectorID := c.Params("id")
userID, ok := c.Locals("userID").(string)
if !ok || userID == "" {
return utils.GenericResponse(c, fiber.StatusUnauthorized, "Unauthorized: User session not found")
@ -146,7 +92,6 @@ func (h *collectorHandler) GetCollectorByUserID(c *fiber.Ctx) error {
return utils.SuccessResponse(c, result, "Data collector berhasil diambil")
}
// PATCH /collectors/:id
func (h *collectorHandler) UpdateCollector(c *fiber.Ctx) error {
collectorID := c.Params("id")
var req struct {
@ -201,8 +146,6 @@ func (h *collectorHandler) UpdateJobStatus(c *fiber.Ctx) error {
return utils.SuccessResponse(c, nil, "Status collector berhasil diperbarui")
}
// PATCH /collectors/:id/trash
func (h *collectorHandler) UpdateTrash(c *fiber.Ctx) error {
collectorID := c.Params("id")
var req []dto.RequestAvaibleTrashbyCollector
@ -234,7 +177,6 @@ func (h *collectorHandler) UpdateTrash(c *fiber.Ctx) error {
return utils.SuccessResponse(c, nil, "Trash berhasil diperbarui")
}
// DELETE /collectors/trash/:id
func (h *collectorHandler) DeleteTrash(c *fiber.Ctx) error {
trashID := c.Params("id")
if trashID == "" {

92
internal/handler/requestpickup_handler.go
View File

@ -1,92 +0,0 @@
package handler
// import (
// "fmt"
// "rijig/dto"
// "rijig/internal/services"
// "rijig/utils"
// "github.com/gofiber/fiber/v2"
// )
// type RequestPickupHandler struct {
// service services.RequestPickupService
// }
// func NewRequestPickupHandler(service services.RequestPickupService) *RequestPickupHandler {
// return &RequestPickupHandler{service: service}
// }
// func (h *RequestPickupHandler) CreateRequestPickup(c *fiber.Ctx) error {
// userID, ok := c.Locals("userID").(string)
// if !ok || userID == "" {
// return utils.GenericResponse(c, fiber.StatusUnauthorized, "Unauthorized: User session not found")
// }
// var request dto.RequestPickup
// if err := c.BodyParser(&request); err != nil {
// return utils.GenericResponse(c, fiber.StatusBadRequest, "Invalid request body")
// }
// errors, valid := request.ValidateRequestPickup()
// if !valid {
// return utils.ValidationErrorResponse(c, errors)
// }
// response, err := h.service.CreateRequestPickup(request, userID)
// if err != nil {
// return utils.InternalServerErrorResponse(c, fmt.Sprintf("Error creating request pickup: %v", err))
// }
// return utils.SuccessResponse(c, response, "Request pickup created successfully")
// }
// func (h *RequestPickupHandler) GetRequestPickupByID(c *fiber.Ctx) error {
// id := c.Params("id")
// response, err := h.service.GetRequestPickupByID(id)
// if err != nil {
// return utils.GenericResponse(c, fiber.StatusNotFound, fmt.Sprintf("Request pickup with ID %s not found: %v", id, err))
// }
// return utils.SuccessResponse(c, response, "Request pickup retrieved successfully")
// }
// func (h *RequestPickupHandler) GetRequestPickups(c *fiber.Ctx) error {
// collectorId := c.Locals("userID").(string)
// requests, err := h.service.GetRequestPickupsForCollector(collectorId)
// if err != nil {
// return utils.ErrorResponse(c, err.Error())
// }
// return utils.SuccessResponse(c, requests, "Automatic request pickups retrieved successfully")
// }
// func (h *RequestPickupHandler) AssignCollectorToRequest(c *fiber.Ctx) error {
// userId, ok := c.Locals("userID").(string)
// if !ok || userId == "" {
// return utils.GenericResponse(c, fiber.StatusUnauthorized, "Unauthorized: User session not found")
// }
// var request dto.SelectCollectorRequest
// errors, valid := request.ValidateSelectCollectorRequest()
// if !valid {
// return utils.ValidationErrorResponse(c, errors)
// }
// if err := c.BodyParser(&request); err != nil {
// return fmt.Errorf("error parsing request body: %v", err)
// }
// err := h.service.SelectCollectorInRequest(userId, request.Collector_id)
// if err != nil {
// return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Error assigning collector: %v", err))
// }
// return utils.GenericResponse(c, fiber.StatusOK, "berhasil memilih collector")
// }

2
internal/repositories/collector_repo.go
View File

@ -104,8 +104,6 @@ func (r *collectorRepository) DeleteAvaibleTrash(ctx context.Context, trashID st
Delete(&model.AvaibleTrashByCollector{}, "id = ?", trashID).Error
}
//
func (r *collectorRepository) GetActiveCollectorsWithTrashAndAddress(ctx context.Context) ([]model.Collector, error) {
var collectors []model.Collector
err := config.DB.WithContext(ctx).

181
internal/repositories/requestpickup_repo.go
View File

@ -1,181 +0,0 @@
package repositories
// import (
// "fmt"
// "rijig/model"
// "gorm.io/gorm"
// )
// type RequestPickupRepository interface {
// CreateRequestPickup(request *model.RequestPickup) error
// CreateRequestPickupItem(item *model.RequestPickupItem) error
// FindRequestPickupByID(id string) (*model.RequestPickup, error)
// FindAllRequestPickups(userId string) ([]model.RequestPickup, error)
// FindAllAutomaticMethodRequest(requestMethod, statuspickup string) ([]model.RequestPickup, error)
// FindRequestPickupByAddressAndStatus(userId, status, method string) (*model.RequestPickup, error)
// FindRequestPickupByStatus(userId, status, method string) (*model.RequestPickup, error)
// GetRequestPickupItems(requestPickupId string) ([]model.RequestPickupItem, error)
// GetAutomaticRequestPickupsForCollector() ([]model.RequestPickup, error)
// GetManualReqMethodforCollect(collector_id string) ([]model.RequestPickup, error)
// // SelectCollectorInRequest(userId string, collectorId string) error
// UpdateRequestPickup(id string, request *model.RequestPickup) error
// DeleteRequestPickup(id string) error
// }
// type requestPickupRepository struct {
// DB *gorm.DB
// }
// func NewRequestPickupRepository(db *gorm.DB) RequestPickupRepository {
// return &requestPickupRepository{DB: db}
// }
// func (r *requestPickupRepository) CreateRequestPickup(request *model.RequestPickup) error {
// if err := r.DB.Create(request).Error; err != nil {
// return fmt.Errorf("failed to create request pickup: %v", err)
// }
// for _, item := range request.RequestItems {
// item.RequestPickupId = request.ID
// if err := r.DB.Create(&item).Error; err != nil {
// return fmt.Errorf("failed to create request pickup item: %v", err)
// }
// }
// return nil
// }
// func (r *requestPickupRepository) CreateRequestPickupItem(item *model.RequestPickupItem) error {
// if err := r.DB.Create(item).Error; err != nil {
// return fmt.Errorf("failed to create request pickup item: %v", err)
// }
// return nil
// }
// func (r *requestPickupRepository) FindRequestPickupByID(id string) (*model.RequestPickup, error) {
// var request model.RequestPickup
// err := r.DB.Preload("RequestItems").First(&request, "id = ?", id).Error
// if err != nil {
// return nil, fmt.Errorf("request pickup with ID %s not found: %v", id, err)
// }
// return &request, nil
// }
// func (r *requestPickupRepository) FindAllRequestPickups(userId string) ([]model.RequestPickup, error) {
// var requests []model.RequestPickup
// err := r.DB.Preload("RequestItems").Where("user_id = ?", userId).Find(&requests).Error
// if err != nil {
// return nil, fmt.Errorf("failed to fetch all request pickups: %v", err)
// }
// return requests, nil
// }
// func (r *requestPickupRepository) FindAllAutomaticMethodRequest(requestMethod, statuspickup string) ([]model.RequestPickup, error) {
// var requests []model.RequestPickup
// err := r.DB.Preload("RequestItems").Where("request_method = ? AND status_pickup = ?", requestMethod, statuspickup).Find(&requests).Error
// if err != nil {
// return nil, fmt.Errorf("error fetching request pickups with request_method %s: %v", requestMethod, err)
// }
// return requests, nil
// }
// func (r *requestPickupRepository) FindRequestPickupByAddressAndStatus(userId, status, method string) (*model.RequestPickup, error) {
// var request model.RequestPickup
// err := r.DB.Preload("Address").Where("user_id = ? AND status_pickup = ? AND request_method =?", userId, status, method).First(&request).Error
// if err != nil {
// if err == gorm.ErrRecordNotFound {
// return nil, nil
// }
// return nil, fmt.Errorf("failed to check existing request pickup: %v", err)
// }
// return &request, nil
// }
// func (r *requestPickupRepository) FindRequestPickupByStatus(userId, status, method string) (*model.RequestPickup, error) {
// var request model.RequestPickup
// err := r.DB.Where("user_id = ? AND status_pickup = ? AND request_method =?", userId, status, method).First(&request).Error
// if err != nil {
// if err == gorm.ErrRecordNotFound {
// return nil, nil
// }
// return nil, fmt.Errorf("failed to check existing request pickup: %v", err)
// }
// return &request, nil
// }
// func (r *requestPickupRepository) UpdateRequestPickup(id string, request *model.RequestPickup) error {
// err := r.DB.Model(&model.RequestPickup{}).Where("id = ?", id).Updates(request).Error
// if err != nil {
// return fmt.Errorf("failed to update request pickup: %v", err)
// }
// return nil
// }
// // func (r *requestPickupRepository) SelectCollectorInRequest(userId string, collectorId string) error {
// // var request model.RequestPickup
// // err := r.DB.Model(&model.RequestPickup{}).
// // Where("user_id = ? AND status_pickup = ? AND request_method = ? AND collector_id IS NULL", userId, "waiting_collector", "manual").
// // First(&request).Error
// // if err != nil {
// // if err == gorm.ErrRecordNotFound {
// // return fmt.Errorf("no matching request pickup found for user %s", userId)
// // }
// // return fmt.Errorf("failed to find request pickup: %v", err)
// // }
// // err = r.DB.Model(&model.RequestPickup{}).
// // Where("id = ?", request.ID).
// // Update("collector_id", collectorId).
// // Error
// // if err != nil {
// // return fmt.Errorf("failed to update collector_id: %v", err)
// // }
// // return nil
// // }
// func (r *requestPickupRepository) DeleteRequestPickup(id string) error {
// if err := r.DB.Where("request_pickup_id = ?", id).Delete(&model.RequestPickupItem{}).Error; err != nil {
// return fmt.Errorf("failed to delete request pickup items: %v", err)
// }
// err := r.DB.Delete(&model.RequestPickup{}, "id = ?", id).Error
// if err != nil {
// return fmt.Errorf("failed to delete request pickup: %v", err)
// }
// return nil
// }
// func (r *requestPickupRepository) GetAutomaticRequestPickupsForCollector() ([]model.RequestPickup, error) {
// var requests []model.RequestPickup
// err := r.DB.Preload("Address").
// Where("request_method = ? AND status_pickup = ? AND collector_id = ?", "otomatis", "waiting_collector", nil).
// Find(&requests).Error
// if err != nil {
// return nil, fmt.Errorf("error fetching pickup requests: %v", err)
// }
// return requests, nil
// }
// func (r *requestPickupRepository) GetManualReqMethodforCollect(collector_id string) ([]model.RequestPickup, error) {
// var requests []model.RequestPickup
// err := r.DB.Where("request_method = ? AND status_pickup = ? AND collector_id = ?", "otomatis", "waiting_collector", collector_id).
// Find(&requests).Error
// if err != nil {
// return nil, fmt.Errorf("error fetching pickup requests: %v", err)
// }
// return requests, nil
// }
// func (r *requestPickupRepository) GetRequestPickupItems(requestPickupId string) ([]model.RequestPickupItem, error) {
// var items []model.RequestPickupItem
// err := r.DB.Preload("TrashCategory").Where("request_pickup_id = ?", requestPickupId).Find(&items).Error
// if err != nil {
// return nil, fmt.Errorf("error fetching request pickup items: %v", err)
// }
// return items, nil
// }

349
internal/services/requestpickup_service.go
View File

@ -1,349 +0,0 @@
package services
// import (
// "fmt"
// "rijig/dto"
// "rijig/internal/repositories"
// "rijig/model"
// "rijig/utils"
// )
// type RequestPickupService interface {
// // CreateRequestPickup(request dto.RequestPickup, UserId string) (*dto.ResponseRequestPickup, error)
// // GetRequestPickupByID(id string) (*dto.ResponseRequestPickup, error)
// // GetAllRequestPickups(userid string) ([]dto.ResponseRequestPickup, error)
// // GetRequestPickupsForCollector(collectorId string) ([]dto.ResponseRequestPickup, error)
// // SelectCollectorInRequest(userId, collectorId string) error
// }
// type requestPickupService struct {
// repo repositories.RequestPickupRepository
// repoColl repositories.CollectorRepository
// repoAddress repositories.AddressRepository
// repoTrash repositories.TrashRepository
// repoUser repositories.UserProfilRepository
// }
// func NewRequestPickupService(repo repositories.RequestPickupRepository,
// repoColl repositories.CollectorRepository,
// repoAddress repositories.AddressRepository,
// repoTrash repositories.TrashRepository,
// repoUser repositories.UserProfilRepository) RequestPickupService {
// return &requestPickupService{repo: repo, repoColl: repoColl, repoAddress: repoAddress, repoTrash: repoTrash, repoUser: repoUser}
// }
// func (s *requestPickupService) CreateRequestPickup(request dto.RequestPickup, UserId string) (*dto.ResponseRequestPickup, error) {
// errors, valid := request.ValidateRequestPickup()
// if !valid {
// return nil, fmt.Errorf("validation errors: %v", errors)
// }
// _, err := s.repoAddress.FindAddressByID(request.AddressID)
// if err != nil {
// return nil, fmt.Errorf("address with ID %s not found", request.AddressID)
// }
// existingRequest, err := s.repo.FindRequestPickupByAddressAndStatus(UserId, "waiting_collector", "otomatis")
// if err != nil {
// return nil, fmt.Errorf("error checking for existing request pickup: %v", err)
// }
// if existingRequest != nil {
// return nil, fmt.Errorf("there is already a pending pickup request for address %s", request.AddressID)
// }
// modelRequest := model.RequestPickup{
// UserId: UserId,
// AddressId: request.AddressID,
// EvidenceImage: request.EvidenceImage,
// RequestMethod: request.RequestMethod,
// }
// err = s.repo.CreateRequestPickup(&modelRequest)
// if err != nil {
// return nil, fmt.Errorf("failed to create request pickup: %v", err)
// }
// createdAt, _ := utils.FormatDateToIndonesianFormat(modelRequest.CreatedAt)
// updatedAt, _ := utils.FormatDateToIndonesianFormat(modelRequest.UpdatedAt)
// response := &dto.ResponseRequestPickup{
// ID: modelRequest.ID,
// UserId: UserId,
// AddressID: modelRequest.AddressId,
// EvidenceImage: modelRequest.EvidenceImage,
// StatusPickup: modelRequest.StatusPickup,
// CreatedAt: createdAt,
// UpdatedAt: updatedAt,
// }
// for _, item := range request.RequestItems {
// findTrashCategory, err := s.repoTrash.GetCategoryByID(item.TrashCategoryID)
// if err != nil {
// return nil, fmt.Errorf("trash category with ID %s not found", item.TrashCategoryID)
// }
// modelItem := model.RequestPickupItem{
// RequestPickupId: modelRequest.ID,
// TrashCategoryId: findTrashCategory.ID,
// EstimatedAmount: item.EstimatedAmount,
// }
// err = s.repo.CreateRequestPickupItem(&modelItem)
// if err != nil {
// return nil, fmt.Errorf("failed to create request pickup item: %v", err)
// }
// response.RequestItems = append(response.RequestItems, dto.ResponseRequestPickupItem{
// ID: modelItem.ID,
// TrashCategory: []dto.ResponseTrashCategoryDTO{{Name: findTrashCategory.Name, Icon: findTrashCategory.Icon}},
// EstimatedAmount: modelItem.EstimatedAmount,
// })
// }
// return response, nil
// }
// func (s *requestPickupService) GetRequestPickupByID(id string) (*dto.ResponseRequestPickup, error) {
// request, err := s.repo.FindRequestPickupByID(id)
// if err != nil {
// return nil, fmt.Errorf("error fetching request pickup with ID %s: %v", id, err)
// }
// createdAt, _ := utils.FormatDateToIndonesianFormat(request.CreatedAt)
// updatedAt, _ := utils.FormatDateToIndonesianFormat(request.UpdatedAt)
// response := &dto.ResponseRequestPickup{
// ID: request.ID,
// UserId: request.UserId,
// AddressID: request.AddressId,
// EvidenceImage: request.EvidenceImage,
// StatusPickup: request.StatusPickup,
// CreatedAt: createdAt,
// UpdatedAt: updatedAt,
// }
// return response, nil
// }
// func (s *requestPickupService) GetAllRequestPickups(userid string) ([]dto.ResponseRequestPickup, error) {
// requests, err := s.repo.FindAllRequestPickups(userid)
// if err != nil {
// return nil, fmt.Errorf("error fetching all request pickups: %v", err)
// }
// var response []dto.ResponseRequestPickup
// for _, request := range requests {
// createdAt, _ := utils.FormatDateToIndonesianFormat(request.CreatedAt)
// updatedAt, _ := utils.FormatDateToIndonesianFormat(request.UpdatedAt)
// response = append(response, dto.ResponseRequestPickup{
// ID: request.ID,
// UserId: request.UserId,
// AddressID: request.AddressId,
// EvidenceImage: request.EvidenceImage,
// StatusPickup: request.StatusPickup,
// CreatedAt: createdAt,
// UpdatedAt: updatedAt,
// })
// }
// return response, nil
// }
// // func (s *requestPickupService) GetRequestPickupsForCollector(collectorId string) ([]dto.ResponseRequestPickup, error) {
// // requests, err := s.repo.GetAutomaticRequestPickupsForCollector()
// // if err != nil {
// // return nil, fmt.Errorf("error retrieving automatic pickup requests: %v", err)
// // }
// // var response []dto.ResponseRequestPickup
// // for _, req := range requests {
// // collector, err := s.repoColl.FindCollectorById(collectorId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching collector data: %v", err)
// // }
// // _, distance := utils.Distance(
// // utils.Coord{Lat: collector.Address.Latitude, Lon: collector.Address.Longitude},
// // utils.Coord{Lat: req.Address.Latitude, Lon: req.Address.Longitude},
// // )
// // if distance <= 20 {
// // mappedRequest := dto.ResponseRequestPickup{
// // ID: req.ID,
// // UserId: req.UserId,
// // AddressID: req.AddressId,
// // EvidenceImage: req.EvidenceImage,
// // StatusPickup: req.StatusPickup,
// // CreatedAt: req.CreatedAt.Format("2006-01-02 15:04:05"),
// // UpdatedAt: req.UpdatedAt.Format("2006-01-02 15:04:05"),
// // }
// // user, err := s.repoUser.FindByID(req.UserId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching user data: %v", err)
// // }
// // mappedRequest.User = []dto.UserResponseDTO{
// // {
// // Name: user.Name,
// // Phone: user.Phone,
// // },
// // }
// // address, err := s.repoAddress.FindAddressByID(req.AddressId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching address data: %v", err)
// // }
// // mappedRequest.Address = []dto.AddressResponseDTO{
// // {
// // District: address.District,
// // Village: address.Village,
// // Detail: address.Detail,
// // },
// // }
// // requestItems, err := s.repo.GetRequestPickupItems(req.ID)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching request items: %v", err)
// // }
// // var mappedRequestItems []dto.ResponseRequestPickupItem
// // for _, item := range requestItems {
// // trashCategory, err := s.repoTrash.GetCategoryByID(item.TrashCategoryId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching trash category: %v", err)
// // }
// // mappedRequestItems = append(mappedRequestItems, dto.ResponseRequestPickupItem{
// // ID: item.ID,
// // TrashCategory: []dto.ResponseTrashCategoryDTO{{
// // Name: trashCategory.Name,
// // Icon: trashCategory.Icon,
// // }},
// // EstimatedAmount: item.EstimatedAmount,
// // })
// // }
// // mappedRequest.RequestItems = mappedRequestItems
// // response = append(response, mappedRequest)
// // }
// // }
// // return response, nil
// // }
// // func (s *requestPickupService) GetManualRequestPickupsForCollector(collectorId string) ([]dto.ResponseRequestPickup, error) {
// // collector, err := s.repoColl.FindCollectorById(collectorId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching collector data: %v", err)
// // }
// // requests, err := s.repo.GetManualReqMethodforCollect(collector.ID)
// // if err != nil {
// // return nil, fmt.Errorf("error retrieving manual pickup requests: %v", err)
// // }
// // var response []dto.ResponseRequestPickup
// // for _, req := range requests {
// // createdAt, _ := utils.FormatDateToIndonesianFormat(req.CreatedAt)
// // updatedAt, _ := utils.FormatDateToIndonesianFormat(req.UpdatedAt)
// // mappedRequest := dto.ResponseRequestPickup{
// // ID: req.ID,
// // UserId: req.UserId,
// // AddressID: req.AddressId,
// // EvidenceImage: req.EvidenceImage,
// // StatusPickup: req.StatusPickup,
// // CreatedAt: createdAt,
// // UpdatedAt: updatedAt,
// // }
// // user, err := s.repoUser.FindByID(req.UserId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching user data: %v", err)
// // }
// // mappedRequest.User = []dto.UserResponseDTO{
// // {
// // Name: user.Name,
// // Phone: user.Phone,
// // },
// // }
// // address, err := s.repoAddress.FindAddressByID(req.AddressId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching address data: %v", err)
// // }
// // mappedRequest.Address = []dto.AddressResponseDTO{
// // {
// // District: address.District,
// // Village: address.Village,
// // Detail: address.Detail,
// // },
// // }
// // requestItems, err := s.repo.GetRequestPickupItems(req.ID)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching request items: %v", err)
// // }
// // var mappedRequestItems []dto.ResponseRequestPickupItem
// // for _, item := range requestItems {
// // trashCategory, err := s.repoTrash.GetCategoryByID(item.TrashCategoryId)
// // if err != nil {
// // return nil, fmt.Errorf("error fetching trash category: %v", err)
// // }
// // mappedRequestItems = append(mappedRequestItems, dto.ResponseRequestPickupItem{
// // ID: item.ID,
// // TrashCategory: []dto.ResponseTrashCategoryDTO{{
// // Name: trashCategory.Name,
// // Icon: trashCategory.Icon,
// // }},
// // EstimatedAmount: item.EstimatedAmount,
// // })
// // }
// // mappedRequest.RequestItems = mappedRequestItems
// // response = append(response, mappedRequest)
// // }
// // return response, nil
// // }
// // func (s *requestPickupService) SelectCollectorInRequest(userId, collectorId string) error {
// // request, err := s.repo.FindRequestPickupByStatus(userId, "waiting_collector", "manual")
// // if err != nil {
// // return fmt.Errorf("request pickup not found: %v", err)
// // }
// // if request.StatusPickup != "waiting_collector" && request.RequestMethod != "manual" {
// // return fmt.Errorf("pickup request is not in 'waiting_collector' status and not 'manual' method")
// // }
// // collector, err := s.repoColl.FindCollectorByIdWithoutAddr(collectorId)
// // if err != nil {
// // return fmt.Errorf("collector tidak ditemukan: %v", err)
// // }
// // request.CollectorID = &collector.ID
// // err = s.repo.UpdateRequestPickup(request.ID, request)
// // if err != nil {
// // return fmt.Errorf("failed to update request pickup: %v", err)
// // }
// // return nil
// // }

21
model/requestpickup_model.go
View File

@ -16,8 +16,8 @@ type RequestPickup struct {
CollectorID *string `gorm:"type:uuid" json:"collector_id,omitempty"`
Collector *Collector `gorm:"foreignKey:CollectorID;references:ID" json:"collector,omitempty"`
ConfirmedByCollectorAt *time.Time `json:"confirmed_by_collector_at,omitempty"`
RequestMethod string `gorm:"not null" json:"request_method"` // manual / otomatis
FinalPrice float64 `json:"final_price"` // diisi setelah collector update berat
RequestMethod string `gorm:"not null" json:"request_method"`
FinalPrice float64 `json:"final_price"`
CreatedAt time.Time `gorm:"autoCreateTime" json:"created_at"`
UpdatedAt time.Time `gorm:"autoUpdateTime" json:"updated_at"`
}
@ -29,19 +29,6 @@ type RequestPickupItem struct {
TrashCategoryId string `gorm:"not null" json:"trash_category_id"`
TrashCategory *TrashCategory `gorm:"foreignKey:TrashCategoryId" json:"trash_category"`
EstimatedAmount float64 `gorm:"not null" json:"estimated_amount"`
EstimatedPricePerKg float64 `gorm:"not null" json:"estimated_price_per_kg"` // harga pada saat itu
EstimatedSubtotalPrice float64 `gorm:"not null" json:"estimated_subtotal_price"` // amount * price per kg
EstimatedPricePerKg float64 `gorm:"not null" json:"estimated_price_per_kg"`
EstimatedSubtotalPrice float64 `gorm:"not null" json:"estimated_subtotal_price"`
}
// request_method {
// "otomatis",
// "manual"
// }
// status_pickup {
// "waiting_collector",
// "confirmed",
// "collector_picking",
// "completed"
// "canceled"
// }

36
presentation/collector_route.go
View File

@ -7,29 +7,11 @@ import (
"rijig/internal/services"
"rijig/middleware"
// "rijig/utils"
"github.com/gofiber/fiber/v2"
)
func CollectorRouter(api fiber.Router) {
// repo := repositories.NewCollectorRepository(config.DB)
// repoReq := repositories.NewRequestPickupRepository(config.DB)
// repoAddress := repositories.NewAddressRepository(config.DB)
// repoUser := repositories.NewUserProfilRepository(config.DB)
// colectorService := services.NewCollectorService(repo, repoReq, repoAddress, repoUser)
// collectorHandler := handler.NewCollectorHandler(colectorService)
// collector := api.Group("/collector")
// collector.Use(middleware.AuthMiddleware)
// collector.Put("confirmrequest/:id", collectorHandler.ConfirmRequestPickup)
// collector.Put("confirm-manual/request/:request_id", collectorHandler.ConfirmRequestManualPickup)
// collector.Get("/avaible", collectorHandler.GetAvaibleCollector)
// Middleware Auth dan Role
// Inisialisasi repository dan service
pickupRepo := repositories.NewRequestPickupRepository()
trashRepo := repositories.NewTrashRepository(config.DB)
historyRepo := repositories.NewPickupStatusHistoryRepository()
@ -38,22 +20,20 @@ func CollectorRouter(api fiber.Router) {
pickupService := services.NewRequestPickupService(trashRepo, pickupRepo, cartService, historyRepo)
pickupHandler := handler.NewRequestPickupHandler(pickupService)
collectorRepo := repositories.NewCollectorRepository()
// trashRepo := repositories.NewTrashRepository(config.DB)
collectorService := services.NewCollectorService(collectorRepo, trashRepo)
collectorHandler := handler.NewCollectorHandler(collectorService)
// Group collector
collectors := api.Group("/collectors")
collectors.Use(middleware.AuthMiddleware)
// === Collector routes ===
collectors.Post("/", collectorHandler.CreateCollector) // Create collector
collectors.Post("/:id/trash", collectorHandler.AddTrashToCollector) // Add trash to collector
collectors.Get("/:id", collectorHandler.GetCollectorByID) // Get collector by ID
collectors.Get("/", collectorHandler.GetCollectorByUserID)
collectors.Get("/pickup/assigned-to-me", pickupHandler.GetAssignedPickup)
// Get collector by ID
collectors.Patch("/:id", collectorHandler.UpdateCollector) // Update collector fields
collectors.Post("/", collectorHandler.CreateCollector)
collectors.Post("/:id/trash", collectorHandler.AddTrashToCollector)
collectors.Get("/:id", collectorHandler.GetCollectorByID)
collectors.Get("/", collectorHandler.GetCollectorByUserID)
collectors.Get("/pickup/assigned-to-me", pickupHandler.GetAssignedPickup)
collectors.Patch("/:id", collectorHandler.UpdateCollector)
collectors.Patch("/:id/trash", collectorHandler.UpdateTrash)
collectors.Patch("/:id/job-status", collectorHandler.UpdateJobStatus)
collectors.Delete("/trash/:id", collectorHandler.DeleteTrash)

46
presentation/requestpickup_route.go
View File

@ -1,46 +0,0 @@
package presentation
// import (
// "rijig/config"
// "rijig/internal/handler"
// "rijig/internal/repositories"
// "rijig/internal/services"
// "rijig/middleware"
// "github.com/gofiber/fiber/v2"
// )
// func RequestPickupRouter(api fiber.Router) {
// // repo repositories.RequestPickupRepository
// // repoColl repositories.CollectorRepository
// // repoAddress repositories.AddressRepository
// // repoTrash repositories.TrashRepository
// // repoUser repositories.UserProfilRepository
// requestRepo := repositories.NewRequestPickupRepository(config.DB)
// // repoColl := repositories.NewCollectorRepository(config.DB)
// repoColl := repositories.NewCollectorRepository()
// repoAddress := repositories.NewAddressRepository(config.DB)
// Trashrepo := repositories.NewTrashRepository(config.DB)
// repouser := repositories.NewUserProfilRepository(config.DB)
// // collectorRepo := repositories.NewCollectorRepository(config.DB)
// requestPickupServices := services.NewRequestPickupService(requestRepo, repoColl, repoAddress, Trashrepo, repouser)
// // collectorService := services.NewCollectorService(collectorRepo, requestRepo, repoAddress)
// // service services.RequestPickupService,
// // collectorService services.CollectorService
// requestPickupHandler := handler.NewRequestPickupHandler(requestPickupServices)
// requestPickupAPI := api.Group("/requestpickup")
// requestPickupAPI.Use(middleware.AuthMiddleware)
// requestPickupAPI.Post("/", requestPickupHandler.CreateRequestPickup)
// // requestPickupAPI.Get("/get", middleware.AuthMiddleware, requestPickupHandler.GetAutomaticRequestByUser)
// requestPickupAPI.Get("/get-allrequest", requestPickupHandler.GetRequestPickups)
// requestPickupAPI.Patch("/select-collector", requestPickupHandler.AssignCollectorToRequest)
// // requestPickupAPI.Get("/:id", requestPickupHandler.GetRequestPickupByID)
// // requestPickupAPI.Get("/", requestPickupHandler.GetAllRequestPickups)
// // requestPickupAPI.Put("/:id", requestPickupHandler.UpdateRequestPickup)
// // requestPickupAPI.Delete("/:id", requestPickupHandler.DeleteRequestPickup)
// }