stufflog3/usecases/projects/result.go

package projects

import (
	"git.aiterp.net/stufflog3/stufflog3/entities"
	"git.aiterp.net/stufflog3/stufflog3/models"
	"time"
)

type Entry struct {
	ID          int           `json:"id"`
	OwnerID     string        `json:"ownerId"`
	CreatedTime time.Time     `json:"createdTime"`
	Name        string        `json:"name"`
	Status      models.Status `json:"status"`
}

func generateEntry(project entities.Project) Entry {
	return Entry{
		ID:          project.ID,
		OwnerID:     project.OwnerID,
		CreatedTime: project.CreatedTime,
		Name:        project.Name,
		Status:      project.Status,
	}
}

type Result struct {
	entities.Project
	Requirements []ResultRequirement `json:"requirements"`
}

func GenerateResult(
	project entities.Project,
	requirement []entities.Requirement,
	requirementStats []entities.RequirementStat,
	items []entities.Item,
	itemProgresses []entities.ItemProgress,
	stats []entities.Stat,
) Result {
	res := Result{
		Project:      project,
		Requirements: make([]ResultRequirement, 0, 8),
	}

	for _, req := range requirement {
		if req.ProjectID != project.ID {
			continue
		}

		resReq := ResultRequirement{
			ID:          req.ID,
			Name:        req.Name,
			Description: req.Description,
			Status:      req.Status,
			Stats:       make([]ResultRequirementStat, 0, 8),
			Items:       make([]ResultRequirementItem, 0, 8),
		}
		statIndices := make(map[int]int)
		for _, reqStat := range requirementStats {
			if reqStat.RequirementID != req.ID {
				continue
			}

			resStat := ResultRequirementStat{
				ID:       reqStat.StatID,
				Required: reqStat.Required,
			}
			for _, stat := range stats {
				if stat.ID == resStat.ID {
					resStat.Name = stat.Name
					resStat.Weight = stat.Weight
					break
				}
			}

			resReq.Stats = append(resReq.Stats, resStat)
			statIndices[reqStat.StatID] = len(resReq.Stats) - 1
		}

		for _, item := range items {
			if item.ProjectRequirementID == nil || *item.ProjectRequirementID != req.ID {
				continue
			}

			resItem := ResultRequirementItem{
				Item:  item,
				Stats: make([]ResultRequirementStat, 0, 8),
			}
			for _, itemProgress := range itemProgresses {
				if itemProgress.ItemID != item.ID {
					continue
				}

				resStat := ResultRequirementStat{
					ID:       itemProgress.StatID,
					Acquired: itemProgress.Acquired,
					Required: itemProgress.Required,
				}
				for _, stat := range stats {
					if stat.ID == resStat.ID {
						resStat.Name = stat.Name
						resStat.Weight = stat.Weight
						break
					}
				}
				if si, ok := statIndices[resStat.ID]; ok {
					resReq.Stats[si].Acquired += itemProgress.Acquired
				}

				resItem.Stats = append(resItem.Stats, resStat)
			}

			resReq.Items = append(resReq.Items, resItem)
		}

		res.Requirements = append(res.Requirements, resReq)
	}

	return res
}

type ResultRequirement struct {
	ID          int                     `json:"id"`
	Name        string                  `json:"name"`
	Description string                  `json:"description"`
	Status      models.Status           `json:"status"`
	Stats       []ResultRequirementStat `json:"stats"`
	Items       []ResultRequirementItem `json:"items"`
}

type ResultRequirementStat struct {
	ID       int     `json:"id"`
	Name     string  `json:"name"`
	Weight   float64 `json:"weight"`
	Acquired int     `json:"acquired"`
	Required int     `json:"required"`
}

type ResultRequirementItem struct {
	entities.Item

	Stats []ResultRequirementStat `json:"stats"`
}