lti-api/internal/modules/closings/services/closing.service.go

package service

import (
	"context"
	"errors"

	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
	"gitlab.com/mbugroup/lti-api.git/internal/modules/closings/dto"
	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/repositories"
	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/validations"
	"gitlab.com/mbugroup/lti-api.git/internal/utils"
	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"

	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

type ClosingService interface {
	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, error)
	GetClosingSummary(ctx *fiber.Ctx, projectFlockID uint) (*dto.ClosingSummaryDTO, error)
}

type closingService struct {
	Log         *logrus.Logger
	Validate    *validator.Validate
	Repository  repository.ClosingRepository
	ApprovalSvc commonSvc.ApprovalService
}

func NewClosingService(repo repository.ClosingRepository, approvalSvc commonSvc.ApprovalService, validate *validator.Validate) ClosingService {
	return &closingService{
		Log:         utils.Log,
		Validate:    validate,
		Repository:  repo,
		ApprovalSvc: approvalSvc,
	}
}

func (s closingService) withRelations(db *gorm.DB) *gorm.DB {
	return db.Preload("CreatedUser")
}

func (s closingService) withClosingRelations(db *gorm.DB) *gorm.DB {
	return s.withRelations(db).
		Preload("KandangHistory").
		Preload("KandangHistory.Chickins")
}

func (s closingService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, error) {
	if err := s.Validate.Struct(params); err != nil {
		return nil, 0, err
	}

	offset := (params.Page - 1) * params.Limit

	closings, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
		db = s.withRelations(db)
		if params.Search != "" {
			return db.Where("name LIKE ?", "%"+params.Search+"%")
		}
		return db.Order("created_at DESC").Order("updated_at DESC")
	})

	if err != nil {
		s.Log.Errorf("Failed to get closings: %+v", err)
		return nil, 0, err
	}
	return closings, total, nil
}

func (s closingService) GetClosingSummary(c *fiber.Ctx, projectFlockID uint) (*dto.ClosingSummaryDTO, error) {
	if projectFlockID == 0 {
		return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid project flock id")
	}

	project, err := s.Repository.GetByID(c.Context(), projectFlockID, s.withClosingRelations)
	if errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, fiber.NewError(fiber.StatusNotFound, "Project flock not found")
	}
	if err != nil {
		s.Log.Errorf("Failed get project flock %d for closing summary: %+v", projectFlockID, err)
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock")
	}

	statusProject, statusClosing, err := s.getApprovalStatuses(c.Context(), projectFlockID)
	if err != nil {
		s.Log.Errorf("Failed to retrieve approval statuses for project flock %d: %+v", projectFlockID, err)
		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch approval status")
	}

	summary := dto.ToClosingSummaryDTO(*project, statusProject, statusClosing)

	return &summary, nil
}

func (s closingService) getApprovalStatuses(ctx context.Context, projectFlockID uint) (string, string, error) {
	if s.ApprovalSvc == nil {
		return "", "Belum Selesai", nil
	}

	records, _, err := s.ApprovalSvc.List(ctx, utils.ApprovalWorkflowProjectFlock.String(), &projectFlockID, 1, 1000, "")
	if err != nil {
		return "", "", err
	}

	var (
		minStep       uint16
		statusProject string
		completed     int
	)

	for _, rec := range records {
		if minStep == 0 || rec.StepNumber < minStep {
			minStep = rec.StepNumber
			statusProject = rec.StepName
		}
		if rec.StepNumber == uint16(utils.ProjectFlockStepSelesai) {
			completed++
		}
	}

	if statusProject == "" && minStep > 0 {
		if label, ok := approvalutils.ApprovalStepName(utils.ApprovalWorkflowProjectFlock, approvalutils.ApprovalStep(minStep)); ok {
			statusProject = label
		}
	}

	statusClosing := "Belum Selesai"
	switch {
	case len(records) == 0 || completed == 0:
		statusClosing = "Belum Selesai"
	case completed < len(records):
		statusClosing = "Sebagian"
	default:
		statusClosing = "Selesai"
	}

	return statusProject, statusClosing, nil
}