feat: asset tags/ids (#142)

* add schema

* run db migration

* bulk seed asset IDs

* breaking: update runtime options

* conditionally increment asset IDs

* update API endpoints

* fix import asset id assignment

* refactor display + marshal/unmarshal

* add docs page

* add to form field

* hide 000-000 values

* update ENV vars

backend/internal/core/services/all.go

@@ -8,17 +8,38 @@ type AllServices struct {
 	Items *ItemService
 }
 
-func New(repos *repo.AllRepos) *AllServices {
+type OptionsFunc func(*options)
+
+type options struct {
+	autoIncrementAssetID bool
+}
+
+func WithAutoIncrementAssetID(v bool) func(*options) {
+	return func(o *options) {
+		o.autoIncrementAssetID = v
+	}
+}
+
+func New(repos *repo.AllRepos, opts ...OptionsFunc) *AllServices {
 	if repos == nil {
 		panic("repos cannot be nil")
 	}
 
+	options := &options{
+		autoIncrementAssetID: true,
+	}
+
+	for _, opt := range opts {
+		opt(options)
+	}
+
 	return &AllServices{
 		User:  &UserService{repos},
 		Group: &GroupService{repos},
 		Items: &ItemService{
-			repo: repos,
-			at:   attachmentTokens{},
+			repo:                 repos,
+			at:                   attachmentTokens{},
+			autoIncrementAssetID: options.autoIncrementAssetID,
 		},
 	}
 }

backend/internal/core/services/service_items.go

@@ -21,8 +21,49 @@ type ItemService struct {
 	// at is a map of tokens to attachment IDs. This is used to store the attachment ID
 	// for issued URLs
 	at attachmentTokens
+
+	autoIncrementAssetID bool
 }
 
+func (svc *ItemService) Create(ctx Context, item repo.ItemCreate) (repo.ItemOut, error) {
+	if svc.autoIncrementAssetID {
+		highest, err := svc.repo.Items.GetHighestAssetID(ctx, ctx.GID)
+		if err != nil {
+			return repo.ItemOut{}, err
+		}
+
+		item.AssetID = repo.AssetID(highest + 1)
+	}
+
+	return svc.repo.Items.Create(ctx, ctx.GID, item)
+}
+
+func (svc *ItemService) EnsureAssetID(ctx context.Context, GID uuid.UUID) (int, error) {
+	items, err := svc.repo.Items.GetAllZeroAssetID(ctx, GID)
+
+	if err != nil {
+		return 0, err
+	}
+
+	highest, err := svc.repo.Items.GetHighestAssetID(ctx, GID)
+	if err != nil {
+		return 0, err
+	}
+
+	finished := 0
+	for _, item := range items {
+		highest++
+
+		err = svc.repo.Items.SetAssetID(ctx, GID, item.ID, repo.AssetID(highest))
+		if err != nil {
+			return 0, err
+		}
+
+		finished++
+	}
+
+	return finished, nil
+}
 func (svc *ItemService) CsvImport(ctx context.Context, GID uuid.UUID, data [][]string) (int, error) {
 	loaded := []csvRow{}
 
@@ -114,6 +155,14 @@ func (svc *ItemService) CsvImport(ctx context.Context, GID uuid.UUID, data [][]s
 		}
 	}
 
+	highest := repo.AssetID(-1)
+	if svc.autoIncrementAssetID {
+		highest, err = svc.repo.Items.GetHighestAssetID(ctx, GID)
+		if err != nil {
+			return 0, err
+		}
+	}
+
 	// Create the items
 	var count int
 	for _, row := range loaded {
@@ -139,13 +188,20 @@ func (svc *ItemService) CsvImport(ctx context.Context, GID uuid.UUID, data [][]s
 			Str("location", row.Location).
 			Msgf("Creating Item: %s", row.Item.Name)
 
-		result, err := svc.repo.Items.Create(ctx, GID, repo.ItemCreate{
+		data := repo.ItemCreate{
 			ImportRef:   row.Item.ImportRef,
 			Name:        row.Item.Name,
 			Description: row.Item.Description,
 			LabelIDs:    labelIDs,
 			LocationID:  locationID,
-		})
+		}
+
+		if svc.autoIncrementAssetID {
+			highest++
+			data.AssetID = highest
+		}
+
+		result, err := svc.repo.Items.Create(ctx, GID, data)
 
 		if err != nil {
 			return count, err
@@ -156,6 +212,7 @@ func (svc *ItemService) CsvImport(ctx context.Context, GID uuid.UUID, data [][]s
 			// Edges
 			LocationID: locationID,
 			LabelIDs:   labelIDs,
+			AssetID:    data.AssetID,
 
 			// General Fields
 			ID:          result.ID,