lti-api/internal/modules/production/project_flocks/dto/projectflock.dto.go

package dto

import (
	"time"

	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
	approvalDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/approvals/dto"
	areaDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/areas/dto"
	fcrDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/fcrs/dto"
	flockDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/dto"
	kandangDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/dto"
	locationDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/locations/dto"

	// pfutils "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/utils"
	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
	"gitlab.com/mbugroup/lti-api.git/internal/utils"
	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
)

type ProjectFlockBaseDTO struct {
	Id        uint   `json:"id"`
	Period    int    `json:"period"`
	FlockName string `json:"flock_name"`
}

type ProjectFlockListDTO struct {
	ProjectFlockBaseDTO
	Flock       *flockDTO.FlockBaseDTO         `json:"flock,omitempty"`
	Area        *areaDTO.AreaBaseDTO           `json:"area,omitempty"`
	Category    string                         `json:"category"`
	Fcr         *fcrDTO.FcrBaseDTO             `json:"fcr,omitempty"`
	Location    *locationDTO.LocationBaseDTO   `json:"location,omitempty"`
	Kandangs    []KandangWithProjectFlockIdDTO `json:"kandangs,omitempty"`
	CreatedUser *userDTO.UserBaseDTO           `json:"created_user"`
	CreatedAt   time.Time                      `json:"created_at"`
	UpdatedAt   time.Time                      `json:"updated_at"`
	Approval    approvalDTO.ApprovalBaseDTO    `json:"approval"`
}

type KandangWithProjectFlockIdDTO struct {
	kandangDTO.KandangBaseDTO
	ProjectFlockKandangId uint `json:"project_flock_kandang_id"`
}

type ProjectFlockDetailDTO struct {
	ProjectFlockListDTO
}

type FlockPeriodDTO struct {
	Flock      flockDTO.FlockBaseDTO `json:"flock"`
	NextPeriod int                   `json:"next_period"`
}

func ToProjectFlockListDTO(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO) ProjectFlockListDTO {
	var createdUser *userDTO.UserBaseDTO
	if e.CreatedUser.Id != 0 {
		mapped := userDTO.ToUserBaseDTO(e.CreatedUser)
		createdUser = &mapped
	}

	var kandangSummaries []KandangWithProjectFlockIdDTO
	if len(e.Kandangs) > 0 {
		kandangSummaries = make([]KandangWithProjectFlockIdDTO, len(e.Kandangs))
		for i, kandang := range e.Kandangs {

			var pfkId uint
			for _, kh := range e.KandangHistory {
				if kh.KandangId == kandang.Id {
					pfkId = kh.Id
					break
				}
			}
			kandangSummaries[i] = KandangWithProjectFlockIdDTO{
				KandangBaseDTO:        kandangDTO.ToKandangBaseDTO(kandang),
				ProjectFlockKandangId: pfkId,
			}
		}
	}

	var areaSummary *areaDTO.AreaBaseDTO
	if e.Area.Id != 0 {
		mapped := areaDTO.ToAreaBaseDTO(e.Area)
		areaSummary = &mapped
	}

	var fcrSummary *fcrDTO.FcrBaseDTO
	if e.Fcr.Id != 0 {
		mapped := fcrDTO.ToFcrBaseDTO(e.Fcr)
		fcrSummary = &mapped
	}

	var locationSummary *locationDTO.LocationBaseDTO
	if e.Location.Id != 0 {
		mapped := locationDTO.ToLocationBaseDTO(e.Location)
		locationSummary = &mapped
	}

	var flockSummary *flockDTO.FlockBaseDTO
	if flock != nil && flock.Id != 0 {
		flockSummary = flock
	}

	latestApproval := defaultProjectFlockLatestApproval(e)
	if e.LatestApproval != nil {
		snapshot := approvalDTO.ToApprovalDTO(*e.LatestApproval)
		latestApproval = snapshot
	}

	return ProjectFlockListDTO{
		ProjectFlockBaseDTO: createProjectFlockBaseDTO(e),
		Flock:               flockSummary,
		Area:                areaSummary,
		Kandangs:            kandangSummaries,
		Category:            e.Category,
		Fcr:                 fcrSummary,
		Location:            locationSummary,
		CreatedAt:           e.CreatedAt,
		UpdatedAt:           e.UpdatedAt,
		CreatedUser:         createdUser,
		Approval:            latestApproval,
	}
}

func ToProjectFlockListDTOWithFlock(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO) ProjectFlockListDTO {
	return ToProjectFlockListDTO(e, flock)
}

func ToProjectFlockListDTOs(items []entity.ProjectFlock) []ProjectFlockListDTO {
	result := make([]ProjectFlockListDTO, len(items))
	for i, item := range items {
		result[i] = ToProjectFlockListDTO(item, nil)
	}
	return result
}

func ToProjectFlockListDTOsWithFlocks(items []entity.ProjectFlock, flocks map[uint]*entity.Flock) []ProjectFlockListDTO {
	result := make([]ProjectFlockListDTO, len(items))
	for i, item := range items {
		var flock *flockDTO.FlockBaseDTO
		if flocks != nil {
			if f := flocks[item.Id]; f != nil {
				flock = &flockDTO.FlockBaseDTO{
					Id:   f.Id,
					Name: f.Name,
				}
			}
		}
		result[i] = ToProjectFlockListDTOWithFlock(item, flock)
	}
	return result
}

func ToProjectFlockDetailDTO(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO) ProjectFlockDetailDTO {
	return ProjectFlockDetailDTO{
		ProjectFlockListDTO: ToProjectFlockListDTO(e, flock),
	}
}

func defaultProjectFlockLatestApproval(e entity.ProjectFlock) approvalDTO.ApprovalBaseDTO {
	result := approvalDTO.ApprovalBaseDTO{}

	step := utils.ProjectFlockStepPengajuan
	if step > 0 {
		result.StepNumber = uint16(step)
		if label, ok := approvalutils.ApprovalStepName(utils.ApprovalWorkflowProjectFlock, step); ok {
			result.StepName = label
		} else if label, ok := utils.ProjectFlockApprovalSteps[step]; ok {
			result.StepName = label
		}
	}

	if e.CreatedUser.Id != 0 {
		result.ActionBy = userDTO.ToUserBaseDTO(e.CreatedUser)
	} else if e.CreatedBy != 0 {
		result.ActionBy = userDTO.UserBaseDTO{
			Id:     e.CreatedBy,
			IdUser: int64(e.CreatedBy),
		}
	}

	return result
}

func createProjectFlockBaseDTO(e entity.ProjectFlock) ProjectFlockBaseDTO {
	return ProjectFlockBaseDTO{
		Id:        e.Id,
		Period:    e.Period,
		FlockName: e.FlockName,
	}
}

func ToFlockSummaryDTO(e entity.Flock) flockDTO.FlockBaseDTO {
	return flockDTO.FlockBaseDTO{
		Id:   e.Id,
		Name: e.Name,
	}
}

func ToFlockPeriodSummaryDTO(flock entity.Flock, next int) FlockPeriodDTO {
	return FlockPeriodDTO{
		Flock:      ToFlockSummaryDTO(flock),
		NextPeriod: next,
	}
}