stufflog3/internal/database/mysql/project.go

package mysql

import (
	"context"
	"database/sql"
	"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
	"golang.org/x/sync/errgroup"
)

type projectRepository struct {
	db      *sql.DB
	q       *mysqlcore.Queries
	items   *itemRepository
	scopeID int
}

func (r *projectRepository) Find(ctx context.Context, id int) (*models.Project, error) {
	row, err := r.q.GetProject(ctx, id)
	if err == sql.ErrNoRows || row.ScopeID != r.scopeID {
		return nil, slerrors.NotFound("Project")
	} else if err != nil {
		return nil, err
	}

	project := models.Project{
		ProjectEntry: models.ProjectEntry{
			ID:          row.ID,
			OwnerID:     row.AuthorID,
			CreatedTime: row.CreatedTime,
			Name:        row.Name,
			Status:      models.Status(row.Status),
		},
		Description:  row.Description,
		Requirements: []models.ProjectRequirement{},
	}

	reqs, err := r.q.ListProjectRequirementsByProjectID(ctx, id)
	if err != nil && err != sql.ErrNoRows {
		return nil, err
	}
	itemRows, err := r.q.ListItemsByProject(ctx, id)
	if err != nil && err != sql.ErrNoRows {
		return nil, err
	}
	items := make([]models.Item, 0, len(itemRows))
	for _, itemRow := range itemRows {
		item := r.items.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(itemRow))
		items = append(items, item)
	}

	err = r.items.fillStats(ctx, items)
	if err != nil {
		return nil, err
	}

	eg, ctx := errgroup.WithContext(ctx)

	for i := range reqs {
		project.Requirements = append(project.Requirements, models.ProjectRequirement{
			ID:          reqs[i].ID,
			Name:        reqs[i].Name,
			Description: reqs[i].Description,
			Status:      models.Status(reqs[i].Status),
			Stats:       []models.StatProgressEntry{},
			Items:       nil,
		})
		requirement := &project.Requirements[len(project.Requirements)-1]
		for _, item := range items {
			if *item.ProjectRequirementID == requirement.ID {
				requirement.Items = append(requirement.Items, item)
			}
		}

		eg.Go(func() error {
			stats, err := r.q.ListProjectRequirementStats(ctx, requirement.ID)
			if err != nil && err != sql.ErrNoRows {
				return err
			}

			for _, statRow := range stats {
				stat := models.StatProgressEntry{
					StatEntry: models.StatEntry{
						ID:     statRow.ID,
						Name:   statRow.Name,
						Weight: statRow.Weight,
					},
					Acquired: 0,
					Required: int(statRow.Required.Int32),
				}

				for _, item := range requirement.Items {
					for _, stat2 := range item.Stats {
						if stat2.ID == stat.ID {
							stat.Acquired += stat2.Acquired
						}
					}
				}

				requirement.Stats = append(requirement.Stats, stat)
			}

			return nil
		})
	}

	err = eg.Wait()
	if err != nil {
		return nil, err
	}

	return &project, nil
}

func (r *projectRepository) List(ctx context.Context) ([]models.ProjectEntry, error) {
	rows, err := r.q.ListProjectEntries(ctx, r.scopeID)
	if err != nil && err != sql.ErrNoRows {
		return nil, err
	}

	projects := make([]models.ProjectEntry, 0, len(rows))
	for _, row := range rows {
		projects = append(projects, models.ProjectEntry{
			ID:          row.ID,
			OwnerID:     row.AuthorID,
			CreatedTime: row.CreatedTime,
			Name:        row.Name,
			Status:      models.Status(row.Status),
		})
	}

	return projects, nil
}

func (r *projectRepository) Create(ctx context.Context, project models.Project) (*models.Project, error) {
	res, err := r.q.InsertProject(ctx, mysqlcore.InsertProjectParams{
		ScopeID:     r.scopeID,
		AuthorID:    project.OwnerID,
		Name:        project.Name,
		Status:      int(project.Status),
		Description: project.Description,
		CreatedTime: project.CreatedTime,
	})
	if err != nil {
		return nil, err
	}

	id, err := res.LastInsertId()
	if err != nil {
		return nil, err
	}

	return r.Find(ctx, int(id))
}

func (r *projectRepository) Update(ctx context.Context, project models.Project) (*models.Project, error) {
	//TODO implement me
	panic("implement me")
}

func (r *projectRepository) Delete(ctx context.Context, project models.ProjectEntry) error {
	//TODO implement me
	panic("implement me")
}

func (r *projectRepository) AddRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement) {
	//TODO implement me
	panic("implement me")
}

func (r *projectRepository) UpdateRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement, update models.ProjectRequirementUpdate) {
	//TODO implement me
	panic("implement me")
}

func (r *projectRepository) DeleteRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement, deleteItems bool) {
	//TODO implement me
	panic("implement me")
}