Relationen, fehlt -PreferredTitle für Entries -Überflüssige Felder in Contents

migrations/1738936648_items.go

@@ -0,0 +1,73 @@
+package migrations
+
+import (
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/pocketbase/pocketbase/core"
+	m "github.com/pocketbase/pocketbase/migrations"
+)
+
+func init() {
+	m.Register(func(app core.App) error {
+		items := itemsTable()
+		items.Fields = itemsFields(app)
+		itemsIndexes(items)
+
+		return app.Save(items)
+	}, func(app core.App) error {
+		items, err := app.FindCollectionByNameOrId(dbmodels.ITEMS_TABLE)
+		if err != nil {
+			return nil
+		}
+
+		return app.Delete(items)
+	})
+}
+
+func itemsTable() *core.Collection {
+	collection := core.NewBaseCollection(dbmodels.ITEMS_TABLE)
+	setBasicPublicRules(collection)
+	return collection
+}
+
+func itemsFields(app core.App) core.FieldsList {
+	bcoll, err := app.FindCollectionByNameOrId(dbmodels.ENTRIES_TABLE)
+	if err != nil {
+		panic(err)
+	}
+
+	fields := core.NewFieldsList(
+		&core.RelationField{Name: dbmodels.ENTRIES_TABLE, CollectionId: bcoll.Id, Required: false},
+		&core.TextField{Name: dbmodels.ITEMS_IDENTIFIER_FIELD, Required: true, Presentable: true},
+		&core.TextField{Name: dbmodels.ITEMS_LOCATION_FIELD, Required: false, Presentable: true},
+		&core.TextField{Name: dbmodels.ITEMS_OWNER_FIELD, Required: false, Presentable: false},
+		&core.SelectField{
+			Name:        dbmodels.ITEMS_MEDIA_FIELD,
+			Required:    false,
+			Presentable: true,
+			Values:      dbmodels.ITEM_TYPE_VALUES,
+			MaxSelect:   len(dbmodels.ITEM_TYPE_VALUES) - 1,
+		},
+		&core.TextField{Name: dbmodels.ITEMS_CONDITION_FIELD, Required: false, Presentable: true},
+		&core.FileField{
+			Name:      dbmodels.SCAN_FIELD,
+			Required:  false,
+			MaxSize:   100 * 1024 * 1024,
+			MaxSelect: 1000,
+			MimeTypes: dbmodels.MUSENALM_MIME_TYPES,
+			Thumbs:    []string{"0x300", "0x500", "0x1000", "300x0", "500x0", "1000x0"},
+		}, // 100 MB a file
+		&core.URLField{Name: dbmodels.URI_FIELD, Required: false, Presentable: false},
+	)
+
+	setNotesAndAnnotationsField(&fields)
+
+	return fields
+}
+
+func itemsIndexes(collection *core.Collection) {
+	addIndex(collection, dbmodels.ITEMS_CONDITION_FIELD, false)
+	addIndex(collection, dbmodels.ITEMS_OWNER_FIELD, false)
+	addIndex(collection, dbmodels.ITEMS_LOCATION_FIELD, false)
+	addIndex(collection, dbmodels.ITEMS_IDENTIFIER_FIELD, false)
+	addIndex(collection, dbmodels.URI_FIELD, false)
+}

migrations/1738942133_partials.go

@@ -2,6 +2,8 @@ package migrations
 
 import (
 	"errors"
+	"maps"
+	"slices"
 
 	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/pocketbase/pocketbase/core"
@@ -21,7 +23,7 @@ func init() {
 
 		return app.Save(partials)
 	}, func(app core.App) error {
-		partials, err := app.FindCollectionByNameOrId(dbmodels.PARTIALS_TABLE)
+		partials, err := app.FindCollectionByNameOrId(dbmodels.CONTENTS_TABLE)
 		if err != nil {
 			return nil
 		}
@@ -31,7 +33,7 @@ func init() {
 }
 
 func partialsTable() *core.Collection {
-	collection := core.NewBaseCollection(dbmodels.PARTIALS_TABLE)
+	collection := core.NewBaseCollection(dbmodels.CONTENTS_TABLE)
 	setBasicPublicRules(collection)
 	return collection
 }
@@ -46,7 +48,7 @@ func partialsFields(app core.App) *core.FieldsList {
 		// Title information
 		&core.TextField{Name: dbmodels.PREFERRED_TITLE_FIELD, Required: true, Presentable: true},
 		&core.TextField{Name: dbmodels.VARIANT_TITLE_FIELD, Required: false, Presentable: false},
-		&core.BoolField{Name: dbmodels.PARALLEL_TITLE_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.PARALLEL_TITLE_FIELD, Required: false},
 
 		// Transcribed information
 		&core.TextField{Name: dbmodels.TITLE_STMT_FIELD, Required: false, Presentable: false},
@@ -101,7 +103,7 @@ func partialsFields(app core.App) *core.FieldsList {
 		&core.SelectField{
 			Name:      dbmodels.MUSENALM_PAGINATION_FIELD,
 			Required:  false,
-			Values:    dbmodels.MUSENALM_PAGINATION_VALUES,
+			Values:    slices.Collect(maps.Values(dbmodels.MUSENALM_PAGINATION_VALUES)),
 			MaxSelect: len(dbmodels.MUSENALM_PAGINATION_VALUES),
 		},
 		&core.FileField{

migrations/1738951458_r_partials_agents.go

@@ -8,14 +8,14 @@ import (
 
 func init() {
 	m.Register(func(app core.App) error {
-		collections, err := basicRelationCollection(app, dbmodels.PARTIALS_TABLE, dbmodels.AGENTS_TABLE, dbmodels.AGENT_RELATIONS)
+		collections, err := basicRelationCollection(app, dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE, dbmodels.AGENT_RELATIONS)
 		if err != nil {
 			return err
 		}
 
 		return app.Save(collections)
 	}, func(app core.App) error {
-		collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.PARTIALS_TABLE, dbmodels.AGENTS_TABLE))
+		collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE))
 		if err != nil {
 			return nil
 		}

migrations/1739007272_insert_data.go

@@ -1,6 +1,8 @@
 package migrations
 
 import (
+	"sync"
+
 	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/Theodor-Springmann-Stiftung/musenalm/migrations/seed"
 	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
@@ -10,17 +12,98 @@ import (
 
 func init() {
 	m.Register(func(app core.App) error {
-		adb, err := xmlmodels.ReadAccessDB(xmlmodels.DATA_PATH)
+		adb, err := xmlmodels.ReadAccessDB(xmlmodels.DATA_PATH, app.Logger())
 		if err != nil {
 			return err
 		}
 
-		*adb.Reihen = xmlmodels.SanitizeReihen(*adb.Reihen, *adb.Relationen_Bände_Reihen)
+		adb.Reihen = xmlmodels.SanitizeReihen(adb.Reihen, adb.Relationen_Bände_Reihen)
+
+		wg := sync.WaitGroup{}
+		wg.Add(3)
+		go func() {
+			if records, err := seed.RecordsFromAkteure(app, adb.Akteure); err == nil {
+				if err = seed.BatchSave(app, records); err != nil {
+					panic(err)
+				}
+			} else {
+				panic(err)
+			}
+			wg.Done()
+		}()
+
+		go func() {
+			if records, err := seed.RecordsFromOrte(app, adb.Orte); err == nil {
+				if err = seed.BatchSave(app, records); err != nil {
+					panic(err)
+				}
+			} else {
+				panic(err)
+			}
+			wg.Done()
+		}()
+
+		go func() {
+			if records, err := seed.RecordsFromReihentitel(app, adb.Reihen); err == nil {
+				if err = seed.BatchSave(app, records); err != nil {
+					panic(err)
+				}
+			} else {
+				panic(err)
+			}
+			wg.Done()
+		}()
+
+		wg.Wait()
+
+		if records, err := seed.RecordsFromBände(app, adb.Bände, adb.Orte); err == nil {
+			if err = seed.BatchSave(app, records); err != nil {
+				panic(err)
+			}
+		} else {
+			panic(err)
+		}
+
+		if records, err := seed.ItemsFromBändeAndBIBLIO(app, adb.Bände, adb.BIBLIO); err == nil {
+			if err = seed.BatchSave(app, records); err != nil {
+				panic(err)
+			}
+		} else {
+			panic(err)
+		}
+
+		if records, err := seed.RecordsFromInhalte(app, adb.Inhalte); err == nil {
+			if err = seed.BatchSave(app, records); err != nil {
+				panic(err)
+			}
+		} else {
+			panic(err)
+		}
+
+		if records, err := seed.RecordsFromRelationBändeReihen(app, adb.Relationen_Bände_Reihen); err == nil {
+			if err = seed.BatchSave(app, records); err != nil {
+				panic(err)
+			}
+		} else {
+			panic(err)
+		}
+
+		if records, err := seed.RecordsFromRelationBändeAkteure(app, adb.Relationen_Bände_Akteure); err == nil {
+			if err = seed.BatchSave(app, records); err != nil {
+				panic(err)
+			}
+		} else {
+			panic(err)
+		}
+
+		if records, err := seed.RecordsFromRelationInhalteAkteure(app, adb.Relationen_Inhalte_Akteure); err == nil {
+			if err = seed.BatchSave(app, records); err != nil {
+				panic(err)
+			}
+		} else {
+			panic(err)
+		}
 
-		seed.SeedTableAgents(app, *adb.Akteure)
-		seed.SeedTablePlaces(app, *adb.Orte)
-		seed.SeedTableSeries(app, *adb.Reihen)
-		seed.SeedTableEntries(app, *adb.Bände, *adb.BIBLIO, *adb.Orte)
 		return nil
 	}, func(app core.App) error {
 		return delete_data(app)
@@ -30,8 +113,8 @@ func init() {
 func delete_data(app core.App) error {
 	_ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE))
 	_ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE))
-	_ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.PARTIALS_TABLE, dbmodels.AGENTS_TABLE))
-	_ = deleteTableContents(app, dbmodels.PARTIALS_TABLE)
+	_ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE))
+	_ = deleteTableContents(app, dbmodels.CONTENTS_TABLE)
 	_ = deleteTableContents(app, dbmodels.ENTRIES_TABLE)
 	_ = deleteTableContents(app, dbmodels.SERIES_TABLE)
 	_ = deleteTableContents(app, dbmodels.AGENTS_TABLE)

migrations/seed/agents.go

@@ -8,11 +8,12 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )
 
-func SeedTableAgents(app core.App, akteure xmlmodels.Akteure) error {
+func RecordsFromAkteure(app core.App, akteure xmlmodels.Akteure) ([]*core.Record, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.AGENTS_TABLE)
 	records := make([]*core.Record, 0, len(akteure.Akteure))
 	if err != nil {
 		fmt.Println(err)
+		return records, err
 	}
 
 	for i := 0; i < len(akteure.Akteure); i++ {
@@ -37,5 +38,5 @@ func SeedTableAgents(app core.App, akteure xmlmodels.Akteure) error {
 		records = append(records, record)
 	}
 
-	return batchSave(app, records)
+	return records, nil
 }

migrations/seed/common.go

@@ -13,7 +13,7 @@ func NormalizeString(s string) string {
 	return s
 }
 
-func batchSave(app core.App, records []*core.Record) error {
+func BatchSave(app core.App, records []*core.Record) error {
 	app.RunInTransaction(func(txapp core.App) error {
 		for _, record := range records {
 			if err := txapp.Save(record); err != nil {

migrations/seed/entries.go

@@ -2,8 +2,6 @@ package seed
 
 import (
 	"fmt"
-	"regexp"
-	"strconv"
 	"strings"
 
 	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
@@ -12,24 +10,23 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )
 
-func SeedTableEntries(
+func RecordsFromBände(
 	app core.App,
 	entries xmlmodels.Bände,
-	biblio map[int]xmlmodels.BIBLIOEintrag,
 	orte xmlmodels.Orte,
-) error {
+) ([]*core.Record, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.ENTRIES_TABLE)
 	records := make([]*core.Record, 0, len(entries.Bände))
-	r := regexp.MustCompile("\\d{6}")
 	if err != nil {
 		fmt.Println(err)
+		return records, err
 	}
 
 	omap := datatypes.MakeMap(orte.Orte, func(o xmlmodels.Ort) string { return o.ID })
 	ocoll, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE)
 	if err != nil {
 		app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.PLACES_TABLE)
-		return err
+		return records, err
 	}
 
 	for i := 0; i < len(entries.Bände); i++ {
@@ -68,13 +65,12 @@ func SeedTableEntries(
 		}
 
 		handleDeprecated(record, band)
-		handleItems(r, band, &biblio, record)
 		handleOrte(record, band, omap, app, ocoll)
 
 		records = append(records, record)
 	}
 
-	return batchSave(app, records)
+	return records, nil
 }
 
 func handleOrte(
@@ -134,91 +130,3 @@ func handleDeprecated(record *core.Record, band xmlmodels.Band) {
 
 	record.Set(dbmodels.MUSENALM_DEPRECATED_FIELD, depr)
 }
-
-func handleItems(r *regexp.Regexp, band xmlmodels.Band, biblio *map[int]xmlmodels.BIBLIOEintrag, record *core.Record) {
-	nst := NormalizeString(band.Norm)
-	matches := r.FindAllStringSubmatchIndex(nst, -1)
-	t := map[string]string{}
-	for i, m := range matches {
-		nr := nst[m[0]:m[1]]
-		end := len(nst)
-
-		if m[1] >= len(nst) {
-			t[nr] = ""
-			continue
-		}
-
-		if len(matches)-1 > i {
-			end = matches[i+1][0]
-		}
-
-		rest := nst[m[1]:end]
-		var last []rune
-
-		for y, c := range rest {
-			if c == '\\' && y < len(rest)-1 && rest[y+1] == ')' {
-				break
-			}
-			if c != '(' && c != ')' {
-				last = append(last, c)
-			}
-		}
-
-		if last != nil && len(last) > 0 {
-			t[nr] = string(last)
-		}
-	}
-
-	var exemlist []dbmodels.Exemplar
-
-	if band.BiblioID != 0 {
-		exem := dbmodels.Exemplar{Identifier: strconv.Itoa(band.BiblioID)}
-		if e, ok := (*biblio)[band.BiblioID]; ok {
-			exem.Location = strings.TrimSpace(e.Standort)
-			exem.Condition = strings.TrimSpace(e.Zustand)
-			message := ""
-			message = appendMessage(e.NotizÄusseres, message)
-			message = appendMessage(e.NotizInhalt, message)
-			message = appendMessage(e.Anmerkungen, message)
-			exem.Annotation = message
-		}
-
-		exemlist = append(exemlist, exem)
-	}
-
-	for nr, m := range t {
-		exem := dbmodels.Exemplar{Identifier: nr}
-
-		no, err := strconv.Atoi(strings.TrimSpace(nr))
-		message := strings.TrimSpace(m)
-		if err != nil {
-			if e, ok := (*biblio)[no]; ok {
-				exem.Location = strings.TrimSpace(e.Standort)
-				exem.Condition = strings.TrimSpace(e.Zustand)
-				message = appendMessage(e.NotizÄusseres, message)
-				message = appendMessage(e.NotizInhalt, message)
-				message = appendMessage(e.Anmerkungen, message)
-			}
-		}
-		exem.Annotation = message
-
-		if exem.Identifier != "" {
-			exemlist = append(exemlist, exem)
-		}
-	}
-
-	if len(exemlist) > 0 {
-		record.Set(dbmodels.ITEMS_TABLE, exemlist)
-	}
-}
-
-func appendMessage(message string, toAppend string) string {
-	notiza := strings.TrimSpace(toAppend)
-	if notiza != "" {
-		if message != "" {
-			message += "\n"
-		}
-		message += notiza
-	}
-	return message
-}

migrations/seed/items.go

@@ -0,0 +1,144 @@
+package seed
+
+import (
+	"fmt"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func ItemsFromBändeAndBIBLIO(
+	app core.App,
+	entries xmlmodels.Bände,
+	biblio map[int]xmlmodels.BIBLIOEintrag,
+) ([]*core.Record, error) {
+	collection, err := app.FindCollectionByNameOrId(dbmodels.ITEMS_TABLE)
+	records := make([]*core.Record, 0, len(entries.Bände))
+	r := regexp.MustCompile("\\d{6}")
+	if err != nil {
+		fmt.Println(err)
+		return records, err
+	}
+
+	for i := 0; i < len(entries.Bände); i++ {
+		band := entries.Bände[i]
+		banddb, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, band.ID)
+		if err != nil {
+			app.Logger().Error("Error finding record", "error", err, "collection", dbmodels.ENTRIES_TABLE, "field", dbmodels.MUSENALMID_FIELD, "value", band.ID)
+			continue
+		}
+
+		nst := NormalizeString(band.Norm)
+		matches := r.FindAllStringSubmatchIndex(nst, -1)
+		t := map[string]string{}
+		for i, m := range matches {
+			nr := nst[m[0]:m[1]]
+			end := len(nst)
+
+			if m[1] >= len(nst) {
+				t[nr] = ""
+				continue
+			}
+
+			if len(matches)-1 > i {
+				end = matches[i+1][0]
+			}
+
+			rest := nst[m[1]:end]
+			var last []rune
+
+			for y, c := range rest {
+				if c == '\\' && y < len(rest)-1 && rest[y+1] == ')' {
+					break
+				}
+				if c != '(' && c != ')' {
+					last = append(last, c)
+				}
+			}
+
+			if last != nil && len(last) > 0 {
+				t[nr] = string(last)
+			}
+		}
+
+		var exemlist []dbmodels.Exemplar
+
+		if band.BiblioID != 0 {
+			exem := dbmodels.Exemplar{Identifier: strconv.Itoa(band.BiblioID)}
+			if e, ok := biblio[band.BiblioID]; ok {
+				exem.Location = strings.TrimSpace(e.Standort)
+				exem.Condition = strings.TrimSpace(e.Zustand)
+				message := ""
+				message = appendMessage(e.NotizÄusseres, message)
+				message = appendMessage(e.NotizInhalt, message)
+				message = appendMessage(e.Anmerkungen, message)
+				exem.Annotation = message
+			}
+
+			exemlist = append(exemlist, exem)
+		}
+
+		for nr, m := range t {
+			exem := dbmodels.Exemplar{Identifier: nr}
+
+			no, err := strconv.Atoi(strings.TrimSpace(nr))
+			message := strings.TrimSpace(m)
+			if err != nil {
+				if e, ok := biblio[no]; ok {
+					exem.Location = strings.TrimSpace(e.Standort)
+					exem.Condition = strings.TrimSpace(e.Zustand)
+					message = appendMessage(e.NotizÄusseres, message)
+					message = appendMessage(e.NotizInhalt, message)
+					message = appendMessage(e.Anmerkungen, message)
+				}
+			}
+			exem.Annotation = message
+
+			if exem.Identifier != "" {
+				exemlist = append(exemlist, exem)
+			}
+		}
+
+		if len(exemlist) > 0 {
+			for _, exem := range exemlist {
+				record := core.NewRecord(collection)
+				record.Set(dbmodels.ENTRIES_TABLE, banddb.Id)
+				record.Set(dbmodels.ITEMS_IDENTIFIER_FIELD, exem.Identifier)
+				record.Set(dbmodels.ITEMS_LOCATION_FIELD, exem.Location)
+				record.Set(dbmodels.ITEMS_OWNER_FIELD, "Theodor Springmann Stiftung")
+				record.Set(dbmodels.ITEMS_CONDITION_FIELD, exem.Condition)
+
+				if slices.Contains(band.Status.Value, "Original vorhanden") {
+					record.Set(dbmodels.ITEMS_MEDIA_FIELD, dbmodels.ITEM_TYPE_VALUES[0])
+				}
+
+				if slices.Contains(band.Status.Value, "Reprint vorhanden") {
+					med := record.GetStringSlice(dbmodels.ITEMS_MEDIA_FIELD)
+					record.Set(dbmodels.ITEMS_MEDIA_FIELD, append(med, dbmodels.ITEM_TYPE_VALUES[1]))
+				}
+
+				record.Set(dbmodels.ANNOTATION_FIELD, exem.Annotation)
+
+				records = append(records, record)
+			}
+		}
+	}
+
+	return records, nil
+}
+
+func appendMessage(message string, toAppend string) string {
+	notiza := strings.TrimSpace(toAppend)
+	if notiza != "" {
+		if message != "" {
+			message += "\n"
+		}
+		message += notiza
+	}
+	return message
+}

migrations/seed/partials.go

@@ -0,0 +1,98 @@
+package seed
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func RecordsFromInhalte(app core.App, inhalte xmlmodels.Inhalte) ([]*core.Record, error) {
+	collection, err := app.FindCollectionByNameOrId(dbmodels.CONTENTS_TABLE)
+	records := make([]*core.Record, 0, len(inhalte.Inhalte))
+	if err != nil {
+		fmt.Println(err)
+		return records, err
+	}
+
+	for i := 0; i < len(inhalte.Inhalte); i++ {
+		record := core.NewRecord(collection)
+		inhalt := inhalte.Inhalte[i]
+		band, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, inhalt.Band)
+		if err != nil {
+			app.Logger().Error("Error finding band record for inhalt", "error", err, "inhalt", inhalt)
+			continue
+		}
+		record.Set(dbmodels.ENTRIES_TABLE, band.Id)
+		record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(inhalt.Anmerkungen))
+		record.Set(dbmodels.MUSENALMID_FIELD, inhalt.ID)
+		record.Set(dbmodels.RESPONSIBILITY_STMT_FIELD, NormalizeString(inhalt.Urheberangabe))
+		record.Set(dbmodels.MUSENALM_INHALTE_TYPE_FIELD, inhalt.Typ.Value)
+		record.Set(dbmodels.EXTENT_FIELD, NormalizeString(inhalt.Seite))
+		record.Set(dbmodels.TITLE_STMT_FIELD, NormalizeString(inhalt.Titelangabe))
+		record.Set(dbmodels.INCIPIT_STMT_FIELD, NormalizeString(inhalt.Incipit))
+
+		counting, ok := dbmodels.MUSENALM_PAGINATION_VALUES[inhalt.Paginierung]
+		if ok {
+			record.Set(dbmodels.MUSENALM_PAGINATION_FIELD, counting)
+		}
+		record.Set(dbmodels.NUMBERING_FIELD, NormalizeString(inhalt.Objektnummer))
+
+		handlePreferredTitle(inhalt, record)
+		n := record.GetString(dbmodels.PREFERRED_TITLE_FIELD)
+		if n == "" || n == "No Title" {
+			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1])
+		} else {
+			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+		}
+
+		records = append(records, record)
+	}
+	return records, nil
+}
+
+func handlePreferredTitle(inhalt xmlmodels.Inhalt, record *core.Record) {
+	if inhalt.Titelangabe != "" {
+		record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(inhalt.Titelangabe))
+		return
+	}
+
+	if inhalt.Incipit != "" {
+		record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(inhalt.Incipit)+"…")
+		return
+	}
+
+	if len(inhalt.Typ.Value) > 0 {
+		str := commatizeArray(inhalt.Typ.Value)
+		if str != "" {
+			if inhalt.Urheberangabe != "" &&
+				!strings.Contains(inhalt.Urheberangabe, "unbezeichnet") &&
+				!strings.Contains(inhalt.Urheberangabe, "unbekannt") &&
+				!strings.Contains(inhalt.Urheberangabe, "unleserlich") {
+				urhh := NormalizeString(inhalt.Urheberangabe)
+				urhh = strings.ReplaceAll(urhh, "#", "")
+				urhh = NormalizeString(urhh)
+				str += " (" + urhh + ")"
+			}
+			record.Set(dbmodels.PREFERRED_TITLE_FIELD, "["+str+"]")
+			return
+		}
+	}
+
+	record.Set(dbmodels.PREFERRED_TITLE_FIELD, "[Kein Titel]")
+}
+
+func commatizeArray(array []string) string {
+	if len(array) == 0 {
+		return ""
+	}
+
+	res := array[0]
+
+	for i := 1; i < len(array)-1; i++ {
+		res += ", " + array[i]
+	}
+	return array[0]
+}

migrations/seed/places.go

@@ -8,11 +8,12 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )
 
-func SeedTablePlaces(app core.App, orte xmlmodels.Orte) error {
+func RecordsFromOrte(app core.App, orte xmlmodels.Orte) ([]*core.Record, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE)
 	records := make([]*core.Record, 0, len(orte.Orte))
 	if err != nil {
 		fmt.Println(err)
+		return records, err
 	}
 
 	for i := 0; i < len(orte.Orte); i++ {
@@ -33,5 +34,5 @@ func SeedTablePlaces(app core.App, orte xmlmodels.Orte) error {
 		records = append(records, record)
 	}
 
-	return batchSave(app, records)
+	return records, nil
 }

migrations/seed/r_contents_agents.go

@@ -0,0 +1,144 @@
+package seed
+
+import (
+	"slices"
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relationen_Inhalte_Akteure) ([]*core.Record, error) {
+	records := make([]*core.Record, 0, len(relations.Relationen))
+	collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE))
+	if err != nil {
+		app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE))
+		return nil, err
+	}
+
+	for _, relation := range relations.Relationen {
+		content, err := app.FindFirstRecordByData(dbmodels.CONTENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Inhalt)
+		if err != nil {
+			app.Logger().Error("Error finding Inhalt", "error", err, "relation", relation)
+			continue
+		}
+
+		agent, err := app.FindFirstRecordByData(dbmodels.AGENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Akteur)
+		if err != nil {
+			app.Logger().Error("Error finding Content", "error", err, "relation", relation)
+			continue
+		}
+
+		record := core.NewRecord(collection)
+		record.Set(dbmodels.CONTENTS_TABLE, content.Id)
+		record.Set(dbmodels.AGENTS_TABLE, agent.Id)
+
+		switch relation.Relation {
+		case "1":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Schöpfer")
+			cat := content.GetStringSlice(dbmodels.MUSENALM_INHALTE_TYPE_FIELD)
+			ber := agent.GetString(dbmodels.AGENTS_PROFESSION_FIELD)
+			probt := 0
+			probm := 0
+			probg := 0
+
+			if slices.ContainsFunc(cat, isProse) {
+				probt += 1
+			} else {
+				probt -= 1
+			}
+
+			if Text(ber) {
+				if probt > 0 {
+					probt += 1
+				}
+				probt += 1
+			}
+
+			if slices.ContainsFunc(cat, isMusic) {
+				probm += 1
+			} else {
+				probm -= 1
+			}
+			if Musik(ber) {
+				if probm > 0 {
+					probm += 1
+				}
+				probm += 1
+			}
+
+			if slices.ContainsFunc(cat, isGraph) {
+				probg += 1
+			} else {
+				probg -= 1
+			}
+			if Graphiker(ber) {
+				if probg > 0 {
+					probg += 1
+				}
+				probg += 1
+			}
+
+			if probt == 3 && probm <= 1 && probg <= 1 {
+				record.Set(dbmodels.RELATION_TYPE_FIELD, "Autor:in")
+				break
+			}
+
+			if probm == 3 && probt <= 1 && probg <= 1 {
+				record.Set(dbmodels.RELATION_TYPE_FIELD, "Komponist:in")
+				break
+			}
+
+			if probg == 3 && probt <= 1 && probm <= 1 {
+				record.Set(dbmodels.RELATION_TYPE_FIELD, "Künstler:in")
+				break
+			}
+
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Schöpfer")
+		case "2":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Autor:in")
+		case "3":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Zeichner:in")
+		case "4":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Kupferstecher:in")
+		}
+
+		rel := record.GetString(dbmodels.RELATION_TYPE_FIELD)
+		ent := record.GetString(dbmodels.CONTENTS_TABLE)
+		ser := record.GetString(dbmodels.AGENTS_TABLE)
+
+		if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" {
+			content.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
+			_ = app.Save(content)
+		}
+
+		records = append(records, record)
+	}
+
+	return records, err
+}
+
+func isProse(cat string) bool {
+	return cat == "Corrigenda" || cat == "Gedicht/Lied" || cat == "Motto" || cat == "Kalendarium" || cat == "Tabelle" || cat == "Inhaltsverzeichnis" || cat == "Text" || cat == "Prosa"
+}
+
+func isGraph(cat string) bool {
+	return strings.HasPrefix(cat, "graph") || cat == "Graphik"
+}
+
+func Graphiker(beruf string) bool {
+	return strings.Contains(beruf, "Graphik")
+}
+
+func Text(beruf string) bool {
+	return strings.Contains(beruf, "Text")
+}
+
+func Musik(beruf string) bool {
+	return strings.Contains(beruf, "Musik")
+}
+
+func isMusic(cat string) bool {
+	return cat == "Gedicht/Lied" || cat == "Musikbeigabe"
+}

migrations/seed/r_entries_agents.go

@@ -0,0 +1,59 @@
+package seed
+
+import (
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func RecordsFromRelationBändeAkteure(app core.App, relations xmlmodels.Relationen_Bände_Akteure) ([]*core.Record, error) {
+	records := make([]*core.Record, 0, len(relations.Relationen))
+	collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE))
+	if err != nil {
+		app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE))
+		return nil, err
+	}
+
+	for _, relation := range relations.Relationen {
+		entry, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, relation.Band)
+		if err != nil {
+			app.Logger().Error("Error finding Entry", "error", err, "relation", relation)
+			continue
+		}
+
+		agent, err := app.FindFirstRecordByData(dbmodels.AGENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Akteur)
+		if err != nil {
+			app.Logger().Error("Error finding Agent", "error", err, "relation", relation)
+			continue
+		}
+
+		record := core.NewRecord(collection)
+		record.Set(dbmodels.ENTRIES_TABLE, entry.Id)
+		record.Set(dbmodels.AGENTS_TABLE, agent.Id)
+
+		switch relation.Relation {
+		case "8":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Vertrieb")
+		case "7":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Druck")
+		case "6":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Verlag")
+		case "5":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Herausgeber:in")
+		}
+
+		rel := record.GetString(dbmodels.RELATION_TYPE_FIELD)
+		ent := record.GetString(dbmodels.ENTRIES_TABLE)
+		ser := record.GetString(dbmodels.AGENTS_TABLE)
+
+		if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" {
+			entry.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
+			_ = app.Save(entry)
+		}
+		records = append(records, record)
+	}
+
+	return records, nil
+}

migrations/seed/r_entries_series.go

@@ -0,0 +1,68 @@
+package seed
+
+import (
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func RecordsFromRelationBändeReihen(app core.App, relations xmlmodels.Relationen_Bände_Reihen) ([]*core.Record, error) {
+	records := make([]*core.Record, 0, len(relations.Relationen))
+	collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE))
+	if err != nil {
+		app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE))
+		return nil, err
+	}
+
+	for _, relation := range relations.Relationen {
+		entry, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, relation.Band)
+		if err != nil {
+			app.Logger().Error("Error finding Entry", "error", err, "relation", relation)
+			continue
+		}
+
+		series, err := app.FindFirstRecordByData(dbmodels.SERIES_TABLE, dbmodels.MUSENALMID_FIELD, relation.Reihe)
+		if err != nil {
+			app.Logger().Error("Error finding Series", "error", err, "relation", relation)
+			continue
+		}
+
+		record := core.NewRecord(collection)
+		record.Set(dbmodels.ENTRIES_TABLE, entry.Id)
+		record.Set(dbmodels.SERIES_TABLE, series.Id)
+
+		switch relation.Relation {
+		case "1":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Bevorzugter Reihentitel")
+		case "2":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Alternativer Reihentitel")
+		case "3":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "In anderer Sprache")
+		case "4":
+			entry.Set(dbmodels.LANGUAGE_FIELD, "fre")
+			_ = app.Save(entry)
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "In anderer Sprache")
+		case "5":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Alternativer Reihentitel")
+		case "6":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Früherer Reihentitel")
+		case "7":
+			record.Set(dbmodels.RELATION_TYPE_FIELD, "Späterer Reihentitel")
+		}
+
+		rel := record.GetString(dbmodels.RELATION_TYPE_FIELD)
+		ent := record.GetString(dbmodels.ENTRIES_TABLE)
+		ser := record.GetString(dbmodels.SERIES_TABLE)
+
+		if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" {
+			entry.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
+			_ = app.Save(entry)
+		}
+
+		records = append(records, record)
+	}
+
+	return records, nil
+}

migrations/seed/series.go

@@ -8,11 +8,12 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )
 
-func SeedTableSeries(app core.App, reihen xmlmodels.Reihentitel) error {
+func RecordsFromReihentitel(app core.App, reihen xmlmodels.Reihentitel) ([]*core.Record, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.SERIES_TABLE)
 	records := make([]*core.Record, 0, len(reihen.Reihen))
 	if err != nil {
 		fmt.Println(err)
+		return records, err
 	}
 
 	for i := 0; i < len(reihen.Reihen); i++ {
@@ -39,5 +40,5 @@ func SeedTableSeries(app core.App, reihen xmlmodels.Reihentitel) error {
 		records = append(records, record)
 	}
 
-	return batchSave(app, records)
+	return records, nil
 }