Places, Agents, Serials, Entries

2025-10-29 01:05:32 +00:00 · 2025-02-08 15:24:13 +01:00
parent f4cbb037e0
commit cfce7a2dc7
32 changed files with 451342 additions and 154 deletions
--- a/migrations/1738936553_places.go
+++ b/migrations/1738936553_places.go
@@ -1,7 +1,7 @@
 package migrations

 import (
-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/pocketbase/pocketbase/core"
 	m "github.com/pocketbase/pocketbase/migrations"
 )
@@ -14,7 +14,7 @@ func init() {

 		return app.Save(places)
 	}, func(app core.App) error {
-		places, err := app.FindCollectionByNameOrId(models.PLACES_TABLE)
+		places, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE)
 		if err != nil {
 			return nil
 		}
@@ -24,16 +24,16 @@ func init() {
 }

 func placesTable() *core.Collection {
-	collection := core.NewBaseCollection(models.PLACES_TABLE)
+	collection := core.NewBaseCollection(dbmodels.PLACES_TABLE)
 	setBasicPublicRules(collection)
 	return collection
 }

 func placesFields() core.FieldsList {
 	fields := core.NewFieldsList(
-		&core.TextField{Name: models.PLACES_NAME_FIELD, Required: true, Presentable: true},
-		&core.BoolField{Name: models.AGENTS_FICTIONAL_FIELD, Required: false},
-		&core.URLField{Name: models.URI_FIELD, Required: false, OnlyDomains: []string{"geonames.org"}},
+		&core.TextField{Name: dbmodels.PLACES_NAME_FIELD, Required: true, Presentable: true},
+		&core.BoolField{Name: dbmodels.AGENTS_FICTIONAL_FIELD, Required: false},
+		&core.URLField{Name: dbmodels.URI_FIELD, Required: false, OnlyDomains: []string{"geonames.org"}},
 	)

 	setMusenalmIDField(&fields)
@@ -45,6 +45,6 @@ func placesFields() core.FieldsList {

 func placesIndexes(collection *core.Collection) {
 	addMusenalmIDIndex(collection)
-	addIndex(collection, models.PLACES_NAME_FIELD, false)
-	addIndex(collection, models.URI_FIELD, true)
+	addIndex(collection, dbmodels.PLACES_NAME_FIELD, false)
+	addIndex(collection, dbmodels.URI_FIELD, false)
 }
--- a/migrations/1738936568_agents.go
+++ b/migrations/1738936568_agents.go
@@ -1,7 +1,7 @@
 package migrations

 import (
-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/pocketbase/pocketbase/core"
 	m "github.com/pocketbase/pocketbase/migrations"
 )
@@ -14,7 +14,7 @@ func init() {

 		return app.Save(agents)
 	}, func(app core.App) error {
-		agents, err := app.FindCollectionByNameOrId(models.AGENTS_TABLE)
+		agents, err := app.FindCollectionByNameOrId(dbmodels.AGENTS_TABLE)
 		if err != nil {
 			return nil
 		}
@@ -24,21 +24,21 @@ func init() {
 }

 func agentsTable() *core.Collection {
-	collection := core.NewBaseCollection(models.AGENTS_TABLE)
+	collection := core.NewBaseCollection(dbmodels.AGENTS_TABLE)
 	setBasicPublicRules(collection)
 	return collection
 }

 func agentsFields() core.FieldsList {
 	fields := core.NewFieldsList(
-		&core.TextField{Name: models.AGENTS_NAME_FIELD, Required: true, Presentable: true},
-		&core.BoolField{Name: models.AGENTS_CORP_FIELD, Required: false},
-		&core.BoolField{Name: models.AGENTS_FICTIONAL_FIELD, Required: false},
-		&core.URLField{Name: models.URI_FIELD, Required: false},
-		&core.TextField{Name: models.AGENTS_BIOGRAPHICAL_DATA_FIELD, Required: false, Presentable: true},
-		&core.TextField{Name: models.AGENTS_PROFESSION_FIELD, Required: false},
-		&core.TextField{Name: models.AGENTS_PSEUDONYMS_FIELD, Required: false},
-		&core.TextField{Name: models.REFERENCES_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.AGENTS_NAME_FIELD, Required: true, Presentable: true},
+		&core.BoolField{Name: dbmodels.AGENTS_CORP_FIELD, Required: false},
+		&core.BoolField{Name: dbmodels.AGENTS_FICTIONAL_FIELD, Required: false},
+		&core.URLField{Name: dbmodels.URI_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.AGENTS_BIOGRAPHICAL_DATA_FIELD, Required: false, Presentable: true},
+		&core.TextField{Name: dbmodels.AGENTS_PROFESSION_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.AGENTS_PSEUDONYMS_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.REFERENCES_FIELD, Required: false},
 	)

 	setMusenalmIDField(&fields)
@@ -50,6 +50,6 @@ func agentsFields() core.FieldsList {

 func agentsIndexes(collection *core.Collection) {
 	addMusenalmIDIndex(collection)
-	addIndex(collection, models.AGENTS_NAME_FIELD, false)
-	addIndex(collection, models.URI_FIELD, true)
+	addIndex(collection, dbmodels.AGENTS_NAME_FIELD, false)
+	addIndex(collection, dbmodels.URI_FIELD, false)
 }
--- a/migrations/1738936584_series.go
+++ b/migrations/1738936584_series.go
@@ -1,7 +1,7 @@
 package migrations

 import (
-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/pocketbase/pocketbase/core"
 	m "github.com/pocketbase/pocketbase/migrations"
 )
@@ -14,7 +14,7 @@ func init() {

 		return app.Save(series)
 	}, func(app core.App) error {
-		series, err := app.FindCollectionByNameOrId(models.SERIES_TABLE)
+		series, err := app.FindCollectionByNameOrId(dbmodels.SERIES_TABLE)
 		if err != nil {
 			return nil
 		}
@@ -24,16 +24,17 @@ func init() {
 }

 func seriesTable() *core.Collection {
-	collection := core.NewBaseCollection(models.SERIES_TABLE)
+	collection := core.NewBaseCollection(dbmodels.SERIES_TABLE)
 	setBasicPublicRules(collection)
 	return collection
 }

 func seriesFields() core.FieldsList {
 	fields := core.NewFieldsList(
-		&core.TextField{Name: models.SERIES_NAME_FIELD, Required: true, Presentable: true},
-		&core.TextField{Name: models.SERIES_PSEUDONYMS_FIELD, Required: false},
-		&core.TextField{Name: models.REFERENCES_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.SERIES_NAME_FIELD, Required: true, Presentable: true},
+		&core.TextField{Name: dbmodels.SERIES_PSEUDONYMS_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.REFERENCES_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.SERIES_FREQUENCY_FIELD, Required: false},
 	)

 	setMusenalmIDField(&fields)
--- a/migrations/1738936647_entries.go
+++ b/migrations/1738936647_entries.go
@@ -3,7 +3,7 @@ package migrations
 import (
 	"errors"

-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/pocketbase/pocketbase/core"
 	m "github.com/pocketbase/pocketbase/migrations"
 )
@@ -21,7 +21,7 @@ func init() {

 		return app.Save(entries)
 	}, func(app core.App) error {
-		entries, err := app.FindCollectionByNameOrId(models.ENTRIES_TABLE)
+		entries, err := app.FindCollectionByNameOrId(dbmodels.ENTRIES_TABLE)
 		if err != nil {
 			return nil
 		}
@@ -31,87 +31,82 @@ func init() {
 }

 func entriesTable() *core.Collection {
-	collection := core.NewBaseCollection(models.ENTRIES_TABLE)
+	collection := core.NewBaseCollection(dbmodels.ENTRIES_TABLE)
 	setBasicPublicRules(collection)
 	return collection
 }

 func entriesFields(app core.App) *core.FieldsList {
-	places, err := app.FindCollectionByNameOrId(models.PLACES_TABLE)
+	places, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE)
 	if err != nil {
 		return nil
 	}

 	fields := core.NewFieldsList(
 		// Title information
-		&core.TextField{Name: models.PREFERRED_TITLE_FIELD, Required: true, Presentable: true},
-		&core.TextField{Name: models.VARIANT_TITLE_FIELD, Required: false, Presentable: false},
-		&core.BoolField{Name: models.PARALLEL_TITLE_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.PREFERRED_TITLE_FIELD, Required: true, Presentable: true},
+		&core.TextField{Name: dbmodels.VARIANT_TITLE_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.PARALLEL_TITLE_FIELD, Required: false},

 		// Transcribed information
-		&core.TextField{Name: models.TITLE_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.SUBTITLE_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.INCIPIT_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.TITLE_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.SUBTITLE_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.INCIPIT_STMT_FIELD, Required: false, Presentable: false},

-		&core.TextField{Name: models.RESPONSIBILITY_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.PLACE_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.PUBLICATION_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.RESPONSIBILITY_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.PLACE_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.PUBLICATION_STMT_FIELD, Required: false, Presentable: false},

 		// Other discerning Information
-		&core.NumberField{Name: models.YEAR_FIELD, Required: false},
-		&core.TextField{Name: models.EDITION_FIELD, Required: false},
+		&core.NumberField{Name: dbmodels.YEAR_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.EDITION_FIELD, Required: false},

 		// Media Information
 		&core.SelectField{
-			Name:      models.LANGUAGE_FIELD,
+			Name:      dbmodels.LANGUAGE_FIELD,
 			Required:  false,
-			Values:    models.LANGUAGE_VALUES,
-			MaxSelect: len(models.LANGUAGE_VALUES),
+			Values:    dbmodels.LANGUAGE_VALUES,
+			MaxSelect: len(dbmodels.LANGUAGE_VALUES),
 		},
 		&core.SelectField{
-			Name:      models.CONTENT_TYPE_FIELD,
+			Name:      dbmodels.CONTENT_TYPE_FIELD,
 			Required:  false,
-			Values:    models.CONTENT_TYPE_VALUES,
-			MaxSelect: len(models.CONTENT_TYPE_VALUES),
+			Values:    dbmodels.CONTENT_TYPE_VALUES,
+			MaxSelect: len(dbmodels.CONTENT_TYPE_VALUES),
 		},

 		// Physical Description
-		&core.TextField{Name: models.EXTENT_FIELD, Required: false},
-		&core.TextField{Name: models.DIMENSIONS_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.EXTENT_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.DIMENSIONS_FIELD, Required: false},
 		&core.SelectField{
-			Name:      models.CARRIER_TYPE_FIELD,
+			Name:      dbmodels.CARRIER_TYPE_FIELD,
 			Required:  false,
-			Values:    models.MEDIA_TYPE_VALUES,
-			MaxSelect: len(models.MEDIA_TYPE_VALUES),
+			Values:    dbmodels.MEDIA_TYPE_VALUES,
+			MaxSelect: len(dbmodels.MEDIA_TYPE_VALUES),
 		},
 		&core.SelectField{
-			Name:      models.CARRIER_TYPE_FIELD,
+			Name:      dbmodels.CARRIER_TYPE_FIELD,
 			Required:  false,
-			Values:    models.CARRIER_TYPE_VALUES,
-			MaxSelect: len(models.CARRIER_TYPE_VALUES),
+			Values:    dbmodels.CARRIER_TYPE_VALUES,
+			MaxSelect: len(dbmodels.CARRIER_TYPE_VALUES),
 		},

 		// Norm Data
-		&core.TextField{Name: models.REFERENCES_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.REFERENCES_FIELD, Required: false},
 		&core.RelationField{
-			Name:          models.PLACES_TABLE,
+			Name:          dbmodels.PLACES_TABLE,
 			Required:      false,
 			CollectionId:  places.Id,
 			CascadeDelete: false,
 			MaxSelect:     5000,
 		},

-		// Musenalm specific data
-		&core.SelectField{
-			Name:      models.MUSENALM_BAENDE_STATUS_FIELD,
-			Required:  false,
-			Values:    models.MUSENALM_STATUS_VALUES,
-			MaxSelect: len(models.MUSENALM_STATUS_VALUES),
-		},
-		&core.JSONField{Name: models.MUSENALM_DEPRECATED_FIELD, Required: false},
-
 		// Exemplare:
-		&core.JSONField{Name: models.ITEMS_TABLE, Required: false},
+		&core.JSONField{Name: dbmodels.ITEMS_TABLE, Required: false},
+
+		// EDIT DATA:
+		&core.JSONField{Name: dbmodels.META_FIELD, Required: false},
+		&core.JSONField{Name: dbmodels.MUSENALM_DEPRECATED_FIELD, Required: false},
 	)

 	setMusenalmIDField(&fields)
@@ -123,15 +118,15 @@ func entriesFields(app core.App) *core.FieldsList {

 func entriesIndexes(collection *core.Collection) {
 	addMusenalmIDIndex(collection)
-	addIndex(collection, models.PREFERRED_TITLE_FIELD, false)
-	addIndex(collection, models.VARIANT_TITLE_FIELD, false)
-	addIndex(collection, models.PARALLEL_TITLE_FIELD, false)
-	addIndex(collection, models.TITLE_STMT_FIELD, false)
-	addIndex(collection, models.SUBTITLE_STMT_FIELD, false)
-	addIndex(collection, models.INCIPIT_STMT_FIELD, false)
-	addIndex(collection, models.RESPONSIBILITY_STMT_FIELD, false)
-	addIndex(collection, models.PLACE_STMT_FIELD, false)
-	addIndex(collection, models.PUBLICATION_STMT_FIELD, false)
-	addIndex(collection, models.YEAR_FIELD, false)
-	addIndex(collection, models.EDITION_FIELD, false)
+	addIndex(collection, dbmodels.PREFERRED_TITLE_FIELD, false)
+	addIndex(collection, dbmodels.VARIANT_TITLE_FIELD, false)
+	addIndex(collection, dbmodels.PARALLEL_TITLE_FIELD, false)
+	addIndex(collection, dbmodels.TITLE_STMT_FIELD, false)
+	addIndex(collection, dbmodels.SUBTITLE_STMT_FIELD, false)
+	addIndex(collection, dbmodels.INCIPIT_STMT_FIELD, false)
+	addIndex(collection, dbmodels.RESPONSIBILITY_STMT_FIELD, false)
+	addIndex(collection, dbmodels.PLACE_STMT_FIELD, false)
+	addIndex(collection, dbmodels.PUBLICATION_STMT_FIELD, false)
+	addIndex(collection, dbmodels.YEAR_FIELD, false)
+	addIndex(collection, dbmodels.EDITION_FIELD, false)
 }
--- a/migrations/1738936829_r_entries_series.go
+++ b/migrations/1738936829_r_entries_series.go
@@ -1,23 +1,23 @@
 package migrations

 import (
-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"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 {
-		collection, err := basicRelationCollection(app, models.ENTRIES_TABLE, models.SERIES_TABLE, models.SERIES_RELATIONS)
+		collection, err := basicRelationCollection(app, dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE, dbmodels.SERIES_RELATIONS)
 		if err != nil {
 			return err
 		}

-		collection.Fields.Add(&core.TextField{Name: models.NUMBERING_FIELD, Required: false, Presentable: true})
+		collection.Fields.Add(&core.TextField{Name: dbmodels.NUMBERING_FIELD, Required: false, Presentable: true})

 		return app.Save(collection)
 	}, func(app core.App) error {
-		collection, err := app.FindCollectionByNameOrId(models.RelationTableName(models.ENTRIES_TABLE, models.SERIES_TABLE))
+		collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE))
 		if err != nil {
 			return nil
 		}
--- a/migrations/1738942133_partials.go
+++ b/migrations/1738942133_partials.go
@@ -3,7 +3,7 @@ package migrations
 import (
 	"errors"

-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/pocketbase/pocketbase/core"
 	m "github.com/pocketbase/pocketbase/migrations"
 )
@@ -21,7 +21,7 @@ func init() {

 		return app.Save(partials)
 	}, func(app core.App) error {
-		partials, err := app.FindCollectionByNameOrId(models.PARTIALS_TABLE)
+		partials, err := app.FindCollectionByNameOrId(dbmodels.PARTIALS_TABLE)
 		if err != nil {
 			return nil
 		}
@@ -31,92 +31,92 @@ func init() {
 }

 func partialsTable() *core.Collection {
-	collection := core.NewBaseCollection(models.PARTIALS_TABLE)
+	collection := core.NewBaseCollection(dbmodels.PARTIALS_TABLE)
 	setBasicPublicRules(collection)
 	return collection
 }

 func partialsFields(app core.App) *core.FieldsList {
-	entries, err := app.FindCollectionByNameOrId(models.ENTRIES_TABLE)
+	entries, err := app.FindCollectionByNameOrId(dbmodels.ENTRIES_TABLE)
 	if err != nil {
 		return nil
 	}

 	fields := core.NewFieldsList(
 		// Title information
-		&core.TextField{Name: models.PREFERRED_TITLE_FIELD, Required: true, Presentable: true},
-		&core.TextField{Name: models.VARIANT_TITLE_FIELD, Required: false, Presentable: false},
-		&core.BoolField{Name: models.PARALLEL_TITLE_FIELD, Required: false},
+		&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},

 		// Transcribed information
-		&core.TextField{Name: models.TITLE_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.SUBTITLE_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.INCIPIT_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.TITLE_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.SUBTITLE_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.INCIPIT_STMT_FIELD, Required: false, Presentable: false},

-		&core.TextField{Name: models.RESPONSIBILITY_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.PLACE_STMT_FIELD, Required: false, Presentable: false},
-		&core.TextField{Name: models.PUBLICATION_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.RESPONSIBILITY_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.PLACE_STMT_FIELD, Required: false, Presentable: false},
+		&core.TextField{Name: dbmodels.PUBLICATION_STMT_FIELD, Required: false, Presentable: false},

 		// Other discerning Information
-		&core.NumberField{Name: models.YEAR_FIELD, Required: false},
-		&core.TextField{Name: models.EDITION_FIELD, Required: false},
+		&core.NumberField{Name: dbmodels.YEAR_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.EDITION_FIELD, Required: false},

 		// Media Information
 		&core.SelectField{
-			Name:      models.LANGUAGE_FIELD,
+			Name:      dbmodels.LANGUAGE_FIELD,
 			Required:  false,
-			Values:    models.LANGUAGE_VALUES,
-			MaxSelect: len(models.LANGUAGE_VALUES),
+			Values:    dbmodels.LANGUAGE_VALUES,
+			MaxSelect: len(dbmodels.LANGUAGE_VALUES),
 		},
 		&core.SelectField{
-			Name:      models.CONTENT_TYPE_FIELD,
+			Name:      dbmodels.CONTENT_TYPE_FIELD,
 			Required:  false,
-			Values:    models.CONTENT_TYPE_VALUES,
-			MaxSelect: len(models.CONTENT_TYPE_VALUES),
+			Values:    dbmodels.CONTENT_TYPE_VALUES,
+			MaxSelect: len(dbmodels.CONTENT_TYPE_VALUES),
 		},

 		// Physical Description
-		&core.TextField{Name: models.EXTENT_FIELD, Required: false},
-		&core.TextField{Name: models.DIMENSIONS_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.EXTENT_FIELD, Required: false},
+		&core.TextField{Name: dbmodels.DIMENSIONS_FIELD, Required: false},
 		&core.SelectField{
-			Name:      models.MEDIA_TYPE_FIELD,
+			Name:      dbmodels.MEDIA_TYPE_FIELD,
 			Required:  false,
-			Values:    models.MEDIA_TYPE_VALUES,
-			MaxSelect: len(models.MEDIA_TYPE_VALUES),
+			Values:    dbmodels.MEDIA_TYPE_VALUES,
+			MaxSelect: len(dbmodels.MEDIA_TYPE_VALUES),
 		},
 		&core.SelectField{
-			Name:      models.CARRIER_TYPE_FIELD,
+			Name:      dbmodels.CARRIER_TYPE_FIELD,
 			Required:  false,
-			Values:    models.CARRIER_TYPE_VALUES,
-			MaxSelect: len(models.CARRIER_TYPE_VALUES),
+			Values:    dbmodels.CARRIER_TYPE_VALUES,
+			MaxSelect: len(dbmodels.CARRIER_TYPE_VALUES),
 		},

 		// Musenalm specific data
 		&core.SelectField{
-			Name:      models.MUSENALM_INHALTE_TYPE_FIELD,
+			Name:      dbmodels.MUSENALM_INHALTE_TYPE_FIELD,
 			Required:  false,
-			Values:    models.MUSENALM_TYPE_VALUES,
-			MaxSelect: len(models.MUSENALM_TYPE_VALUES),
+			Values:    dbmodels.MUSENALM_TYPE_VALUES,
+			MaxSelect: len(dbmodels.MUSENALM_TYPE_VALUES),
 		},
 		&core.SelectField{
-			Name:      models.MUSENALM_PAGINATION_FIELD,
+			Name:      dbmodels.MUSENALM_PAGINATION_FIELD,
 			Required:  false,
-			Values:    models.MUSENALM_PAGINATION_VALUES,
-			MaxSelect: len(models.MUSENALM_PAGINATION_VALUES),
+			Values:    dbmodels.MUSENALM_PAGINATION_VALUES,
+			MaxSelect: len(dbmodels.MUSENALM_PAGINATION_VALUES),
 		},
 		&core.FileField{
-			Name:      models.SCAN_FIELD,
+			Name:      dbmodels.SCAN_FIELD,
 			Required:  false,
 			MaxSize:   100 * 1024 * 1024,
 			MaxSelect: 1000,
-			MimeTypes: models.MUSENALM_MIME_TYPES,
+			MimeTypes: dbmodels.MUSENALM_MIME_TYPES,
 			Thumbs:    []string{"0x300", "0x500", "0x1000", "300x0", "500x0", "1000x0"},
 		}, // 100 MB a file

 		// Band:
-		&core.NumberField{Name: models.NUMBERING_FIELD, Required: false},
+		&core.NumberField{Name: dbmodels.NUMBERING_FIELD, Required: false},
 		&core.RelationField{
-			Name:          models.ENTRIES_TABLE,
+			Name:          dbmodels.ENTRIES_TABLE,
 			Required:      true,
 			CollectionId:  entries.Id,
 			CascadeDelete: false,
@@ -134,15 +134,15 @@ func partialsFields(app core.App) *core.FieldsList {

 func partialsIndexes(collection *core.Collection) {
 	addMusenalmIDIndex(collection)
-	addIndex(collection, models.PREFERRED_TITLE_FIELD, false)
-	addIndex(collection, models.VARIANT_TITLE_FIELD, false)
-	addIndex(collection, models.PARALLEL_TITLE_FIELD, false)
-	addIndex(collection, models.TITLE_STMT_FIELD, false)
-	addIndex(collection, models.SUBTITLE_STMT_FIELD, false)
-	addIndex(collection, models.INCIPIT_STMT_FIELD, false)
-	addIndex(collection, models.RESPONSIBILITY_STMT_FIELD, false)
-	addIndex(collection, models.PLACE_STMT_FIELD, false)
-	addIndex(collection, models.PUBLICATION_STMT_FIELD, false)
-	addIndex(collection, models.YEAR_FIELD, false)
-	addIndex(collection, models.EDITION_FIELD, false)
+	addIndex(collection, dbmodels.PREFERRED_TITLE_FIELD, false)
+	addIndex(collection, dbmodels.VARIANT_TITLE_FIELD, false)
+	addIndex(collection, dbmodels.PARALLEL_TITLE_FIELD, false)
+	addIndex(collection, dbmodels.TITLE_STMT_FIELD, false)
+	addIndex(collection, dbmodels.SUBTITLE_STMT_FIELD, false)
+	addIndex(collection, dbmodels.INCIPIT_STMT_FIELD, false)
+	addIndex(collection, dbmodels.RESPONSIBILITY_STMT_FIELD, false)
+	addIndex(collection, dbmodels.PLACE_STMT_FIELD, false)
+	addIndex(collection, dbmodels.PUBLICATION_STMT_FIELD, false)
+	addIndex(collection, dbmodels.YEAR_FIELD, false)
+	addIndex(collection, dbmodels.EDITION_FIELD, false)
 }
--- a/migrations/1738951458_r_partials_agents.go
+++ b/migrations/1738951458_r_partials_agents.go
@@ -1,21 +1,21 @@
 package migrations

 import (
-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"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 {
-		collections, err := basicRelationCollection(app, models.PARTIALS_TABLE, models.AGENTS_TABLE, models.AGENT_RELATIONS)
+		collections, err := basicRelationCollection(app, dbmodels.PARTIALS_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(models.RelationTableName(models.PARTIALS_TABLE, models.AGENTS_TABLE))
+		collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.PARTIALS_TABLE, dbmodels.AGENTS_TABLE))
 		if err != nil {
 			return nil
 		}
--- a/migrations/1738952826_r_entries_agents.go
+++ b/migrations/1738952826_r_entries_agents.go
@@ -1,21 +1,21 @@
 package migrations

 import (
-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"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 {
-		collections, err := basicRelationCollection(app, models.ENTRIES_TABLE, models.AGENTS_TABLE, models.AGENT_RELATIONS)
+		collections, err := basicRelationCollection(app, dbmodels.ENTRIES_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(models.RelationTableName(models.ENTRIES_TABLE, models.AGENTS_TABLE))
+		collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE))
 		if err != nil {
 			return nil
 		}
--- a/migrations/1739007272_insert_data.go
+++ b/migrations/1739007272_insert_data.go
@@ -0,0 +1,48 @@
+package migrations
+
+import (
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/migrations/seed"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+	m "github.com/pocketbase/pocketbase/migrations"
+)
+
+func init() {
+	m.Register(func(app core.App) error {
+		adb, err := xmlmodels.ReadAccessDB(xmlmodels.DATA_PATH)
+		if err != nil {
+			return err
+		}
+
+		*adb.Reihen = xmlmodels.SanitizeReihen(*adb.Reihen, *adb.Relationen_Bände_Reihen)
+
+		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)
+	})
+}
+
+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.ENTRIES_TABLE)
+	_ = deleteTableContents(app, dbmodels.SERIES_TABLE)
+	_ = deleteTableContents(app, dbmodels.AGENTS_TABLE)
+	_ = deleteTableContents(app, dbmodels.PLACES_TABLE)
+	return nil
+}
+
+func deleteTableContents(app core.App, table string) error {
+	_, err := app.DB().NewQuery("DELETE FROM " + table).Execute()
+	if err != nil {
+		return err
+	}
+	return nil
+}
--- a/migrations/common.go
+++ b/migrations/common.go
@@ -1,30 +1,30 @@
 package migrations

 import (
-	"github.com/Theodor-Springmann-Stiftung/musenalm/models"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/types"
 )

 func setBasicPublicRules(collection *core.Collection) {
-	collection.ViewRule = types.Pointer(models.PUBLIC_VIEW_RULE)
+	collection.ViewRule = types.Pointer(dbmodels.PUBLIC_VIEW_RULE)
 }

 func setMusenalmIDField(fieldlist *core.FieldsList) {
-	fieldlist.Add(&core.TextField{Name: models.MUSENALMID_FIELD, Max: 64, Required: false})
+	fieldlist.Add(&core.TextField{Name: dbmodels.MUSENALMID_FIELD, Max: 64, Required: false})
 }

 func setEditorStateField(fieldlist *core.FieldsList) {
-	fieldlist.Add(&core.SelectField{Name: models.EDITSTATE_FIELD, Required: false, Values: models.EDITORSTATE_VALUES})
+	fieldlist.Add(&core.SelectField{Name: dbmodels.EDITSTATE_FIELD, Required: false, Values: dbmodels.EDITORSTATE_VALUES})
 }

 func setNotesAndAnnotationsField(fieldlist *core.FieldsList) {
-	fieldlist.Add(&core.EditorField{Name: models.ANNOTATION_FIELD, Required: false, ConvertURLs: false})
-	fieldlist.Add(&core.EditorField{Name: models.COMMENT_FIELD, Required: false, ConvertURLs: false})
+	fieldlist.Add(&core.EditorField{Name: dbmodels.ANNOTATION_FIELD, Required: false, ConvertURLs: false})
+	fieldlist.Add(&core.EditorField{Name: dbmodels.COMMENT_FIELD, Required: false, ConvertURLs: false})
 }

 func addMusenalmIDIndex(collection *core.Collection) {
-	addIndex(collection, models.MUSENALMID_FIELD, true)
+	addIndex(collection, dbmodels.MUSENALMID_FIELD, true)
 }

 func addIndex(collection *core.Collection, field string, unique bool) {
@@ -43,15 +43,15 @@ func basicRelationCollection(app core.App, sourcetablename, targettablename stri
 		return nil, err
 	}

-	collection := core.NewBaseCollection(models.RelationTableName(stable.Name, ttable.Name))
+	collection := core.NewBaseCollection(dbmodels.RelationTableName(stable.Name, ttable.Name))
 	setBasicPublicRules(collection)

 	fields := core.NewFieldsList(
 		&core.RelationField{Name: stable.Name, Required: true, CollectionId: stable.Id, MinSelect: 1, MaxSelect: 1},
 		&core.RelationField{Name: ttable.Name, Required: true, CollectionId: ttable.Id, MinSelect: 1, MaxSelect: 1},
-		&core.SelectField{Name: models.RELATION_TYPE_FIELD, Required: true, Values: relations, MaxSelect: 1},
-		&core.BoolField{Name: models.RELATION_CONJECTURE_FIELD, Required: false},
-		&core.BoolField{Name: models.RELATION_UNCERTAIN_FIELD, Required: false},
+		&core.SelectField{Name: dbmodels.RELATION_TYPE_FIELD, Required: true, Values: relations, MaxSelect: 1},
+		&core.BoolField{Name: dbmodels.RELATION_CONJECTURE_FIELD, Required: false},
+		&core.BoolField{Name: dbmodels.RELATION_UNCERTAIN_FIELD, Required: false},
 	)

 	setNotesAndAnnotationsField(&fields)
@@ -59,7 +59,7 @@ func basicRelationCollection(app core.App, sourcetablename, targettablename stri
 	collection.Fields = fields
 	addIndex(collection, stable.Name, false)
 	addIndex(collection, ttable.Name, false)
-	addIndex(collection, models.RELATION_TYPE_FIELD, false)
+	addIndex(collection, dbmodels.RELATION_TYPE_FIELD, false)

 	return collection, nil
 }
--- a/migrations/consts.go
+++ b/migrations/consts.go
@@ -1 +0,0 @@
-package migrations
--- a/migrations/seed/agents.go
+++ b/migrations/seed/agents.go
@@ -0,0 +1,41 @@
+package seed
+
+import (
+	"fmt"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func SeedTableAgents(app core.App, akteure xmlmodels.Akteure) error {
+	collection, err := app.FindCollectionByNameOrId(dbmodels.AGENTS_TABLE)
+	records := make([]*core.Record, 0, len(akteure.Akteure))
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	for i := 0; i < len(akteure.Akteure); i++ {
+		record := 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)
+
+		n := akteur.Name
+		if n == "" {
+			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 batchSave(app, records)
+}
--- a/migrations/seed/common.go
+++ b/migrations/seed/common.go
@@ -0,0 +1,28 @@
+package seed
+
+import (
+	"strings"
+
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func NormalizeString(s string) string {
+	s = strings.TrimSpace(s)
+	s = strings.ReplaceAll(s, "<div>", "")
+	s = strings.ReplaceAll(s, "</div>", "")
+	return s
+}
+
+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 {
+				app.Logger().Error("Error saving record.", "error", err, "record", record)
+				continue
+			}
+		}
+		return nil
+	})
+
+	return nil
+}
--- a/migrations/seed/entries.go
+++ b/migrations/seed/entries.go
@@ -0,0 +1,224 @@
+package seed
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/helpers/datatypes"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func SeedTableEntries(
+	app core.App,
+	entries xmlmodels.Bände,
+	biblio map[int]xmlmodels.BIBLIOEintrag,
+	orte xmlmodels.Orte,
+) 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)
+	}
+
+	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
+	}
+
+	for i := 0; i < len(entries.Bände); i++ {
+		band := entries.Bände[i]
+		record := core.NewRecord(collection)
+
+		// TODO: Hier bevorzugter reihentitel + jahr, oder irgendein reihentitel, oder reihentitelALT
+		if band.ReihentitelALT == "" {
+			continue
+		}
+		record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(band.ReihentitelALT))
+		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)
+
+		if band.Erfasst {
+			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1])
+		} else if band.Gesichtet {
+			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[2])
+		} else if band.BiblioID != 0 {
+			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1])
+		} else {
+			record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[0])
+		}
+
+		handleDeprecated(record, band)
+		handleItems(r, band, &biblio, record)
+		handleOrte(record, band, omap, app, ocoll)
+
+		records = append(records, record)
+	}
+
+	return batchSave(app, records)
+}
+
+func handleOrte(
+	record *core.Record,
+	band xmlmodels.Band,
+	orte map[string]xmlmodels.Ort,
+	app core.App,
+	ocollection *core.Collection,
+) {
+	for _, v := range band.Orte {
+		o, ok := orte[v.Value]
+		if ok {
+			n := NormalizeString(o.Name)
+			e := false
+			if strings.HasPrefix(n, "[") {
+				n = n[1 : len(n)-1]
+				e = true
+			}
+
+			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))
+			} 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])
+				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))
+				}
+			}
+
+			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}},
+				)
+			}
+		}
+	}
+}
+
+func handleDeprecated(record *core.Record, band xmlmodels.Band) {
+	depr := dbmodels.Deprecated{
+		Reihentitel: NormalizeString(band.ReihentitelALT),
+		Norm:        NormalizeString(band.Norm),
+		BiblioID:    band.BiblioID,
+		Status:      band.Status.Value,
+	}
+
+	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/places.go
+++ b/migrations/seed/places.go
@@ -0,0 +1,37 @@
+package seed
+
+import (
+	"fmt"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func SeedTablePlaces(app core.App, orte xmlmodels.Orte) error {
+	collection, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE)
+	records := make([]*core.Record, 0, len(orte.Orte))
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	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)
+
+		n := ort.Name
+		if n == "" {
+			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 batchSave(app, records)
+}
--- a/migrations/seed/series.go
+++ b/migrations/seed/series.go
@@ -0,0 +1,43 @@
+package seed
+
+import (
+	"fmt"
+
+	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
+	"github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+func SeedTableSeries(app core.App, reihen xmlmodels.Reihentitel) error {
+	collection, err := app.FindCollectionByNameOrId(dbmodels.SERIES_TABLE)
+	records := make([]*core.Record, 0, len(reihen.Reihen))
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	for i := 0; i < len(reihen.Reihen); i++ {
+		record := core.NewRecord(collection)
+		reihe := reihen.Reihen[i]
+		if reihe.Titel == "" {
+			record.Set(dbmodels.SERIES_NAME_FIELD, reihe.Sortiername)
+		} else {
+			record.Set(dbmodels.SERIES_NAME_FIELD, 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)
+
+		n := record.GetString(dbmodels.SERIES_NAME_FIELD)
+		if n == "" {
+			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 batchSave(app, records)
+}