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

2025-12-16 06:15:29 +00:00 · 2025-02-08 23:04:32 +01:00
parent cfce7a2dc7
commit 851de285aa
19 changed files with 844 additions and 203 deletions
--- a/migrations/seed/agents.go
+++ b/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
 }
--- a/migrations/seed/common.go
+++ b/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 {
--- a/migrations/seed/entries.go
+++ b/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
-}
--- a/migrations/seed/items.go
+++ b/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
+}
--- a/migrations/seed/partials.go
+++ b/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]
+}
--- a/migrations/seed/places.go
+++ b/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
 }
--- a/migrations/seed/r_contents_agents.go
+++ b/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"
+}
--- a/migrations/seed/r_entries_agents.go
+++ b/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
+}
--- a/migrations/seed/r_entries_series.go
+++ b/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
+}
--- a/migrations/seed/series.go
+++ b/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
 }