Move instances into a separate component

internal/component/instances/instances.go

@@ -0,0 +1,143 @@
+package instances
+
+import (
+	"errors"
+
+	"github.com/FAU-CDI/wisski-distillery/internal/bookkeeping"
+	"github.com/FAU-CDI/wisski-distillery/internal/component"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/sql"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/triplestore"
+	"github.com/tkw1536/goprogram/exit"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// Instances manages multiple WissKI Instances.
+type Instances struct {
+	component.ComponentBase
+
+	TS  *triplestore.Triplestore
+	SQL *sql.SQL
+}
+
+func (Instances) Name() string {
+	return "instances"
+}
+
+// ErrWissKINotFound is returned when a WissKI is not found
+var ErrWissKINotFound = errors.New("WissKI not found")
+
+var errSQL = exit.Error{
+	Message:  "Unknown SQL Error %s",
+	ExitCode: exit.ExitGeneric,
+}
+
+// WissKI returns the WissKI with the provided slug, if it exists.
+// It the WissKI does not exist, returns ErrWissKINotFound.
+func (instances *Instances) WissKI(slug string) (i WissKI, err error) {
+	sql := instances.SQL
+	if err := sql.Wait(); err != nil {
+		return i, err
+	}
+
+	table, err := sql.OpenBookkeeping(false)
+	if err != nil {
+		return i, err
+	}
+
+	// find the instance by slug
+	query := table.Where(&bookkeeping.Instance{Slug: slug}).Find(&i.Instance)
+	switch {
+	case query.Error != nil:
+		return i, errSQL.WithMessageF(query.Error)
+	case query.RowsAffected == 0:
+		return i, ErrWissKINotFound
+	default:
+		i.instances = instances
+		return i, nil
+	}
+}
+
+// Has checks if a WissKI with the provided slug exists inside the database.
+// It does not perform any checks on the WissKI itself.
+func (instances *Instances) Has(slug string) (ok bool, err error) {
+	sql := instances.SQL
+	if err := sql.Wait(); err != nil {
+		return false, err
+	}
+
+	table, err := sql.OpenBookkeeping(false)
+	if err != nil {
+		return false, err
+	}
+
+	query := table.Select("count(*) > 0").Where("slug = ?", slug).Find(&ok)
+	if query.Error != nil {
+		return false, errSQL.WithMessageF(query.Error)
+	}
+	return
+}
+
+// All returns all instances of the WissKI Distillery in consistent order.
+//
+// There is no guarantee that this order remains identical between different api releases; however subsequent invocations are guaranteed to return the same order.
+func (instances *Instances) All() ([]WissKI, error) {
+	return instances.find(true, func(table *gorm.DB) *gorm.DB {
+		return table
+	})
+}
+
+// WissKIs returns the WissKI instances with the provides slugs.
+// If a slug does not exist, it is omitted from the result.
+func (instances *Instances) WissKIs(slugs ...string) ([]WissKI, error) {
+	return instances.find(true, func(table *gorm.DB) *gorm.DB {
+		return table.Where("slug IN ?", slugs)
+	})
+}
+
+// Load is like All, except that when no slugs are provided, it calls All.
+func (instances *Instances) Load(slugs ...string) ([]WissKI, error) {
+	if len(slugs) == 0 {
+		return instances.All()
+	}
+	return instances.WissKIs(slugs...)
+}
+
+// find finds instances based on the provided query
+func (instances *Instances) find(order bool, query func(table *gorm.DB) *gorm.DB) (results []WissKI, err error) {
+	sql := instances.SQL
+	if err := sql.Wait(); err != nil {
+		return nil, err
+	}
+
+	// open the bookkeeping table
+	table, err := sql.OpenBookkeeping(false)
+	if err != nil {
+		return nil, err
+	}
+
+	// prepare a query
+	find := table
+	if order {
+		find = find.Order(clause.OrderByColumn{Column: clause.Column{Name: "slug"}, Desc: false})
+	}
+	if query != nil {
+		find = query(find)
+	}
+
+	// fetch bookkeeping instances
+	var bks []bookkeeping.Instance
+	find = find.Find(&bks)
+	if find.Error != nil {
+		return nil, errSQL.WithMessageF(find.Error)
+	}
+
+	// make proper instances
+	results = make([]WissKI, len(bks))
+	for i, bk := range bks {
+		results[i].Instance = bk
+		results[i].instances = instances
+	}
+
+	return results, nil
+}