Added DB models

2025-10-29 17:25:32 +00:00 · 2025-02-10 16:58:55 +01:00
parent bd59fdc2c2
commit a39ac0d68e
26 changed files with 1301 additions and 251 deletions
--- a/migrations/seed/agents.go
+++ b/migrations/seed/agents.go
@@ -8,31 +8,31 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )

-func RecordsFromAkteure(app core.App, akteure xmlmodels.Akteure) ([]*core.Record, error) {
+func RecordsFromAkteure(app core.App, akteure xmlmodels.Akteure) ([]*dbmodels.Agent, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.AGENTS_TABLE)
-	records := make([]*core.Record, 0, len(akteure.Akteure))
+	records := make([]*dbmodels.Agent, 0, len(akteure.Akteure))
 	if err != nil {
 		fmt.Println(err)
 		return records, err
 	}

 	for i := 0; i < len(akteure.Akteure); i++ {
-		record := core.NewRecord(collection)
+		record := dbmodels.NewAgent(core.NewRecord(collection))
 		akteur := akteure.Akteure[i]
-		record.Set(dbmodels.AGENTS_CORP_FIELD, akteur.Körperschaft)
-		record.Set(dbmodels.AGENTS_NAME_FIELD, NormalizeString(akteur.Name))
-		record.Set(dbmodels.REFERENCES_FIELD, NormalizeString(akteur.Nachweis))
-		record.Set(dbmodels.AGENTS_BIOGRAPHICAL_DATA_FIELD, NormalizeString(akteur.Lebensdaten))
-		record.Set(dbmodels.AGENTS_PROFESSION_FIELD, NormalizeString(akteur.Beruf))
-		record.Set(dbmodels.AGENTS_PSEUDONYMS_FIELD, NormalizeString(akteur.Pseudonyme))
-		record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(akteur.Anmerkungen))
-		record.Set(dbmodels.MUSENALMID_FIELD, akteur.ID)
+		record.SetCorporateBody(akteur.Körperschaft)
+		record.SetName(NormalizeString(akteur.Name))
+		record.SetReferences(NormalizeString(akteur.Nachweis))
+		record.SetBiographicalData(NormalizeString(akteur.Lebensdaten))
+		record.SetProfession(NormalizeString(akteur.Beruf))
+		record.SetPseudonyms(NormalizeString(akteur.Pseudonyme))
+		record.SetAnnotation(NormalizeString(akteur.Anmerkungen))
+		record.SetMusenalmID(akteur.ID)

 		n := akteur.Name
 		if n == "" {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[1])
 		} else {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
 		}

 		records = append(records, record)
--- a/migrations/seed/contents.go
+++ b/migrations/seed/contents.go
@@ -2,6 +2,7 @@ package seed

 import (
 	"fmt"
+	"strconv"
 	"strings"

 	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
@@ -9,43 +10,50 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )

-func RecordsFromInhalte(app core.App, inhalte xmlmodels.Inhalte) ([]*core.Record, error) {
+const NO_TITLE = "[No Title]"
+
+func RecordsFromInhalte(app core.App, inhalte xmlmodels.Inhalte) ([]*dbmodels.Content, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.CONTENTS_TABLE)
-	records := make([]*core.Record, 0, len(inhalte.Inhalte))
+	records := make([]*dbmodels.Content, 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)
+		record := dbmodels.NewContent(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))
+		record.SetEntry(band.Id)
+		record.SetAnnotation(NormalizeString(inhalt.Anmerkungen))
+		record.SetMusenalmID(inhalt.ID)
+		record.SetResponsibilityStmt(NormalizeString(inhalt.Urheberangabe))
+		record.SetMusenalmType(inhalt.Typ.Value)
+		record.SetExtent(NormalizeString(inhalt.Seite))
+		record.SetTitleStmt(NormalizeString(inhalt.Titelangabe))
+		record.SetIncipitStmt(NormalizeString(inhalt.Incipit))

 		counting, ok := dbmodels.MUSENALM_PAGINATION_VALUES[inhalt.Paginierung]
 		if ok {
-			record.Set(dbmodels.MUSENALM_PAGINATION_FIELD, counting)
+			record.SetMusenalmPagination(counting)
 		}
-		record.Set(dbmodels.NUMBERING_FIELD, NormalizeString(inhalt.Objektnummer))
+
+		no, err := strconv.ParseFloat(NormalizeString(inhalt.Objektnummer), 64)
+		if err != nil {
+			app.Logger().Error("Error parsing object number", "error", err, "object number", inhalt.Objektnummer)
+		}
+		record.SetNumbering(no)

 		handlePreferredTitle(inhalt, record)
-		n := record.GetString(dbmodels.PREFERRED_TITLE_FIELD)
-		if n == "" || n == "No Title" {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1])
+		n := record.PreferredTitle()
+		if n == "" || n == NO_TITLE {
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[1])
 		} else {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
 		}

 		records = append(records, record)
@@ -53,14 +61,14 @@ func RecordsFromInhalte(app core.App, inhalte xmlmodels.Inhalte) ([]*core.Record
 	return records, nil
 }

-func handlePreferredTitle(inhalt xmlmodels.Inhalt, record *core.Record) {
+func handlePreferredTitle(inhalt xmlmodels.Inhalt, record *dbmodels.Content) {
 	if inhalt.Titelangabe != "" {
-		record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(inhalt.Titelangabe))
+		record.SetPreferredTitle(NormalizeString(inhalt.Titelangabe))
 		return
 	}

 	if inhalt.Incipit != "" {
-		record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(inhalt.Incipit)+"…")
+		record.SetPreferredTitle(NormalizeString(inhalt.Incipit) + "…")
 		return
 	}

@@ -76,12 +84,12 @@ func handlePreferredTitle(inhalt xmlmodels.Inhalt, record *core.Record) {
 				urhh = NormalizeString(urhh)
 				str += " (" + urhh + ")"
 			}
-			record.Set(dbmodels.PREFERRED_TITLE_FIELD, "["+str+"]")
+			record.SetPreferredTitle("[" + str + "]")
 			return
 		}
 	}

-	record.Set(dbmodels.PREFERRED_TITLE_FIELD, "[Kein Titel]")
+	record.SetPreferredTitle(NO_TITLE)
 }

 func commatizeArray(array []string) string {
--- a/migrations/seed/entries.go
+++ b/migrations/seed/entries.go
@@ -15,58 +15,61 @@ import (
 func RecordsFromBände(
 	app core.App,
 	adb xmlmodels.AccessDB,
-) ([]*core.Record, error) {
+) ([]*dbmodels.Entry, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.ENTRIES_TABLE)
-	records := make([]*core.Record, 0, len(adb.Bände.Bände))
+	records := make([]*dbmodels.Entry, 0, len(adb.Bände.Bände))
 	if err != nil {
 		fmt.Println(err)
 		return records, err
 	}

-	omap := datatypes.MakeMap(adb.Orte.Orte, func(o xmlmodels.Ort) string { return o.ID })
-	relmap := datatypes.MakeMultiMap(
-		adb.Relationen_Bände_Reihen.Relationen,
-		func(r xmlmodels.Relation_Band_Reihe) string { return r.Band },
-	)
-	rmap := datatypes.MakeMap(adb.Reihen.Reihen, func(r xmlmodels.Reihe) string { return r.ID })
 	ocoll, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE)
 	if err != nil {
 		app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.PLACES_TABLE)
 		return records, err
 	}

+	// INFO: lets make some maps to speed this up
+	omap := datatypes.MakeMap(adb.Orte.Orte, func(o xmlmodels.Ort) string { return o.ID })
+	relmap := datatypes.MakeMultiMap(
+		adb.Relationen_Bände_Reihen.Relationen,
+		func(r xmlmodels.Relation_Band_Reihe) string { return r.Band },
+	)
+	rmap := datatypes.MakeMap(adb.Reihen.Reihen, func(r xmlmodels.Reihe) string { return r.ID })
+
 	for i := 0; i < len(adb.Bände.Bände); i++ {
 		band := adb.Bände.Bände[i]
-		record := core.NewRecord(collection)
+		record := dbmodels.NewEntry(core.NewRecord(collection))

 		// TODO: Hier bevorzugter reihentitel + jahr, oder irgendein reihentitel, oder reihentitelALT
 		if band.ReihentitelALT == "" {
 			continue
 		}
-		record.Set(dbmodels.TITLE_STMT_FIELD, NormalizeString(band.Titelangabe))
-		record.Set(dbmodels.REFERENCES_FIELD, NormalizeString(band.Nachweis))
-		record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(band.Anmerkungen))
-		if band.Jahr != 0 {
-			record.Set(dbmodels.YEAR_FIELD, band.Jahr)
-		}
-		record.Set(dbmodels.RESPONSIBILITY_STMT_FIELD, NormalizeString(band.Verantwortlichkeitsangabe))
-		record.Set(dbmodels.PUBLICATION_STMT_FIELD, NormalizeString(band.Ortsangabe))
-		record.Set(dbmodels.EXTENT_FIELD, NormalizeString(band.Struktur))

-		record.Set(dbmodels.CARRIER_TYPE_FIELD, "Band")
-		record.Set(dbmodels.CONTENT_TYPE_FIELD, []string{"unbewegtes Bild", "Text"})
-		record.Set(dbmodels.MEDIA_TYPE_FIELD, "ohne Hilfsmittel")
-		record.Set(dbmodels.LANGUAGE_FIELD, "ger")
-		record.Set(dbmodels.MUSENALMID_FIELD, band.ID)
+		record.SetTitleStmt(NormalizeString(band.Titelangabe))
+		record.SetReferences(NormalizeString(band.Nachweis))
+		record.SetAnnotation(NormalizeString(band.Anmerkungen))
+		record.SetResponsibilityStmt(NormalizeString(band.Verantwortlichkeitsangabe))
+		record.SetPublicationStmt(NormalizeString(band.Ortsangabe))
+		record.SetExtent(NormalizeString(band.Struktur))
+		record.SetCarrierType([]string{"Band"})
+		record.SetContentType([]string{"unbewegtes Bild", "Text"})
+		record.SetMediaType([]string{"ohne Hilfsmittel"})
+		record.SetLanguage([]string{"ger"})
+		record.SetMusenalmID(band.ID)
+
+		if band.Jahr != 0 {
+			record.SetYear(band.Jahr)
+		}

 		if band.Erfasst {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
 		} else if band.Gesichtet {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[2])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[2])
 		} else if band.BiblioID != 0 {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[1])
 		} else {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[0])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[0])
 		}

 		handlePreferredTitleEntry(record, band, rmap, relmap)
@@ -80,15 +83,15 @@ func RecordsFromBände(
 }

 func handlePreferredTitleEntry(
-	record *core.Record,
+	record *dbmodels.Entry,
 	band xmlmodels.Band,
 	rmap map[string]xmlmodels.Reihe,
 	rrelmap map[string][]xmlmodels.Relation_Band_Reihe,
 ) {
 	rels := rrelmap[band.ID]
 	if len(rels) == 0 {
-		record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(band.ReihentitelALT))
-		record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
+		record.SetPreferredTitle(NormalizeString(band.ReihentitelALT))
+		record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
 		return
 	}

@@ -102,7 +105,7 @@ func handlePreferredTitleEntry(
 	bevti := slices.IndexFunc(rels, func(r xmlmodels.Relation_Band_Reihe) bool { return r.Relation == "1" })
 	if bevti != -1 {
 		bevt := rmap[rels[bevti].Reihe]
-		record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(bevt.Titel)+" "+jahr)
+		record.SetPreferredTitle(NormalizeString(bevt.Titel) + " " + jahr)
 		return
 	}

@@ -110,11 +113,11 @@ func handlePreferredTitleEntry(
 		return strings.Compare(a.Relation, b.Relation)
 	})

-	record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(rmap[rels[0].Reihe].Titel)+jahr)
+	record.SetPreferredTitle(NormalizeString(rmap[rels[0].Reihe].Titel) + jahr)
 }

 func handleOrte(
-	record *core.Record,
+	record *dbmodels.Entry,
 	band xmlmodels.Band,
 	orte map[string]xmlmodels.Ort,
 	app core.App,
@@ -132,35 +135,32 @@ func handleOrte(

 			ort, err := app.FindFirstRecordByData(dbmodels.PLACES_TABLE, dbmodels.PLACES_NAME_FIELD, n)
 			if err == nil {
-				before := record.GetStringSlice(dbmodels.PLACES_TABLE)
-				record.Set(dbmodels.PLACES_TABLE, append(before, ort.Id))
+				before := record.Places()
+				record.SetPlaces(append(before, ort.Id))
 			} else {
-				orec := core.NewRecord(ocollection)
-				orec.Set(dbmodels.PLACES_NAME_FIELD, n)
-				orec.Set(dbmodels.ANNOTATION_FIELD, o.Anmerkungen)
-				orec.Set(dbmodels.PLACES_FICTIONAL_FIELD, o.Fiktiv)
-				orec.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+				orec := dbmodels.NewPlace(core.NewRecord(ocollection))
+				orec.SetName(n)
+				orec.SetAnnotation(o.Anmerkungen)
+				orec.SetFictional(o.Fiktiv)
+				orec.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
 				if err := app.Save(orec); err != nil {
 					app.Logger().Error("Error saving record", "error", err, "record", orec)
 					continue
 				} else {
-					before := record.GetStringSlice(dbmodels.PLACES_TABLE)
-					record.Set(dbmodels.PLACES_TABLE, append(before, orec.Id))
+					before := record.Places()
+					record.SetPlaces(append(before, orec.Id))
 				}
 			}

 			if e {
 				// INFO: We do not need to get the record metadata here, as we know that the record is new
-				record.Set(
-					dbmodels.META_FIELD,
-					map[string]dbmodels.MetaData{dbmodels.PLACES_TABLE: {Conjecture: true}},
-				)
+				record.SetMeta(map[string]dbmodels.MetaData{dbmodels.PLACES_TABLE: {Conjecture: true}})
 			}
 		}
 	}
 }

-func handleDeprecated(record *core.Record, band xmlmodels.Band) {
+func handleDeprecated(record *dbmodels.Entry, band xmlmodels.Band) {
 	depr := dbmodels.Deprecated{
 		Reihentitel: NormalizeString(band.ReihentitelALT),
 		Norm:        NormalizeString(band.Norm),
@@ -170,5 +170,5 @@ func handleDeprecated(record *core.Record, band xmlmodels.Band) {
 		Erfasst:     band.Erfasst,
 	}

-	record.Set(dbmodels.MUSENALM_DEPRECATED_FIELD, depr)
+	record.SetDeprecated(depr)
 }
--- a/migrations/seed/items.go
+++ b/migrations/seed/items.go
@@ -16,9 +16,9 @@ func ItemsFromBändeAndBIBLIO(
 	app core.App,
 	entries xmlmodels.Bände,
 	biblio map[int]xmlmodels.BIBLIOEintrag,
-) ([]*core.Record, error) {
+) ([]*dbmodels.Item, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.ITEMS_TABLE)
-	records := make([]*core.Record, 0, len(entries.Bände))
+	records := make([]*dbmodels.Item, 0, len(entries.Bände))
 	r := regexp.MustCompile("\\d{6}")
 	if err != nil {
 		fmt.Println(err)
@@ -66,65 +66,63 @@ func ItemsFromBändeAndBIBLIO(
 			}
 		}

-		var exemlist []dbmodels.Item
-
 		if band.BiblioID != 0 {
-			exem := dbmodels.Item{Identifier: strconv.Itoa(band.BiblioID)}
+			exem := dbmodels.NewItem(core.NewRecord(collection))
+			exem.SetIdentifier(strconv.Itoa(band.BiblioID))
 			if e, ok := biblio[band.BiblioID]; ok {
-				exem.Location = strings.TrimSpace(e.Standort)
-				exem.Condition = strings.TrimSpace(e.Zustand)
+				exem.SetLocation(strings.TrimSpace(e.Standort))
+				exem.SetCondition(strings.TrimSpace(e.Zustand))
 				message := ""
 				message = appendMessage(e.NotizÄusseres, message)
 				message = appendMessage(e.NotizInhalt, message)
 				message = appendMessage(e.Anmerkungen, message)
-				exem.Annotation = message
+				exem.SetAnnotation(message)
 			}

-			exemlist = append(exemlist, exem)
+			records = append(records, exem)
 		}

 		for nr, m := range t {
-			exem := dbmodels.Item{Identifier: nr}
+			exem := dbmodels.NewItem(core.NewRecord(collection))
+			exem.SetIdentifier(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)
+					exem.SetLocation(strings.TrimSpace(e.Standort))
+					exem.SetCondition(strings.TrimSpace(e.Zustand))
 					message = appendMessage(e.NotizÄusseres, message)
 					message = appendMessage(e.NotizInhalt, message)
 					message = appendMessage(e.Anmerkungen, message)
 				}
 			}
-			exem.Annotation = message
+			exem.SetAnnotation(message)

-			if exem.Identifier != "" {
-				exemlist = append(exemlist, exem)
+			if exem.Identifier() != "" {
+				records = append(records, 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 len(records) > 0 {
+			for _, exem := range records {
+				exem.SetEntry(banddb.Id)
+				exem.SetOwner("Theodor Springmann Stiftung")

 				if slices.Contains(band.Status.Value, "Original vorhanden") {
-					record.Set(dbmodels.ITEMS_MEDIA_FIELD, dbmodels.ITEM_TYPE_VALUES[0])
+					exem.SetMedia([]string{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]))
+					med := exem.Media()
+					exem.SetMedia(append(med, dbmodels.ITEM_TYPE_VALUES[1]))
 				}

-				record.Set(dbmodels.ANNOTATION_FIELD, exem.Annotation)
-
-				records = append(records, record)
+				if exem.Location() == "" {
+					exem.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
+				} else {
+					exem.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+				}
 			}
 		}
 	}
--- a/migrations/seed/places.go
+++ b/migrations/seed/places.go
@@ -8,9 +8,9 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )

-func RecordsFromOrte(app core.App, orte xmlmodels.Orte) ([]*core.Record, error) {
+func RecordsFromOrte(app core.App, orte xmlmodels.Orte) ([]*dbmodels.Place, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE)
-	records := make([]*core.Record, 0, len(orte.Orte))
+	records := make([]*dbmodels.Place, 0, len(orte.Orte))
 	if err != nil {
 		fmt.Println(err)
 		return records, err
@@ -18,17 +18,17 @@ func RecordsFromOrte(app core.App, orte xmlmodels.Orte) ([]*core.Record, error)

 	for i := 0; i < len(orte.Orte); i++ {
 		ort := orte.Orte[i]
-		record := core.NewRecord(collection)
-		record.Set(dbmodels.PLACES_NAME_FIELD, NormalizeString(ort.Name))
-		record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(ort.Anmerkungen))
-		record.Set(dbmodels.PLACES_FICTIONAL_FIELD, ort.Fiktiv)
-		record.Set(dbmodels.MUSENALMID_FIELD, ort.ID)
+		record := dbmodels.NewPlace(core.NewRecord(collection))
+		record.SetName(NormalizeString(ort.Name))
+		record.SetAnnotation(NormalizeString(ort.Anmerkungen))
+		record.SetFictional(ort.Fiktiv)
+		record.SetMusenalmID(ort.ID)

 		n := ort.Name
 		if n == "" {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[1])
 		} else {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
 		}

 		records = append(records, record)
--- a/migrations/seed/r_contents_agents.go
+++ b/migrations/seed/r_contents_agents.go
@@ -9,8 +9,8 @@ import (
 	"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))
+func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relationen_Inhalte_Akteure) ([]*dbmodels.RContentsAgents, error) {
+	records := make([]*dbmodels.RContentsAgents, 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))
@@ -18,27 +18,29 @@ func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relatio
 	}

 	for _, relation := range relations.Relationen {
-		content, err := app.FindFirstRecordByData(dbmodels.CONTENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Inhalt)
+		c, 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
 		}
+		content := dbmodels.NewContent(c)

-		agent, err := app.FindFirstRecordByData(dbmodels.AGENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Akteur)
+		a, 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
 		}
+		agent := dbmodels.NewAgent(a)

-		record := core.NewRecord(collection)
-		record.Set(dbmodels.CONTENTS_TABLE, content.Id)
-		record.Set(dbmodels.AGENTS_TABLE, agent.Id)
+		record := dbmodels.NewRContentsAgents(core.NewRecord(collection))
+		record.SetContent(content.Id)
+		record.SetAgent(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)
+			record.SetType("Schöpfer")
+			cat := content.MusenalmType()
+			ber := agent.Profession()
 			probt := 0
 			probm := 0
 			probg := 0
@@ -81,32 +83,32 @@ func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relatio
 			}

 			if probt == 3 && probm <= 1 && probg <= 1 {
-				record.Set(dbmodels.RELATION_TYPE_FIELD, "Autor:in")
+				record.SetType("Autor:in")
 				break
 			}

 			if probm == 3 && probt <= 1 && probg <= 1 {
-				record.Set(dbmodels.RELATION_TYPE_FIELD, "Komponist:in")
+				record.SetType("Komponist:in")
 				break
 			}

 			if probg == 3 && probt <= 1 && probm <= 1 {
-				record.Set(dbmodels.RELATION_TYPE_FIELD, "Künstler:in")
+				record.SetType("Künstler:in")
 				break
 			}

-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Schöpfer")
+			record.SetType("Schöpfer")
 		case "2":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Autor:in")
+			record.SetType("Autor:in")
 		case "3":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Zeichner:in")
+			record.SetType("Herausgeber:in")
 		case "4":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Kupferstecher:in")
+			record.SetType("Verlag")
 		}

-		rel := record.GetString(dbmodels.RELATION_TYPE_FIELD)
-		ent := record.GetString(dbmodels.CONTENTS_TABLE)
-		ser := record.GetString(dbmodels.AGENTS_TABLE)
+		rel := record.Type()
+		ent := record.Content()
+		ser := record.Agent()

 		if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" {
 			content.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
--- a/migrations/seed/r_entries_agents.go
+++ b/migrations/seed/r_entries_agents.go
@@ -8,8 +8,8 @@ import (
 	"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))
+func RecordsFromRelationBändeAkteure(app core.App, relations xmlmodels.Relationen_Bände_Akteure) ([]*dbmodels.REntriesAgents, error) {
+	records := make([]*dbmodels.REntriesAgents, 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))
@@ -29,28 +29,29 @@ func RecordsFromRelationBändeAkteure(app core.App, relations xmlmodels.Relation
 			continue
 		}

-		record := core.NewRecord(collection)
-		record.Set(dbmodels.ENTRIES_TABLE, entry.Id)
-		record.Set(dbmodels.AGENTS_TABLE, agent.Id)
+		record := dbmodels.NewREntriesAgents(core.NewRecord(collection))
+		record.SetEntry(entry.Id)
+		record.SetAgent(agent.Id)

 		switch relation.Relation {
 		case "8":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Vertrieb")
+			record.SetType("Vertrieb")
 		case "7":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Druck")
+			record.SetType("Druck")
 		case "6":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Verlag")
+			record.SetType("Verlag")
 		case "5":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Herausgeber:in")
+			record.SetType("Herausgeber:in")
 		}

-		rel := record.GetString(dbmodels.RELATION_TYPE_FIELD)
-		ent := record.GetString(dbmodels.ENTRIES_TABLE)
-		ser := record.GetString(dbmodels.AGENTS_TABLE)
+		rel := record.Type()
+		ent := record.Entry()
+		ser := record.Agent()

 		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)
+			e := dbmodels.NewEntry(entry)
+			e.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
+			_ = app.Save(e)
 		}
 		records = append(records, record)
 	}
--- a/migrations/seed/r_entries_series.go
+++ b/migrations/seed/r_entries_series.go
@@ -8,8 +8,8 @@ import (
 	"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))
+func RecordsFromRelationBändeReihen(app core.App, relations xmlmodels.Relationen_Bände_Reihen) ([]*dbmodels.REntriesSeries, error) {
+	records := make([]*dbmodels.REntriesSeries, 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))
@@ -17,47 +17,49 @@ func RecordsFromRelationBändeReihen(app core.App, relations xmlmodels.Relatione
 	}

 	for _, relation := range relations.Relationen {
-		entry, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, relation.Band)
+		e, 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
 		}

+		entry := dbmodels.NewEntry(e)
+
 		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)
+		record := dbmodels.NewREntriesSeries(core.NewRecord(collection))
+		record.SetEntry(entry.Id)
+		record.SetSeries(series.Id)

 		switch relation.Relation {
 		case "1":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Bevorzugter Reihentitel")
+			record.SetType("Bevorzugter Reihentitel")
 		case "2":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Alternativer Reihentitel")
+			record.SetType("Alternativer Reihentitel")
 		case "3":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "In anderer Sprache")
+			record.SetType("In anderer Sprache")
 		case "4":
-			entry.Set(dbmodels.LANGUAGE_FIELD, "fre")
+			entry.SetLanguage([]string{"fre"})
 			_ = app.Save(entry)
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "In anderer Sprache")
+			record.SetType("In anderer Sprache")
 		case "5":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Alternativer Reihentitel")
+			record.SetType("Alternativer Reihentitel")
 		case "6":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Früherer Reihentitel")
+			record.SetType("Früherer Reihentitel")
 		case "7":
-			record.Set(dbmodels.RELATION_TYPE_FIELD, "Späterer Reihentitel")
+			record.SetType("Späterer Reihentitel")
 		}

-		rel := record.GetString(dbmodels.RELATION_TYPE_FIELD)
-		ent := record.GetString(dbmodels.ENTRIES_TABLE)
-		ser := record.GetString(dbmodels.SERIES_TABLE)
+		rel := record.Type()
+		ent := record.Entry()
+		ser := record.Series()

 		if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" {
-			entry.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
+			entry.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2])
 			_ = app.Save(entry)
 		}

--- a/migrations/seed/series.go
+++ b/migrations/seed/series.go
@@ -8,33 +8,33 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )

-func RecordsFromReihentitel(app core.App, reihen xmlmodels.Reihentitel) ([]*core.Record, error) {
+func RecordsFromReihentitel(app core.App, reihen xmlmodels.Reihentitel) ([]*dbmodels.Series, error) {
 	collection, err := app.FindCollectionByNameOrId(dbmodels.SERIES_TABLE)
-	records := make([]*core.Record, 0, len(reihen.Reihen))
+	records := make([]*dbmodels.Series, 0, len(reihen.Reihen))
 	if err != nil {
 		fmt.Println(err)
 		return records, err
 	}

 	for i := 0; i < len(reihen.Reihen); i++ {
-		record := core.NewRecord(collection)
+		record := dbmodels.NewSeries(core.NewRecord(collection))
 		reihe := reihen.Reihen[i]
 		if reihe.Titel == "" {
-			record.Set(dbmodels.SERIES_NAME_FIELD, reihe.Sortiername)
+			record.SetTitle(NormalizeString(reihe.Sortiername))
 		} else {
-			record.Set(dbmodels.SERIES_NAME_FIELD, reihe.Titel)
+			record.SetTitle(NormalizeString(reihe.Titel))
 		}

-		record.Set(dbmodels.REFERENCES_FIELD, NormalizeString(reihe.Nachweis))
-		record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(reihe.Anmerkungen))
-		record.Set(dbmodels.SERIES_FREQUENCY_FIELD, "jährlich")
-		record.Set(dbmodels.MUSENALMID_FIELD, reihe.ID)
+		record.SetReferences(NormalizeString(reihe.Nachweis))
+		record.SetAnnotation(NormalizeString(reihe.Anmerkungen))
+		record.SetFrequency("jährlich")
+		record.SetMusenalmID(reihe.ID)

-		n := record.GetString(dbmodels.SERIES_NAME_FIELD)
+		n := record.Title()
 		if n == "" {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[1])
 		} else {
-			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+			record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
 		}

 		records = append(records, record)