Theodor-Springmann-Stiftung/musenalm
1
0
Fork 0
mirror of https://github.com/Theodor-Springmann-Stiftung/musenalm.git synced 2025-10-29 09:15:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added DB models

Browse Source
This commit is contained in:
Simon Martens
2025-02-10 16:58:55 +01:00
parent bd59fdc2c2
commit a39ac0d68e
26 changed files with 1301 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
migrations/1738936553_places.go
View File

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

4
migrations/1738936584_series.go
View File

@@ -31,7 +31,7 @@ func seriesTable() *core.Collection {
func seriesFields() core.FieldsList {
fields := core.NewFieldsList(
&core.TextField{Name: dbmodels.SERIES_NAME_FIELD, Required: true, Presentable: true},
&core.TextField{Name: dbmodels.SERIES_TITLE_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},
@@ -46,5 +46,5 @@ func seriesFields() core.FieldsList {
func seriesIndexes(collection *core.Collection) {
addMusenalmIDIndex(collection)
addIndex(collection, "name", false)
addIndex(collection, dbmodels.SERIES_TITLE_FIELD, false)
}

3
migrations/1738936647_entries.go
View File

@@ -101,9 +101,6 @@ func entriesFields(app core.App) *core.FieldsList {
MaxSelect: 5000,
},
// Exemplare:
&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},

1
migrations/1738936648_items.go
View File

@@ -60,6 +60,7 @@ func itemsFields(app core.App) core.FieldsList {
)
setNotesAndAnnotationsField(&fields)
setEditorStateField(&fields)
return fields
}

87
migrations/1739007272_insert_data.go
View File

@@ -1,8 +1,6 @@
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"
@@ -19,86 +17,91 @@ func init() {
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)
if records, err := seed.RecordsFromAkteure(app, adb.Akteure); err == nil {
for _, record := range records {
if err = app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
} else {
panic(err)
}
wg.Done()
}()
} else {
panic(err)
}
go func() {
if records, err := seed.RecordsFromOrte(app, adb.Orte); err == nil {
if err = seed.BatchSave(app, records); err != nil {
panic(err)
if records, err := seed.RecordsFromOrte(app, adb.Orte); err == nil {
for _, record := range records {
if err = app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
} else {
panic(err)
}
wg.Done()
}()
} else {
panic(err)
}
go func() {
if records, err := seed.RecordsFromReihentitel(app, adb.Reihen); err == nil {
if err = seed.BatchSave(app, records); err != nil {
panic(err)
if records, err := seed.RecordsFromReihentitel(app, adb.Reihen); err == nil {
for _, record := range records {
if err = app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
} else {
panic(err)
}
wg.Done()
}()
wg.Wait()
} else {
panic(err)
}
if records, err := seed.RecordsFromBände(app, *adb); err == nil {
if err = seed.BatchSave(app, records); err != nil {
panic(err)
for _, record := range records {
if err = app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
}
} 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)
for _, record := range records {
if err = app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
}
} else {
panic(err)
}
if records, err := seed.RecordsFromInhalte(app, adb.Inhalte); err == nil {
if err = seed.BatchSave(app, records); err != nil {
panic(err)
for _, record := range records {
if err = app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
}
} 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)
for _, record := range records {
if err := app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
}
} 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)
for _, record := range records {
if err := app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
}
} 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)
for _, record := range records {
if err := app.Save(record); err != nil {
app.Logger().Error("Error saving record", "error", err, "record", record)
}
}
} else {
panic(err)

26
migrations/seed/agents.go
View File

@@ -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)

52
migrations/seed/contents.go
View File

@@ -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 {

96
migrations/seed/entries.go
View File

@@ -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)
}

56
migrations/seed/items.go
View File

@@ -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])
}
}
}
}

18
migrations/seed/places.go
View File

@@ -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)

42
migrations/seed/r_contents_agents.go
View File

@@ -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])

29
migrations/seed/r_entries_agents.go
View File

@@ -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)
}

38
migrations/seed/r_entries_series.go
View File

@@ -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)
}

24
migrations/seed/series.go
View File

@@ -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)