From 851de285aa592bde3e304b0f4de79bc8ee44227e Mon Sep 17 00:00:00 2001 From: Simon Martens Date: Sat, 8 Feb 2025 23:04:32 +0100 Subject: [PATCH] =?UTF-8?q?Relationen,=20fehlt=20-PreferredTitle=20f=C3=BC?= =?UTF-8?q?r=20Entries=20-=C3=9Cberfl=C3=BCssige=20Felder=20in=20Contents?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 1 + dbmodels/dbdata.go | 67 +++++---- migrations/1738936648_items.go | 73 ++++++++++ migrations/1738942133_partials.go | 10 +- migrations/1738951458_r_partials_agents.go | 4 +- migrations/1739007272_insert_data.go | 99 ++++++++++++-- migrations/seed/agents.go | 5 +- migrations/seed/common.go | 2 +- migrations/seed/entries.go | 102 +------------- migrations/seed/items.go | 144 +++++++++++++++++++ migrations/seed/partials.go | 98 +++++++++++++ migrations/seed/places.go | 5 +- migrations/seed/r_contents_agents.go | 144 +++++++++++++++++++ migrations/seed/r_entries_agents.go | 59 ++++++++ migrations/seed/r_entries_series.go | 68 +++++++++ migrations/seed/series.go | 5 +- scripts/reset.sh | 3 + xmlmodels/accessdb.go | 152 +++++++++++++-------- xmlmodels/relationen.go | 6 +- 19 files changed, 844 insertions(+), 203 deletions(-) create mode 100644 migrations/1738936648_items.go create mode 100644 migrations/seed/items.go create mode 100644 migrations/seed/partials.go create mode 100644 migrations/seed/r_contents_agents.go create mode 100644 migrations/seed/r_entries_agents.go create mode 100644 migrations/seed/r_entries_series.go create mode 100755 scripts/reset.sh diff --git a/.gitignore b/.gitignore index 5a1dc89..8209d48 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ pb_data/ +musenalm diff --git a/dbmodels/dbdata.go b/dbmodels/dbdata.go index 470b2fe..8df50ab 100644 --- a/dbmodels/dbdata.go +++ b/dbmodels/dbdata.go @@ -1,6 +1,14 @@ package dbmodels -var EDITORSTATE_VALUES = []string{"Unknown", "ToDo", "Seen", "Partially Edited", "Waiting", "Edited"} +var EDITORSTATE_VALUES = []string{"Unknown", "ToDo", "Seen", "Partially Edited", "Waiting", "Review", "Edited"} + +var ITEM_TYPE_VALUES = []string{ + "Original", + "Reproduktion", + "Mikrofiche", + "Digitalisat", + "URL", +} var MEDIA_TYPE_VALUES = []string{ "audio", @@ -319,27 +327,28 @@ var MUSENALM_TYPE_VALUES = []string{ "Widmung", } -var MUSENALM_PAGINATION_VALUES = []string{ - "Römische Seitenzählung", - "Arabische Seitenzählung", - "Alphabetische Seitenzählung", - "Sonstige Seitenzählung", - "1. Arabische Seitenzählung", - "2. Arabische Seitenzählung", - "3. Arabische Seitenzählung", - "4. Arabische Seitenzählung", - "5. Arabische Seitenzählung", - "6. Arabische Seitenzählung", - "7. Arabische Seitenzählung", - "8. Arabische Seitenzählung", - "1. Römische Seitenzählung", - "2. Römische Seitenzählung", - "3. Römische Seitenzählung", - "4. Römische Seitenzählung", - "5. Römische Seitenzählung", - "6. Römische Seitenzählung", - "7. Römische Seitenzählung", - "8. Römische Seitenzählung", +var MUSENALM_PAGINATION_VALUES = map[string]string{ + "": "", + "röm": "Römische Seitenzählung", + "ar": "Arabische Seitenzählung", + "alph": "Alphabetische Seitenzählung", + "sonst": "Sonstige Seitenzählung", + "ar1": "1. Arabische Seitenzählung", + "ar2": "2. Arabische Seitenzählung", + "ar3": "3. Arabische Seitenzählung", + "ar4": "4. Arabische Seitenzählung", + "ar5": "5. Arabische Seitenzählung", + "ar6": "6. Arabische Seitenzählung", + "ar7": "7. Arabische Seitenzählung", + "ar8": "8. Arabische Seitenzählung", + "röm1": "1. Römische Seitenzählung", + "röm2": "2. Römische Seitenzählung", + "röm3": "3. Römische Seitenzählung", + "röm4": "4. Römische Seitenzählung", + "röm5": "5. Römische Seitenzählung", + "röm6": "6. Römische Seitenzählung", + "röm7": "7. Römische Seitenzählung", + "röm8": "8. Römische Seitenzählung", } var MUSENALM_MIME_TYPES = []string{ @@ -377,6 +386,7 @@ var MUSENALM_MIME_TYPES = []string{ } var AGENT_RELATIONS = []string{ + "Schöpfer", "Autor:in", "Herausgeber:in", "Verlag", @@ -384,7 +394,12 @@ var AGENT_RELATIONS = []string{ "Vertrieb", "Stecher:in", "Zeichner:in", + "Komponist:in", + "Künstler:in", "Übersetzer:in", + "Redakteur:in", + "Kartograf:in", + "Kupferstecher:in", } var SERIES_RELATIONS = []string{ @@ -402,7 +417,7 @@ const ( AGENTS_TABLE = "agents" SERIES_TABLE = "series" ENTRIES_TABLE = "entries" - PARTIALS_TABLE = "partials" + CONTENTS_TABLE = "contents" ITEMS_TABLE = "items" ANNOTATION_FIELD = "annotation" @@ -462,6 +477,12 @@ const ( NUMBERING_FIELD = "numbering" SCAN_FIELD = "scans" + + ITEMS_LOCATION_FIELD = "location" + ITEMS_OWNER_FIELD = "owner" + ITEMS_MEDIA_FIELD = "media" + ITEMS_CONDITION_FIELD = "condition" + ITEMS_IDENTIFIER_FIELD = "identifier" ) func RelationTableName(collection1, collection2 string) string { diff --git a/migrations/1738936648_items.go b/migrations/1738936648_items.go new file mode 100644 index 0000000..a34aa68 --- /dev/null +++ b/migrations/1738936648_items.go @@ -0,0 +1,73 @@ +package migrations + +import ( + "github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels" + "github.com/pocketbase/pocketbase/core" + m "github.com/pocketbase/pocketbase/migrations" +) + +func init() { + m.Register(func(app core.App) error { + items := itemsTable() + items.Fields = itemsFields(app) + itemsIndexes(items) + + return app.Save(items) + }, func(app core.App) error { + items, err := app.FindCollectionByNameOrId(dbmodels.ITEMS_TABLE) + if err != nil { + return nil + } + + return app.Delete(items) + }) +} + +func itemsTable() *core.Collection { + collection := core.NewBaseCollection(dbmodels.ITEMS_TABLE) + setBasicPublicRules(collection) + return collection +} + +func itemsFields(app core.App) core.FieldsList { + bcoll, err := app.FindCollectionByNameOrId(dbmodels.ENTRIES_TABLE) + if err != nil { + panic(err) + } + + fields := core.NewFieldsList( + &core.RelationField{Name: dbmodels.ENTRIES_TABLE, CollectionId: bcoll.Id, Required: false}, + &core.TextField{Name: dbmodels.ITEMS_IDENTIFIER_FIELD, Required: true, Presentable: true}, + &core.TextField{Name: dbmodels.ITEMS_LOCATION_FIELD, Required: false, Presentable: true}, + &core.TextField{Name: dbmodels.ITEMS_OWNER_FIELD, Required: false, Presentable: false}, + &core.SelectField{ + Name: dbmodels.ITEMS_MEDIA_FIELD, + Required: false, + Presentable: true, + Values: dbmodels.ITEM_TYPE_VALUES, + MaxSelect: len(dbmodels.ITEM_TYPE_VALUES) - 1, + }, + &core.TextField{Name: dbmodels.ITEMS_CONDITION_FIELD, Required: false, Presentable: true}, + &core.FileField{ + Name: dbmodels.SCAN_FIELD, + Required: false, + MaxSize: 100 * 1024 * 1024, + MaxSelect: 1000, + MimeTypes: dbmodels.MUSENALM_MIME_TYPES, + Thumbs: []string{"0x300", "0x500", "0x1000", "300x0", "500x0", "1000x0"}, + }, // 100 MB a file + &core.URLField{Name: dbmodels.URI_FIELD, Required: false, Presentable: false}, + ) + + setNotesAndAnnotationsField(&fields) + + return fields +} + +func itemsIndexes(collection *core.Collection) { + addIndex(collection, dbmodels.ITEMS_CONDITION_FIELD, false) + addIndex(collection, dbmodels.ITEMS_OWNER_FIELD, false) + addIndex(collection, dbmodels.ITEMS_LOCATION_FIELD, false) + addIndex(collection, dbmodels.ITEMS_IDENTIFIER_FIELD, false) + addIndex(collection, dbmodels.URI_FIELD, false) +} diff --git a/migrations/1738942133_partials.go b/migrations/1738942133_partials.go index 9794bbb..51f0842 100644 --- a/migrations/1738942133_partials.go +++ b/migrations/1738942133_partials.go @@ -2,6 +2,8 @@ package migrations import ( "errors" + "maps" + "slices" "github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels" "github.com/pocketbase/pocketbase/core" @@ -21,7 +23,7 @@ func init() { return app.Save(partials) }, func(app core.App) error { - partials, err := app.FindCollectionByNameOrId(dbmodels.PARTIALS_TABLE) + partials, err := app.FindCollectionByNameOrId(dbmodels.CONTENTS_TABLE) if err != nil { return nil } @@ -31,7 +33,7 @@ func init() { } func partialsTable() *core.Collection { - collection := core.NewBaseCollection(dbmodels.PARTIALS_TABLE) + collection := core.NewBaseCollection(dbmodels.CONTENTS_TABLE) setBasicPublicRules(collection) return collection } @@ -46,7 +48,7 @@ func partialsFields(app core.App) *core.FieldsList { // Title information &core.TextField{Name: dbmodels.PREFERRED_TITLE_FIELD, Required: true, Presentable: true}, &core.TextField{Name: dbmodels.VARIANT_TITLE_FIELD, Required: false, Presentable: false}, - &core.BoolField{Name: dbmodels.PARALLEL_TITLE_FIELD, Required: false}, + &core.TextField{Name: dbmodels.PARALLEL_TITLE_FIELD, Required: false}, // Transcribed information &core.TextField{Name: dbmodels.TITLE_STMT_FIELD, Required: false, Presentable: false}, @@ -101,7 +103,7 @@ func partialsFields(app core.App) *core.FieldsList { &core.SelectField{ Name: dbmodels.MUSENALM_PAGINATION_FIELD, Required: false, - Values: dbmodels.MUSENALM_PAGINATION_VALUES, + Values: slices.Collect(maps.Values(dbmodels.MUSENALM_PAGINATION_VALUES)), MaxSelect: len(dbmodels.MUSENALM_PAGINATION_VALUES), }, &core.FileField{ diff --git a/migrations/1738951458_r_partials_agents.go b/migrations/1738951458_r_partials_agents.go index d70c4b6..35038b8 100644 --- a/migrations/1738951458_r_partials_agents.go +++ b/migrations/1738951458_r_partials_agents.go @@ -8,14 +8,14 @@ import ( func init() { m.Register(func(app core.App) error { - collections, err := basicRelationCollection(app, dbmodels.PARTIALS_TABLE, dbmodels.AGENTS_TABLE, dbmodels.AGENT_RELATIONS) + collections, err := basicRelationCollection(app, dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE, dbmodels.AGENT_RELATIONS) if err != nil { return err } return app.Save(collections) }, func(app core.App) error { - collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.PARTIALS_TABLE, dbmodels.AGENTS_TABLE)) + collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE)) if err != nil { return nil } diff --git a/migrations/1739007272_insert_data.go b/migrations/1739007272_insert_data.go index e45a548..7926fe8 100644 --- a/migrations/1739007272_insert_data.go +++ b/migrations/1739007272_insert_data.go @@ -1,6 +1,8 @@ package migrations import ( + "sync" + "github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels" "github.com/Theodor-Springmann-Stiftung/musenalm/migrations/seed" "github.com/Theodor-Springmann-Stiftung/musenalm/xmlmodels" @@ -10,17 +12,98 @@ import ( func init() { m.Register(func(app core.App) error { - adb, err := xmlmodels.ReadAccessDB(xmlmodels.DATA_PATH) + adb, err := xmlmodels.ReadAccessDB(xmlmodels.DATA_PATH, app.Logger()) if err != nil { return err } - *adb.Reihen = xmlmodels.SanitizeReihen(*adb.Reihen, *adb.Relationen_Bände_Reihen) + adb.Reihen = xmlmodels.SanitizeReihen(adb.Reihen, adb.Relationen_Bände_Reihen) + + wg := sync.WaitGroup{} + wg.Add(3) + go func() { + if records, err := seed.RecordsFromAkteure(app, adb.Akteure); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + wg.Done() + }() + + go func() { + if records, err := seed.RecordsFromOrte(app, adb.Orte); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + wg.Done() + }() + + go func() { + if records, err := seed.RecordsFromReihentitel(app, adb.Reihen); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + wg.Done() + }() + + wg.Wait() + + if records, err := seed.RecordsFromBände(app, adb.Bände, adb.Orte); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + + if records, err := seed.ItemsFromBändeAndBIBLIO(app, adb.Bände, adb.BIBLIO); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + + if records, err := seed.RecordsFromInhalte(app, adb.Inhalte); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + + if records, err := seed.RecordsFromRelationBändeReihen(app, adb.Relationen_Bände_Reihen); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + + if records, err := seed.RecordsFromRelationBändeAkteure(app, adb.Relationen_Bände_Akteure); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } + + if records, err := seed.RecordsFromRelationInhalteAkteure(app, adb.Relationen_Inhalte_Akteure); err == nil { + if err = seed.BatchSave(app, records); err != nil { + panic(err) + } + } else { + panic(err) + } - seed.SeedTableAgents(app, *adb.Akteure) - seed.SeedTablePlaces(app, *adb.Orte) - seed.SeedTableSeries(app, *adb.Reihen) - seed.SeedTableEntries(app, *adb.Bände, *adb.BIBLIO, *adb.Orte) return nil }, func(app core.App) error { return delete_data(app) @@ -30,8 +113,8 @@ func init() { func delete_data(app core.App) error { _ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE)) _ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE)) - _ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.PARTIALS_TABLE, dbmodels.AGENTS_TABLE)) - _ = deleteTableContents(app, dbmodels.PARTIALS_TABLE) + _ = deleteTableContents(app, dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE)) + _ = deleteTableContents(app, dbmodels.CONTENTS_TABLE) _ = deleteTableContents(app, dbmodels.ENTRIES_TABLE) _ = deleteTableContents(app, dbmodels.SERIES_TABLE) _ = deleteTableContents(app, dbmodels.AGENTS_TABLE) diff --git a/migrations/seed/agents.go b/migrations/seed/agents.go index c840c9d..d852ac0 100644 --- 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 } diff --git a/migrations/seed/common.go b/migrations/seed/common.go index 504f44b..a9f0f5f 100644 --- 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 { diff --git a/migrations/seed/entries.go b/migrations/seed/entries.go index 76f9ad5..368f62b 100644 --- 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 -} diff --git a/migrations/seed/items.go b/migrations/seed/items.go new file mode 100644 index 0000000..bedd067 --- /dev/null +++ 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 +} diff --git a/migrations/seed/partials.go b/migrations/seed/partials.go new file mode 100644 index 0000000..dcbdf0d --- /dev/null +++ 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] +} diff --git a/migrations/seed/places.go b/migrations/seed/places.go index d3ba427..4e02f48 100644 --- 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 } diff --git a/migrations/seed/r_contents_agents.go b/migrations/seed/r_contents_agents.go new file mode 100644 index 0000000..4bb94e7 --- /dev/null +++ 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" +} diff --git a/migrations/seed/r_entries_agents.go b/migrations/seed/r_entries_agents.go new file mode 100644 index 0000000..82434f1 --- /dev/null +++ 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 +} diff --git a/migrations/seed/r_entries_series.go b/migrations/seed/r_entries_series.go new file mode 100644 index 0000000..189c8f6 --- /dev/null +++ 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 +} diff --git a/migrations/seed/series.go b/migrations/seed/series.go index e9b0663..88fdb12 100644 --- 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 } diff --git a/scripts/reset.sh b/scripts/reset.sh new file mode 100755 index 0000000..c7fdb6d --- /dev/null +++ b/scripts/reset.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +rm -rf pb_data/ diff --git a/xmlmodels/accessdb.go b/xmlmodels/accessdb.go index 596711c..a3edd50 100644 --- a/xmlmodels/accessdb.go +++ b/xmlmodels/accessdb.go @@ -4,24 +4,26 @@ import ( "encoding/xml" "fmt" "io" + "log/slog" "os" + "sync" "github.com/Theodor-Springmann-Stiftung/musenalm/helpers/datatypes" ) type AccessDB struct { - Orte *Orte - Akteure *Akteure - Reihen *Reihentitel - Bände *Bände - Inhalte *Inhalte - Relationen_Bände_Akteure *Relationen_Bände_Akteure - Relationen_Inhalte_Akteure *Relationen_Inhalte_Akteure - Relationen_Bände_Reihen *Relationen_Bände_Reihen - BIBLIO *map[int]BIBLIOEintrag + Orte Orte + Akteure Akteure + Reihen Reihentitel + Bände Bände + Inhalte Inhalte + Relationen_Bände_Akteure Relationen_Bände_Akteure + Relationen_Inhalte_Akteure Relationen_Inhalte_Akteure + Relationen_Bände_Reihen Relationen_Bände_Reihen + BIBLIO map[int]BIBLIOEintrag } -func ReadAccessDB(path string) (*AccessDB, error) { +func ReadAccessDB(path string, logger *slog.Logger) (*AccessDB, error) { var Akteure Akteure var Reihentitel Reihentitel var Bände Bände @@ -32,57 +34,89 @@ func ReadAccessDB(path string) (*AccessDB, error) { var Relationen_Inhalte_Akteure Relationen_Inhalte_Akteure var BIBLIO BIBLIOEinträge - if err := unmarshalFile(path+"Akteure.xml", &Akteure); err != nil { - return nil, err + var DB AccessDB + wg := sync.WaitGroup{} + wg.Add(9) + + go func() { + if err := unmarshalFile(path+"GM-BIBLIO.xml", &BIBLIO); err != nil { + logger.Error("Error while unmarshalling GM-BIBLIO.xml: ", "error", err, "path", path+"GM-BIBLIO.xml") + } + DB.BIBLIO = datatypes.MakeMap(BIBLIO.Einträge, func(e BIBLIOEintrag) int { return e.Nummer }) + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"Akteure.xml", &Akteure); err != nil { + logger.Error("Error while unmarshalling Akteure.xml: ", "error", err, "path", path+"Akteure.xml") + } + DB.Akteure = Akteure + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"Orte.xml", &Orte); err != nil { + logger.Error("Error while unmarshalling Orte.xml: ", "error", err, "path", path+"Orte.xml") + } + DB.Orte = Orte + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"Reihen.xml", &Reihentitel); err != nil { + logger.Error("Error while unmarshalling Reihen.xml: ", "error", err, "path", path+"Reihen.xml") + } + DB.Reihen = Reihentitel + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"Baende.xml", &Bände); err != nil { + logger.Error("Error while unmarshalling Baende.xml: ", "error", err, "path", path+"Baende.xml") + } + DB.Bände = Bände + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"Inhalte.xml", &Inhalte); err != nil { + logger.Error("Error while unmarshalling Inhalte.xml: ", "error", err, "path", path+"Inhalte.xml") + } + DB.Inhalte = Inhalte + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"_RELATION_BaendeAkteure.xml", &Relationen_Bände_Akteure); err != nil { + logger.Error("Error while unmarshalling RELATION_BaendeAkteure.xml: ", "error", err, "path", path+"_RELATION_BaendeAkteure.xml") + } + DB.Relationen_Bände_Akteure = Relationen_Bände_Akteure + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"_RELATION_BaendeReihen.xml", &Relationen_Bände_Reihen); err != nil { + logger.Error("Error while unmarshalling RELATION_BaendeReihen.xml: ", "error", err, "path", path+"_RELATION_BaendeReihen.xml") + } + DB.Relationen_Bände_Reihen = Relationen_Bände_Reihen + wg.Done() + }() + + go func() { + if err := unmarshalFile(path+"_RELATION_InhalteAkteure.xml", &Relationen_Inhalte_Akteure); err != nil { + logger.Error("Error while unmarshalling RELATION_InhalteAkteure.xml: ", "error", err, "path", path+"_RELATION_InhalteAkteure.xml") + } + DB.Relationen_Inhalte_Akteure = Relationen_Inhalte_Akteure + wg.Done() + }() + + wg.Wait() + + if len(DB.BIBLIO) == 0 || len(DB.Akteure.Akteure) == 0 || len(DB.Orte.Orte) == 0 || len(DB.Reihen.Reihen) == 0 || len(DB.Bände.Bände) == 0 || len(DB.Inhalte.Inhalte) == 0 || len(DB.Relationen_Bände_Akteure.Relationen) == 0 || len(DB.Relationen_Bände_Reihen.Relationen) == 0 || len(DB.Relationen_Inhalte_Akteure.Relationen) == 0 { + return nil, fmt.Errorf("Source files could not be read") } - if err := unmarshalFile(path+"Orte.xml", &Orte); err != nil { - return nil, err - } - - if err := unmarshalFile(path+"Reihen.xml", &Reihentitel); err != nil { - return nil, err - } - - if err := unmarshalFile(path+"Baende.xml", &Bände); err != nil { - return nil, err - } - - if err := unmarshalFile(path+"Inhalte.xml", &Inhalte); err != nil { - return nil, err - } - - if err := unmarshalFile(path+"_RELATION_BaendeAkteure.xml", &Relationen_Bände_Akteure); err != nil { - return nil, err - } - - if err := unmarshalFile(path+"_RELATION_BaendeReihen.xml", &Relationen_Bände_Reihen); err != nil { - return nil, err - } - - if err := unmarshalFile(path+"_RELATION_InhalteAkteure.xml", &Relationen_Inhalte_Akteure); err != nil { - return nil, err - } - - if err := unmarshalFile(path+"GM-BIBLIO.xml", &BIBLIO); err != nil { - return nil, err - } - - var BIBLIOM = datatypes.MakeMap(BIBLIO.Einträge, func(e BIBLIOEintrag) int { return e.Nummer }) - - lib := AccessDB{ - Orte: &Orte, - Akteure: &Akteure, - Reihen: &Reihentitel, - Bände: &Bände, - Inhalte: &Inhalte, - Relationen_Bände_Akteure: &Relationen_Bände_Akteure, - Relationen_Bände_Reihen: &Relationen_Bände_Reihen, - Relationen_Inhalte_Akteure: &Relationen_Inhalte_Akteure, - BIBLIO: &BIBLIOM, - } - - return &lib, nil + return &DB, nil } func unmarshalFile[T any](filename string, data *T) error { diff --git a/xmlmodels/relationen.go b/xmlmodels/relationen.go index 77daeb3..200b6ce 100644 --- a/xmlmodels/relationen.go +++ b/xmlmodels/relationen.go @@ -16,12 +16,12 @@ type Relation_Band_Reihe struct { type Relationen_Inhalte_Akteure struct { XMLName xml.Name `xml:"dataroot"` - Relationen []Relation_Inhalt_akteur `xml:"_x002A_RELATION_InhalteAkteure"` + Relationen []Relation_Inhalt_Akteur `xml:"_x002A_RELATION_InhalteAkteure"` } -type Relation_Inhalt_akteur struct { +type Relation_Inhalt_Akteur struct { ID string `xml:"ID"` - Band string `xml:"INHALT"` + Inhalt string `xml:"INHALT"` Relation string `xml:"BEZIEHUNG"` Akteur string `xml:"AKTEUR"` }