stufflog3/internal/database/mysql/scopes.go

package mysql

import (
	"context"
	"database/sql"
	"encoding/json"
	"golang.org/x/sync/errgroup"
	"sort"

	"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"
)

type scopeRepository struct {
	db *sql.DB
}

func (r *scopeRepository) Find(ctx context.Context, id int) (*models.Scope, error) {
	q := mysqlcore.New(r.db)
	scope, err := q.GetScope(ctx, id)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, slerrors.NotFound("Scope")
		}

		return nil, err
	}

	res := &models.Scope{
		ScopeEntry: models.ScopeEntry{
			ID:           scope.ID,
			Name:         scope.Name,
			Abbreviation: scope.Abbreviation,
		},
	}

	eg, ctx := errgroup.WithContext(ctx)

	eg.Go(func() error {
		members, err := q.ListScopeMembers(ctx, id)
		if err != nil && err != sql.ErrNoRows {
			return err
		}

		for _, member := range members {
			res.Members = append(res.Members, models.ScopeMember{
				ID:    member.UserID,
				Name:  member.Name,
				Owner: member.Owner,
			})
		}

		return nil
	})

	eg.Go(func() error {
		projects, err := q.ListProjectEntries(ctx, id)
		if err != nil && err != sql.ErrNoRows {
			return err
		}

		for _, project := range projects {
			res.Projects = append(res.Projects, models.ProjectEntry{
				ID:     project.ID,
				Name:   project.Name,
				Status: models.Status(project.Status),
			})
		}

		return nil
	})

	eg.Go(func() error {
		stats, err := q.ListStats(ctx, id)
		if err != nil && err != sql.ErrNoRows {
			return err
		}

		for _, stat := range stats {
			var amounts map[string]int
			if stat.AllowedAmounts.Valid {
				amounts = make(map[string]int)
				err := json.Unmarshal(stat.AllowedAmounts.RawMessage, &amounts)
				if err != nil {
					return err
				}
			}

			res.Stats = append(res.Stats, models.Stat{
				StatEntry: models.StatEntry{
					ID:     stat.ID,
					Name:   stat.Name,
					Weight: stat.Weight,
				},
				Description:    stat.Description,
				AllowedAmounts: amounts,
			})
		}

		return nil
	})

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

	return res, nil
}

func (r *scopeRepository) List(ctx context.Context) ([]models.ScopeEntry, error) {
	q := mysqlcore.New(r.db)
	scopes, err := q.ListScopes(ctx)
	if err != nil {
		return nil, err
	}

	res := make([]models.ScopeEntry, 0, len(scopes))
	for _, scope := range scopes {
		res = append(res, models.ScopeEntry{
			ID:           scope.ID,
			Name:         scope.Name,
			Abbreviation: scope.Abbreviation,
		})
	}

	return res, nil
}

func (r *scopeRepository) ListByUser(ctx context.Context, userID string) ([]models.ScopeEntry, error) {
	q := mysqlcore.New(r.db)
	scopes, err := q.ListScopesByUser(ctx, userID)
	if err != nil {
		return nil, err
	}

	res := make([]models.ScopeEntry, 0, len(scopes))
	for _, scope := range scopes {
		res = append(res, models.ScopeEntry{
			ID:           scope.ID,
			Name:         scope.Name,
			Abbreviation: scope.Abbreviation,
		})
	}

	return res, nil
}

func (r *scopeRepository) Create(ctx context.Context, scope models.ScopeEntry, owner models.ScopeMember) (*models.Scope, error) {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return nil, err
	}
	defer tx.Rollback()

	q := mysqlcore.New(tx)
	res, err := q.InsertScope(ctx, mysqlcore.InsertScopeParams(scope))
	if err != nil {
		return nil, err
	}
	id, err := res.LastInsertId()
	if err != nil {
		return nil, err
	}

	err = q.UpdateScopeMember(ctx, mysqlcore.UpdateScopeMemberParams{
		ScopeID: int(id),
		UserID:  owner.ID,
		Name:    owner.Name,
		Owner:   true,
	})

	err = tx.Commit()
	if err != nil {
		return nil, err
	}

	return &models.Scope{
		ScopeEntry: models.ScopeEntry{
			ID:           int(id),
			Name:         scope.Name,
			Abbreviation: scope.Abbreviation,
		},
		DisplayName: owner.Name,
		Members: []models.ScopeMember{
			{
				ID:    owner.ID,
				Name:  owner.Name,
				Owner: true,
			},
		},
		Projects: []models.ProjectEntry{},
		Stats:    []models.Stat{},
	}, nil
}

func (r *scopeRepository) Update(ctx context.Context, scope models.ScopeEntry) error {
	return mysqlcore.New(r.db).UpdateScope(ctx, mysqlcore.UpdateScopeParams{
		Name:         scope.Name,
		Abbreviation: scope.Abbreviation,
		ID:           scope.ID,
	})
}

func (r *scopeRepository) Delete(ctx context.Context, scope models.Scope) error {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}
	defer tx.Rollback()

	q := mysqlcore.New(tx)
	err = q.DeleteAllScopeMembers(ctx, scope.ID)
	if err != nil {
		return err
	}
	err = q.DeleteScope(ctx, scope.ID)
	if err != nil {
		return err
	}

	return tx.Commit()
}

func (r *scopeRepository) UpdateMember(ctx context.Context, scope models.Scope, member models.ScopeMember) (*models.Scope, error) {
	err := mysqlcore.New(r.db).UpdateScopeMember(ctx, mysqlcore.UpdateScopeMemberParams{
		ScopeID: scope.ID,
		UserID:  member.ID,
		Name:    member.Name,
		Owner:   member.Owner,
	})
	if err != nil {
		return nil, err
	}

	found := false
	scope.Members = append(scope.Members[:0:0], scope.Members...)
	for i, member2 := range scope.Members {
		if member2.ID == member.ID {
			scope.Members[i] = member2
			found = true
		}
	}
	if !found {
		scope.Members = append(scope.Members, member)
		sort.Slice(scope.Members, func(i, j int) bool {
			return scope.Members[i].Name < scope.Members[j].Name
		})
	}

	return &scope, nil
}

func (r *scopeRepository) DeleteMember(ctx context.Context, scope models.Scope, userID string) (*models.Scope, error) {
	err := mysqlcore.New(r.db).DeleteScopeMember(ctx, mysqlcore.DeleteScopeMemberParams{
		ScopeID: scope.ID,
		UserID:  userID,
	})
	if err != nil {
		return nil, err
	}

	newMembers := make([]models.ScopeMember, 0, len(scope.Members)-1)
	for _, member := range scope.Members {
		if member.ID != userID {
			newMembers = append(newMembers, member)
		}
	}
	scope.Members = newMembers

	return &scope, nil
}