From a39ac0d68eb272ef9b9a9e097b43d471acce5527 Mon Sep 17 00:00:00 2001 From: Simon Martens Date: Mon, 10 Feb 2025 16:58:55 +0100 Subject: [PATCH] Added DB models --- app/pb.go | 2 +- dbmodels/agent.go | 111 +++++++++++++ dbmodels/common.go | 5 - dbmodels/content.go | 203 +++++++++++++++++++++++ dbmodels/dbdata.go | 7 +- dbmodels/entry.go | 233 +++++++++++++++++++++++++++ dbmodels/item.go | 123 ++++++++++++-- dbmodels/place.go | 75 +++++++++ dbmodels/r_contents_agents.go | 75 +++++++++ dbmodels/r_entries_agents.go | 75 +++++++++ dbmodels/r_entries_series.go | 83 ++++++++++ dbmodels/series.go | 83 ++++++++++ migrations/1738936553_places.go | 1 + migrations/1738936584_series.go | 4 +- migrations/1738936647_entries.go | 3 - migrations/1738936648_items.go | 1 + migrations/1739007272_insert_data.go | 87 +++++----- migrations/seed/agents.go | 26 +-- migrations/seed/contents.go | 52 +++--- migrations/seed/entries.go | 96 +++++------ migrations/seed/items.go | 56 ++++--- migrations/seed/places.go | 18 +-- migrations/seed/r_contents_agents.go | 42 ++--- migrations/seed/r_entries_agents.go | 29 ++-- migrations/seed/r_entries_series.go | 38 ++--- migrations/seed/series.go | 24 +-- 26 files changed, 1301 insertions(+), 251 deletions(-) create mode 100644 dbmodels/agent.go create mode 100644 dbmodels/content.go create mode 100644 dbmodels/entry.go create mode 100644 dbmodels/place.go create mode 100644 dbmodels/r_contents_agents.go create mode 100644 dbmodels/r_entries_agents.go create mode 100644 dbmodels/r_entries_series.go create mode 100644 dbmodels/series.go diff --git a/app/pb.go b/app/pb.go index a5b9723..4f90c6e 100644 --- a/app/pb.go +++ b/app/pb.go @@ -29,7 +29,7 @@ func init() { PRAGMA busy_timeout = 10000; PRAGMA journal_mode = WAL; PRAGMA journal_size_limit = 200000000; - PRAGMA synchronous = NORMAL; + PRAGMA synchronous = FULL; PRAGMA foreign_keys = ON; PRAGMA temp_store = MEMORY; PRAGMA cache_size = -32768; diff --git a/dbmodels/agent.go b/dbmodels/agent.go new file mode 100644 index 0000000..3945d89 --- /dev/null +++ b/dbmodels/agent.go @@ -0,0 +1,111 @@ +package dbmodels + +import "github.com/pocketbase/pocketbase/core" + +var _ core.RecordProxy = (*Agent)(nil) + +type Agent struct { + core.BaseRecordProxy +} + +func NewAgent(record *core.Record) *Agent { + i := &Agent{} + i.SetProxyRecord(record) + return i +} + +func (a *Agent) TableName() string { + return AGENTS_TABLE +} + +func (a *Agent) Name() string { + return a.GetString(AGENTS_NAME_FIELD) +} + +func (a *Agent) SetName(name string) { + a.Set(AGENTS_NAME_FIELD, name) +} + +func (a *Agent) Fictional() bool { + return a.GetBool(AGENTS_FICTIONAL_FIELD) +} + +func (a *Agent) SetFictional(fictional bool) { + a.Set(AGENTS_FICTIONAL_FIELD, fictional) +} + +func (a *Agent) CorporateBody() bool { + return a.GetBool(AGENTS_CORP_FIELD) +} + +func (a *Agent) SetCorporateBody(corporateBody bool) { + a.Set(AGENTS_CORP_FIELD, corporateBody) +} + +func (a *Agent) URI() string { + return a.GetString(URI_FIELD) +} + +func (a *Agent) SetURI(uri string) { + a.Set(URI_FIELD, uri) +} + +func (a *Agent) BiographicalData() string { + return a.GetString(AGENTS_BIOGRAPHICAL_DATA_FIELD) +} + +func (a *Agent) SetBiographicalData(biographicalData string) { + a.Set(AGENTS_BIOGRAPHICAL_DATA_FIELD, biographicalData) +} + +func (a *Agent) Profession() string { + return a.GetString(AGENTS_PROFESSION_FIELD) +} + +func (a *Agent) SetProfession(profession string) { + a.Set(AGENTS_PROFESSION_FIELD, profession) +} + +func (a *Agent) Pseudonyms() string { + return a.GetString(AGENTS_PSEUDONYMS_FIELD) +} + +func (a *Agent) SetPseudonyms(pseudonyms string) { + a.Set(AGENTS_PSEUDONYMS_FIELD, pseudonyms) +} + +func (a *Agent) References() string { + return a.GetString(REFERENCES_FIELD) +} + +func (a *Agent) SetReferences(references string) { + a.Set(REFERENCES_FIELD, references) +} + +func (a *Agent) Annotation() string { + return a.GetString(ANNOTATION_FIELD) +} + +func (a *Agent) SetAnnotation(annotation string) { + a.Set(ANNOTATION_FIELD, annotation) +} + +func (a *Agent) MusenalmID() string { + return a.GetString(MUSENALMID_FIELD) +} + +func (a *Agent) SetMusenalmID(id string) { + a.Set(MUSENALMID_FIELD, id) +} + +func (a *Agent) EditState() string { + return a.GetString(EDITSTATE_FIELD) +} + +func (a *Agent) SetEditState(editState string) { + a.Set(EDITSTATE_FIELD, editState) +} + +func (a *Agent) Comment() string { + return a.GetString(COMMENT_FIELD) +} diff --git a/dbmodels/common.go b/dbmodels/common.go index 544060b..a724166 100644 --- a/dbmodels/common.go +++ b/dbmodels/common.go @@ -1,10 +1,5 @@ package dbmodels -type AnnotatioNotes struct { - Annotation string `json:",omitempty" db:"annotation"` - Notes string `json:",omitempty" db:"edit_comment"` -} - type FieldMetaData struct { MetaData MetaData `json:",omitempty" db:"edit_fielddata"` } diff --git a/dbmodels/content.go b/dbmodels/content.go new file mode 100644 index 0000000..a0e17cc --- /dev/null +++ b/dbmodels/content.go @@ -0,0 +1,203 @@ +package dbmodels + +import "github.com/pocketbase/pocketbase/core" + +var _ core.RecordProxy = (*Content)(nil) + +type Content struct { + core.BaseRecordProxy +} + +func NewContent(record *core.Record) *Content { + i := &Content{} + i.SetProxyRecord(record) + return i +} + +func (c *Content) TableName() string { + return CONTENTS_TABLE +} + +func (c *Content) PreferredTitle() string { + return c.GetString(PREFERRED_TITLE_FIELD) +} + +func (c *Content) SetPreferredTitle(preferredTitle string) { + c.Set(PREFERRED_TITLE_FIELD, preferredTitle) +} + +func (c *Content) VariantTitle() string { + return c.GetString(VARIANT_TITLE_FIELD) +} + +func (c *Content) SetVariantTitle(variantTitle string) { + c.Set(VARIANT_TITLE_FIELD, variantTitle) +} + +func (c *Content) ParallelTitle() string { + return c.GetString(PARALLEL_TITLE_FIELD) +} + +func (c *Content) SetParallelTitle(parallelTitle string) { + c.Set(PARALLEL_TITLE_FIELD, parallelTitle) +} + +func (c *Content) TitleStmt() string { + return c.GetString(TITLE_STMT_FIELD) +} + +func (c *Content) SetTitleStmt(titleStmt string) { + c.Set(TITLE_STMT_FIELD, titleStmt) +} + +func (c *Content) SubtitleStmt() string { + return c.GetString(SUBTITLE_STMT_FIELD) +} + +func (c *Content) SetSubtitleStmt(subtitleStmt string) { + c.Set(SUBTITLE_STMT_FIELD, subtitleStmt) +} + +func (c *Content) IncipitStmt() string { + return c.GetString(INCIPIT_STMT_FIELD) +} + +func (c *Content) SetIncipitStmt(incipitStmt string) { + c.Set(INCIPIT_STMT_FIELD, incipitStmt) +} + +func (c *Content) ResponsibilityStmt() string { + return c.GetString(RESPONSIBILITY_STMT_FIELD) +} + +func (c *Content) SetResponsibilityStmt(responsibilityStmt string) { + c.Set(RESPONSIBILITY_STMT_FIELD, responsibilityStmt) +} + +func (c *Content) PublicationStmt() string { + return c.GetString(PUBLICATION_STMT_FIELD) +} + +func (c *Content) SetPublicationStmt(publicationStmt string) { + c.Set(PUBLICATION_STMT_FIELD, publicationStmt) +} + +func (c *Content) PlaceStmt() string { + return c.GetString(PLACE_STMT_FIELD) +} + +func (c *Content) SetPlaceStmt(placeStmt string) { + c.Set(PLACE_STMT_FIELD, placeStmt) +} + +func (c *Content) Year() int { + return c.GetInt(YEAR_FIELD) +} + +func (c *Content) SetYear(year int) { + c.Set(YEAR_FIELD, year) +} + +func (c *Content) Language() []string { + return c.GetStringSlice(LANGUAGE_FIELD) +} + +func (c *Content) SetLanguage(language []string) { + c.Set(LANGUAGE_FIELD, language) +} + +func (c *Content) ContentType() []string { + return c.GetStringSlice(CONTENT_TYPE_FIELD) +} + +func (c *Content) SetContentType(contentType []string) { + c.Set(CONTENT_TYPE_FIELD, contentType) +} + +func (c *Content) Extent() string { + return c.GetString(EXTENT_FIELD) +} + +func (c *Content) SetExtent(extent string) { + c.Set(EXTENT_FIELD, extent) +} + +func (c *Content) Dimensions() string { + return c.GetString(DIMENSIONS_FIELD) +} + +func (c *Content) SetDimensions(dimensions string) { + c.Set(DIMENSIONS_FIELD, dimensions) +} + +func (c *Content) MusenalmType() []string { + return c.GetStringSlice(MUSENALM_INHALTE_TYPE_FIELD) +} + +func (c *Content) SetMusenalmType(musenalmType []string) { + c.Set(MUSENALM_INHALTE_TYPE_FIELD, musenalmType) +} + +func (c *Content) MusenalmPagination() string { + return c.GetString(MUSENALM_PAGINATION_FIELD) +} + +func (c *Content) SetMusenalmPagination(musenalmPagination string) { + c.Set(MUSENALM_PAGINATION_FIELD, musenalmPagination) +} + +func (c *Content) Scans() []string { + return c.GetStringSlice(SCAN_FIELD) +} + +func (c *Content) SetScans(scans []string) { + c.Set(SCAN_FIELD, scans) +} + +func (c *Content) Numbering() float64 { + return c.GetFloat(NUMBERING_FIELD) +} + +func (c *Content) SetNumbering(numbering float64) { + c.Set(NUMBERING_FIELD, numbering) +} + +func (c *Content) Entry() string { + return c.GetString(ENTRIES_TABLE) +} + +func (c *Content) SetEntry(entry string) { + c.Set(ENTRIES_TABLE, entry) +} + +func (c *Content) MusenalmID() string { + return c.GetString(MUSENALMID_FIELD) +} + +func (c *Content) SetMusenalmID(musenalmID string) { + c.Set(MUSENALMID_FIELD, musenalmID) +} + +func (c *Content) EditState() string { + return c.GetString(EDITSTATE_FIELD) +} + +func (c *Content) SetEditState(editState string) { + c.Set(EDITSTATE_FIELD, editState) +} + +func (c *Content) Annotation() string { + return c.GetString(ANNOTATION_FIELD) +} + +func (c *Content) SetAnnotation(annotation string) { + c.Set(ANNOTATION_FIELD, annotation) +} + +func (c *Content) Comment() string { + return c.GetString(COMMENT_FIELD) +} + +func (c *Content) SetComment(comment string) { + c.Set(COMMENT_FIELD, comment) +} diff --git a/dbmodels/dbdata.go b/dbmodels/dbdata.go index 8df50ab..9ff3289 100644 --- a/dbmodels/dbdata.go +++ b/dbmodels/dbdata.go @@ -434,10 +434,11 @@ const ( AGENTS_PROFESSION_FIELD = "profession" AGENTS_PSEUDONYMS_FIELD = "pseudonyms" - PLACES_NAME_FIELD = "name" - PLACES_FICTIONAL_FIELD = "fictional" + PLACES_NAME_FIELD = "name" + PLACES_FICTIONAL_FIELD = "fictional" + PLACES_PSEUDONYMS_FIELD = "pseudonyms" - SERIES_NAME_FIELD = "name" + SERIES_TITLE_FIELD = "title" SERIES_PSEUDONYMS_FIELD = "pseudonyms" SERIES_FREQUENCY_FIELD = "frequency" diff --git a/dbmodels/entry.go b/dbmodels/entry.go new file mode 100644 index 0000000..d0a799f --- /dev/null +++ b/dbmodels/entry.go @@ -0,0 +1,233 @@ +package dbmodels + +import ( + "log/slog" + + "github.com/pocketbase/pocketbase/core" +) + +var _ core.RecordProxy = (*Entry)(nil) + +type Entry struct { + core.BaseRecordProxy +} + +func NewEntry(record *core.Record) *Entry { + i := &Entry{} + i.SetProxyRecord(record) + return i +} + +func (e *Entry) TableName() string { + return ENTRIES_TABLE +} + +func (e *Entry) PreferredTitle() string { + return e.GetString(PREFERRED_TITLE_FIELD) +} + +func (e *Entry) SetPreferredTitle(preferredTitle string) { + e.Set(PREFERRED_TITLE_FIELD, preferredTitle) +} + +func (e *Entry) VariantTitle() string { + return e.GetString(VARIANT_TITLE_FIELD) +} + +func (e *Entry) SetVariantTitle(variantTitle string) { + e.Set(VARIANT_TITLE_FIELD, variantTitle) +} + +func (e *Entry) ParallelTitle() string { + return e.GetString(PARALLEL_TITLE_FIELD) +} + +func (e *Entry) SetParallelTitle(parallelTitle string) { + e.Set(PARALLEL_TITLE_FIELD, parallelTitle) +} + +func (e *Entry) TitleStmt() string { + return e.GetString(TITLE_STMT_FIELD) +} + +func (e *Entry) SetTitleStmt(titleStmt string) { + e.Set(TITLE_STMT_FIELD, titleStmt) +} + +func (e *Entry) SubtitleStmt() string { + return e.GetString(SUBTITLE_STMT_FIELD) +} + +func (e *Entry) SetSubtitleStmt(subtitleStmt string) { + e.Set(SUBTITLE_STMT_FIELD, subtitleStmt) +} + +func (e *Entry) IncipitStmt() string { + return e.GetString(INCIPIT_STMT_FIELD) +} + +func (e *Entry) SetIncipitStmt(incipitStmt string) { + e.Set(INCIPIT_STMT_FIELD, incipitStmt) +} + +func (e *Entry) ResponsibilityStmt() string { + return e.GetString(RESPONSIBILITY_STMT_FIELD) +} + +func (e *Entry) SetResponsibilityStmt(responsibilityStmt string) { + e.Set(RESPONSIBILITY_STMT_FIELD, responsibilityStmt) +} + +func (e *Entry) PublicationStmt() string { + return e.GetString(PUBLICATION_STMT_FIELD) +} + +func (e *Entry) SetPublicationStmt(publicationStmt string) { + e.Set(PUBLICATION_STMT_FIELD, publicationStmt) +} + +func (e *Entry) PlaceStmt() string { + return e.GetString(PLACE_STMT_FIELD) +} + +func (e *Entry) SetPlaceStmt(placeStmt string) { + e.Set(PLACE_STMT_FIELD, placeStmt) +} + +func (e *Entry) Year() int { + return e.GetInt(YEAR_FIELD) +} + +func (e *Entry) SetYear(year int) { + e.Set(YEAR_FIELD, year) +} + +func (e *Entry) Language() []string { + return e.GetStringSlice(LANGUAGE_FIELD) +} + +func (e *Entry) SetLanguage(language []string) { + e.Set(LANGUAGE_FIELD, language) +} + +func (e *Entry) ContentType() []string { + return e.GetStringSlice(CONTENT_TYPE_FIELD) +} + +func (e *Entry) SetContentType(contentType []string) { + e.Set(CONTENT_TYPE_FIELD, contentType) +} + +func (e *Entry) Extent() string { + return e.GetString(EXTENT_FIELD) +} + +func (e *Entry) SetExtent(extent string) { + e.Set(EXTENT_FIELD, extent) +} + +func (e *Entry) Dimensions() string { + return e.GetString(DIMENSIONS_FIELD) +} + +func (e *Entry) SetDimensions(dimensions string) { + e.Set(DIMENSIONS_FIELD, dimensions) +} + +func (e *Entry) Edition() string { + return e.GetString(EDITION_FIELD) +} + +func (e *Entry) SetEdition(edition string) { + e.Set(EDITION_FIELD, edition) +} + +func (e *Entry) MediaType() []string { + return e.GetStringSlice(MEDIA_TYPE_FIELD) +} + +func (e *Entry) SetMediaType(mediaType []string) { + e.Set(MEDIA_TYPE_FIELD, mediaType) +} + +func (e *Entry) CarrierType() []string { + return e.GetStringSlice(CARRIER_TYPE_FIELD) +} + +func (e *Entry) SetCarrierType(carrierType []string) { + e.Set(CARRIER_TYPE_FIELD, carrierType) +} + +func (e *Entry) References() string { + return e.GetString(REFERENCES_FIELD) +} + +func (e *Entry) SetReferences(references string) { + e.Set(REFERENCES_FIELD, references) +} + +func (e *Entry) Places() []string { + return e.GetStringSlice(PLACES_TABLE) +} + +func (e *Entry) SetPlaces(places []string) { + e.Set(PLACES_TABLE, places) +} + +func (e *Entry) Meta() map[string]MetaData { + md := make(map[string]MetaData) + err := e.UnmarshalJSONField(META_FIELD, &md) + if err != nil { + slog.Error("Error unmarshalling meta field", "error", err) + } + return md +} + +func (e *Entry) SetMeta(meta map[string]MetaData) { + e.Set(META_FIELD, meta) +} + +func (e *Entry) Deprecated() Deprecated { + d := Deprecated{} + err := e.UnmarshalJSONField(MUSENALM_DEPRECATED_FIELD, &d) + if err != nil { + slog.Error("Error unmarshalling deprecated field", "error", err) + } + return d +} + +func (e *Entry) SetDeprecated(deprecated Deprecated) { + e.Set(MUSENALM_DEPRECATED_FIELD, deprecated) +} + +func (e *Entry) MusenalmID() string { + return e.GetString(MUSENALMID_FIELD) +} + +func (e *Entry) SetMusenalmID(musenalmID string) { + e.Set(MUSENALMID_FIELD, musenalmID) +} + +func (e *Entry) EditState() string { + return e.GetString(EDITSTATE_FIELD) +} + +func (e *Entry) SetEditState(editState string) { + e.Set(EDITSTATE_FIELD, editState) +} + +func (e *Entry) Annotation() string { + return e.GetString(ANNOTATION_FIELD) +} + +func (e *Entry) SetAnnotation(annotation string) { + e.Set(ANNOTATION_FIELD, annotation) +} + +func (e *Entry) Comment() string { + return e.GetString(COMMENT_FIELD) +} + +func (e *Entry) SetComment(comment string) { + e.Set(COMMENT_FIELD, comment) +} diff --git a/dbmodels/item.go b/dbmodels/item.go index 75ee9cc..d44c094 100644 --- a/dbmodels/item.go +++ b/dbmodels/item.go @@ -2,19 +2,122 @@ package dbmodels import "github.com/pocketbase/pocketbase/core" +var _ core.RecordProxy = (*Item)(nil) + type Item struct { - core.BaseModel - Entry string `json:",omitempty" db:"entries"` - Identifier string `json:",omitempty" db:"identifier"` - Location string `json:",omitempty" db:"location"` - Owner string `json:",omitempty" db:"owner"` - Media string `json:",omitempty" db:"media"` - Condition string `json:",omitempty" db:"condition"` - Scans string `json:",omitempty" db:"scans"` - Uri string `json:",omitempty" db:"uri"` - AnnotatioNotes + core.BaseRecordProxy + // Entry string `json:",omitempty" db:"entries"` + // Identifier string `json:",omitempty" db:"identifier"` + // Location string `json:",omitempty" db:"location"` + // Owner string `json:",omitempty" db:"owner"` + // Media string `json:",omitempty" db:"media"` + // Condition string `json:",omitempty" db:"condition"` + // Scans string `json:",omitempty" db:"scans"` + // Uri string `json:",omitempty" db:"uri"` +} + +func NewItem(record *core.Record) *Item { + i := &Item{} + i.SetProxyRecord(record) + return i } func (i *Item) TableName() string { return ITEMS_TABLE } + +func (a *Item) Entry() string { + return a.GetString(ENTRIES_TABLE) +} + +func (a *Item) SetEntry(entry string) { + a.Set(ENTRIES_TABLE, entry) +} + +func (a *Item) Identifier() string { + return a.GetString(ITEMS_IDENTIFIER_FIELD) +} + +func (a *Item) SetIdentifier(identifier string) { + a.Set(ITEMS_IDENTIFIER_FIELD, identifier) +} + +func (a *Item) Location() string { + return a.GetString(ITEMS_LOCATION_FIELD) +} + +func (a *Item) SetLocation(location string) { + a.Set(ITEMS_LOCATION_FIELD, location) +} + +func (a *Item) Owner() string { + return a.GetString(ITEMS_OWNER_FIELD) +} + +func (a *Item) SetOwner(owner string) { + a.Set(ITEMS_OWNER_FIELD, owner) +} + +func (a *Item) Media() []string { + return a.GetStringSlice(ITEMS_MEDIA_FIELD) +} + +func (a *Item) SetMedia(media []string) { + a.Set(ITEMS_MEDIA_FIELD, media) +} + +func (a *Item) Condition() string { + return a.GetString(ITEMS_CONDITION_FIELD) +} + +func (a *Item) SetCondition(condition string) { + a.Set(ITEMS_CONDITION_FIELD, condition) +} + +func (a *Item) Scans() string { + return a.GetString(SCAN_FIELD) +} + +func (a *Item) SetScans(scans string) { + a.Set(SCAN_FIELD, scans) +} + +func (a *Item) Uri() string { + return a.GetString(URI_FIELD) +} + +func (a *Item) SetUri(uri string) { + a.Set(URI_FIELD, uri) +} + +func (a *Item) Notes() string { + return a.GetString(COMMENT_FIELD) +} + +func (a *Item) SetNotes(notes string) { + a.Set(COMMENT_FIELD, notes) +} + +func (a *Item) Annotation() string { + return a.GetString(ANNOTATION_FIELD) +} + +func (a *Item) SetAnnotation(annotation string) { + a.Set(ANNOTATION_FIELD, annotation) +} + +func (a *Item) EditState() string { + return a.GetString(EDITSTATE_FIELD) +} + +func (a *Item) SetEditState(editState string) { + a.Set(EDITSTATE_FIELD, editState) +} + +func (a *Item) Comments() string { + return a.GetString(COMMENT_FIELD) +} + +func (a *Item) SetComments(comments string) { + a.Set(COMMENT_FIELD, comments) +} diff --git a/dbmodels/place.go b/dbmodels/place.go new file mode 100644 index 0000000..fa69e85 --- /dev/null +++ b/dbmodels/place.go @@ -0,0 +1,75 @@ +package dbmodels + +import "github.com/pocketbase/pocketbase/core" + +var _ core.RecordProxy = (*Place)(nil) + +type Place struct { + core.BaseRecordProxy +} + +func NewPlace(record *core.Record) *Place { + i := &Place{} + i.SetProxyRecord(record) + return i +} + +func (p *Place) TableName() string { + return PLACES_TABLE +} + +func (p *Place) Name() string { + return p.GetString(PLACES_NAME_FIELD) +} + +func (p *Place) SetName(name string) { + p.Set(PLACES_NAME_FIELD, name) +} + +func (p *Place) Fictional() bool { + return p.GetBool(PLACES_FICTIONAL_FIELD) +} + +func (p *Place) SetFictional(fictional bool) { + p.Set(PLACES_FICTIONAL_FIELD, fictional) +} + +func (p *Place) URI() string { + return p.GetString(URI_FIELD) +} + +func (p *Place) SetURI(uri string) { + p.Set(URI_FIELD, uri) +} + +func (p *Place) Annotation() string { + return p.GetString(ANNOTATION_FIELD) +} + +func (p *Place) SetAnnotation(annotation string) { + p.Set(ANNOTATION_FIELD, annotation) +} + +func (p *Place) MusenalmID() string { + return p.GetString(MUSENALMID_FIELD) +} + +func (p *Place) SetMusenalmID(id string) { + p.Set(MUSENALMID_FIELD, id) +} + +func (p *Place) EditState() string { + return p.GetString(EDITSTATE_FIELD) +} + +func (p *Place) SetEditState(state string) { + p.Set(EDITSTATE_FIELD, state) +} + +func (p *Place) Comment() string { + return p.GetString(COMMENT_FIELD) +} + +func (p *Place) SetComment(comment string) { + p.Set(COMMENT_FIELD, comment) +} diff --git a/dbmodels/r_contents_agents.go b/dbmodels/r_contents_agents.go new file mode 100644 index 0000000..e2a29a6 --- /dev/null +++ b/dbmodels/r_contents_agents.go @@ -0,0 +1,75 @@ +package dbmodels + +import "github.com/pocketbase/pocketbase/core" + +var _ core.RecordProxy = (*RContentsAgents)(nil) + +type RContentsAgents struct { + core.BaseRecordProxy +} + +func NewRContentsAgents(record *core.Record) *RContentsAgents { + i := &RContentsAgents{} + i.SetProxyRecord(record) + return i +} + +func (r *RContentsAgents) TableName() string { + return RelationTableName(CONTENTS_TABLE, AGENTS_TABLE) +} + +func (r *RContentsAgents) Content() string { + return r.GetString(CONTENTS_TABLE) +} + +func (r *RContentsAgents) SetContent(content string) { + r.Set(CONTENTS_TABLE, content) +} + +func (r *RContentsAgents) Agent() string { + return r.GetString(AGENTS_TABLE) +} + +func (r *RContentsAgents) SetAgent(agent string) { + r.Set(AGENTS_TABLE, agent) +} + +func (r *RContentsAgents) Type() string { + return r.GetString(RELATION_TYPE_FIELD) +} + +func (r *RContentsAgents) SetType(relationType string) { + r.Set(RELATION_TYPE_FIELD, relationType) +} + +func (r *RContentsAgents) Annotation() string { + return r.GetString(ANNOTATION_FIELD) +} + +func (r *RContentsAgents) SetAnnotation(annotation string) { + r.Set(ANNOTATION_FIELD, annotation) +} + +func (r *RContentsAgents) Comment() string { + return r.GetString(COMMENT_FIELD) +} + +func (r *RContentsAgents) SetComment(comment string) { + r.Set(COMMENT_FIELD, comment) +} + +func (r *RContentsAgents) Conjecture() bool { + return r.GetBool(RELATION_CONJECTURE_FIELD) +} + +func (r *RContentsAgents) SetConjecture(conjecture bool) { + r.Set(RELATION_CONJECTURE_FIELD, conjecture) +} + +func (r *RContentsAgents) Uncertain() bool { + return r.GetBool(RELATION_UNCERTAIN_FIELD) +} + +func (r *RContentsAgents) SetUncertain(uncertain bool) { + r.Set(RELATION_UNCERTAIN_FIELD, uncertain) +} diff --git a/dbmodels/r_entries_agents.go b/dbmodels/r_entries_agents.go new file mode 100644 index 0000000..48f9977 --- /dev/null +++ b/dbmodels/r_entries_agents.go @@ -0,0 +1,75 @@ +package dbmodels + +import "github.com/pocketbase/pocketbase/core" + +var _ core.RecordProxy = (*REntriesAgents)(nil) + +type REntriesAgents struct { + core.BaseRecordProxy +} + +func NewREntriesAgents(record *core.Record) *REntriesAgents { + i := &REntriesAgents{} + i.SetProxyRecord(record) + return i +} + +func (r *REntriesAgents) TableName() string { + return RelationTableName(ENTRIES_TABLE, AGENTS_TABLE) +} + +func (r *REntriesAgents) Entry() string { + return r.GetString(ENTRIES_TABLE) +} + +func (r *REntriesAgents) SetEntry(entry string) { + r.Set(ENTRIES_TABLE, entry) +} + +func (r *REntriesAgents) Agent() string { + return r.GetString(AGENTS_TABLE) +} + +func (r *REntriesAgents) SetAgent(agent string) { + r.Set(AGENTS_TABLE, agent) +} + +func (r *REntriesAgents) Type() string { + return r.GetString(RELATION_TYPE_FIELD) +} + +func (r *REntriesAgents) SetType(relationType string) { + r.Set(RELATION_TYPE_FIELD, relationType) +} + +func (r *REntriesAgents) Annotation() string { + return r.GetString(ANNOTATION_FIELD) +} + +func (r *REntriesAgents) SetAnnotation(annotation string) { + r.Set(ANNOTATION_FIELD, annotation) +} + +func (r *REntriesAgents) Comment() string { + return r.GetString(COMMENT_FIELD) +} + +func (r *REntriesAgents) SetComment(comment string) { + r.Set(COMMENT_FIELD, comment) +} + +func (r *REntriesAgents) Conjecture() bool { + return r.GetBool(RELATION_CONJECTURE_FIELD) +} + +func (r *REntriesAgents) SetConjecture(conjecture bool) { + r.Set(RELATION_CONJECTURE_FIELD, conjecture) +} + +func (r *REntriesAgents) Uncertain() bool { + return r.GetBool(RELATION_UNCERTAIN_FIELD) +} + +func (r *REntriesAgents) SetUncertain(uncertain bool) { + r.Set(RELATION_UNCERTAIN_FIELD, uncertain) +} diff --git a/dbmodels/r_entries_series.go b/dbmodels/r_entries_series.go new file mode 100644 index 0000000..7c1fd5b --- /dev/null +++ b/dbmodels/r_entries_series.go @@ -0,0 +1,83 @@ +package dbmodels + +import "github.com/pocketbase/pocketbase/core" + +var _ core.RecordProxy = (*REntriesSeries)(nil) + +type REntriesSeries struct { + core.BaseRecordProxy +} + +func NewREntriesSeries(record *core.Record) *REntriesSeries { + i := &REntriesSeries{} + i.SetProxyRecord(record) + return i +} + +func (r *REntriesSeries) TableName() string { + return RelationTableName(ENTRIES_TABLE, SERIES_TABLE) +} + +func (r *REntriesSeries) Entry() string { + return r.GetString(ENTRIES_TABLE) +} + +func (r *REntriesSeries) SetEntry(entry string) { + r.Set(ENTRIES_TABLE, entry) +} + +func (r *REntriesSeries) Series() string { + return r.GetString(SERIES_TABLE) +} + +func (r *REntriesSeries) SetSeries(series string) { + r.Set(SERIES_TABLE, series) +} + +func (r *REntriesSeries) Numbering() string { + return r.GetString(NUMBERING_FIELD) +} + +func (r *REntriesSeries) SetNumbering(numbering string) { + r.Set(NUMBERING_FIELD, numbering) +} + +func (r *REntriesSeries) Type() string { + return r.GetString(RELATION_TYPE_FIELD) +} + +func (r *REntriesSeries) SetType(relationType string) { + r.Set(RELATION_TYPE_FIELD, relationType) +} + +func (r *REntriesSeries) Annotation() string { + return r.GetString(ANNOTATION_FIELD) +} + +func (r *REntriesSeries) SetAnnotation(annotation string) { + r.Set(ANNOTATION_FIELD, annotation) +} + +func (r *REntriesSeries) Comment() string { + return r.GetString(COMMENT_FIELD) +} + +func (r *REntriesSeries) SetComment(comment string) { + r.Set(COMMENT_FIELD, comment) +} + +func (r *REntriesSeries) Conjecture() bool { + return r.GetBool(RELATION_CONJECTURE_FIELD) +} + +func (r *REntriesSeries) SetConjecture(conjecture bool) { + r.Set(RELATION_CONJECTURE_FIELD, conjecture) +} + +func (r *REntriesSeries) Uncertain() bool { + return r.GetBool(RELATION_UNCERTAIN_FIELD) +} + +func (r *REntriesSeries) SetUncertain(uncertain bool) { + r.Set(RELATION_UNCERTAIN_FIELD, uncertain) +} diff --git a/dbmodels/series.go b/dbmodels/series.go new file mode 100644 index 0000000..0420bdb --- /dev/null +++ b/dbmodels/series.go @@ -0,0 +1,83 @@ +package dbmodels + +import "github.com/pocketbase/pocketbase/core" + +var _ core.RecordProxy = (*Series)(nil) + +type Series struct { + core.BaseRecordProxy +} + +func NewSeries(record *core.Record) *Series { + i := &Series{} + i.SetProxyRecord(record) + return i +} + +func (s *Series) TableName() string { + return SERIES_TABLE +} + +func (s *Series) Title() string { + return s.GetString(SERIES_TITLE_FIELD) +} + +func (s *Series) SetTitle(title string) { + s.Set(SERIES_TITLE_FIELD, title) +} + +func (s *Series) Pseudonyms() string { + return s.GetString(SERIES_PSEUDONYMS_FIELD) +} + +func (s *Series) SetPseudonyms(pseudonyms string) { + s.Set(SERIES_PSEUDONYMS_FIELD, pseudonyms) +} + +func (s *Series) References() string { + return s.GetString(REFERENCES_FIELD) +} + +func (s *Series) SetReferences(references string) { + s.Set(REFERENCES_FIELD, references) +} + +func (s *Series) Annotation() string { + return s.GetString(ANNOTATION_FIELD) +} + +func (s *Series) SetAnnotation(annotation string) { + s.Set(ANNOTATION_FIELD, annotation) +} + +func (s *Series) MusenalmID() string { + return s.GetString(MUSENALMID_FIELD) +} + +func (s *Series) SetMusenalmID(id string) { + s.Set(MUSENALMID_FIELD, id) +} + +func (s *Series) EditState() string { + return s.GetString(EDITSTATE_FIELD) +} + +func (s *Series) SetEditState(editState string) { + s.Set(EDITSTATE_FIELD, editState) +} + +func (s *Series) Comment() string { + return s.GetString(COMMENT_FIELD) +} + +func (s *Series) SetComment(comment string) { + s.Set(COMMENT_FIELD, comment) +} + +func (s *Series) Frequency() string { + return s.GetString(SERIES_FREQUENCY_FIELD) +} + +func (s *Series) SetFrequency(frequency string) { + s.Set(SERIES_FREQUENCY_FIELD, frequency) +} diff --git a/migrations/1738936553_places.go b/migrations/1738936553_places.go index 18513dd..70518b3 100644 --- a/migrations/1738936553_places.go +++ b/migrations/1738936553_places.go @@ -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"}}, ) diff --git a/migrations/1738936584_series.go b/migrations/1738936584_series.go index f64a7bc..7460f0c 100644 --- a/migrations/1738936584_series.go +++ b/migrations/1738936584_series.go @@ -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) } diff --git a/migrations/1738936647_entries.go b/migrations/1738936647_entries.go index 548fc0c..7f5280d 100644 --- a/migrations/1738936647_entries.go +++ b/migrations/1738936647_entries.go @@ -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}, diff --git a/migrations/1738936648_items.go b/migrations/1738936648_items.go index a34aa68..e588bf4 100644 --- a/migrations/1738936648_items.go +++ b/migrations/1738936648_items.go @@ -60,6 +60,7 @@ func itemsFields(app core.App) core.FieldsList { ) setNotesAndAnnotationsField(&fields) + setEditorStateField(&fields) return fields } diff --git a/migrations/1739007272_insert_data.go b/migrations/1739007272_insert_data.go index 1129b8b..0b9a1c6 100644 --- a/migrations/1739007272_insert_data.go +++ b/migrations/1739007272_insert_data.go @@ -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) diff --git a/migrations/seed/agents.go b/migrations/seed/agents.go index d852ac0..ec9e12f 100644 --- a/migrations/seed/agents.go +++ b/migrations/seed/agents.go @@ -8,31 +8,31 @@ import ( "github.com/pocketbase/pocketbase/core" ) -func RecordsFromAkteure(app core.App, akteure xmlmodels.Akteure) ([]*core.Record, error) { +func RecordsFromAkteure(app core.App, akteure xmlmodels.Akteure) ([]*dbmodels.Agent, error) { collection, err := app.FindCollectionByNameOrId(dbmodels.AGENTS_TABLE) - records := make([]*core.Record, 0, len(akteure.Akteure)) + records := make([]*dbmodels.Agent, 0, len(akteure.Akteure)) if err != nil { fmt.Println(err) return records, err } for i := 0; i < len(akteure.Akteure); i++ { - record := core.NewRecord(collection) + record := dbmodels.NewAgent(core.NewRecord(collection)) akteur := akteure.Akteure[i] - record.Set(dbmodels.AGENTS_CORP_FIELD, akteur.Körperschaft) - record.Set(dbmodels.AGENTS_NAME_FIELD, NormalizeString(akteur.Name)) - record.Set(dbmodels.REFERENCES_FIELD, NormalizeString(akteur.Nachweis)) - record.Set(dbmodels.AGENTS_BIOGRAPHICAL_DATA_FIELD, NormalizeString(akteur.Lebensdaten)) - record.Set(dbmodels.AGENTS_PROFESSION_FIELD, NormalizeString(akteur.Beruf)) - record.Set(dbmodels.AGENTS_PSEUDONYMS_FIELD, NormalizeString(akteur.Pseudonyme)) - record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(akteur.Anmerkungen)) - record.Set(dbmodels.MUSENALMID_FIELD, akteur.ID) + record.SetCorporateBody(akteur.Körperschaft) + record.SetName(NormalizeString(akteur.Name)) + record.SetReferences(NormalizeString(akteur.Nachweis)) + record.SetBiographicalData(NormalizeString(akteur.Lebensdaten)) + record.SetProfession(NormalizeString(akteur.Beruf)) + record.SetPseudonyms(NormalizeString(akteur.Pseudonyme)) + record.SetAnnotation(NormalizeString(akteur.Anmerkungen)) + record.SetMusenalmID(akteur.ID) n := akteur.Name if n == "" { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[1]) } else { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) } records = append(records, record) diff --git a/migrations/seed/contents.go b/migrations/seed/contents.go index dcbdf0d..acf6743 100644 --- a/migrations/seed/contents.go +++ b/migrations/seed/contents.go @@ -2,6 +2,7 @@ package seed import ( "fmt" + "strconv" "strings" "github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels" @@ -9,43 +10,50 @@ import ( "github.com/pocketbase/pocketbase/core" ) -func RecordsFromInhalte(app core.App, inhalte xmlmodels.Inhalte) ([]*core.Record, error) { +const NO_TITLE = "[No Title]" + +func RecordsFromInhalte(app core.App, inhalte xmlmodels.Inhalte) ([]*dbmodels.Content, error) { collection, err := app.FindCollectionByNameOrId(dbmodels.CONTENTS_TABLE) - records := make([]*core.Record, 0, len(inhalte.Inhalte)) + records := make([]*dbmodels.Content, 0, len(inhalte.Inhalte)) if err != nil { fmt.Println(err) return records, err } for i := 0; i < len(inhalte.Inhalte); i++ { - record := core.NewRecord(collection) + record := dbmodels.NewContent(core.NewRecord(collection)) inhalt := inhalte.Inhalte[i] band, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, inhalt.Band) if err != nil { app.Logger().Error("Error finding band record for inhalt", "error", err, "inhalt", inhalt) continue } - record.Set(dbmodels.ENTRIES_TABLE, band.Id) - record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(inhalt.Anmerkungen)) - record.Set(dbmodels.MUSENALMID_FIELD, inhalt.ID) - record.Set(dbmodels.RESPONSIBILITY_STMT_FIELD, NormalizeString(inhalt.Urheberangabe)) - record.Set(dbmodels.MUSENALM_INHALTE_TYPE_FIELD, inhalt.Typ.Value) - record.Set(dbmodels.EXTENT_FIELD, NormalizeString(inhalt.Seite)) - record.Set(dbmodels.TITLE_STMT_FIELD, NormalizeString(inhalt.Titelangabe)) - record.Set(dbmodels.INCIPIT_STMT_FIELD, NormalizeString(inhalt.Incipit)) + record.SetEntry(band.Id) + record.SetAnnotation(NormalizeString(inhalt.Anmerkungen)) + record.SetMusenalmID(inhalt.ID) + record.SetResponsibilityStmt(NormalizeString(inhalt.Urheberangabe)) + record.SetMusenalmType(inhalt.Typ.Value) + record.SetExtent(NormalizeString(inhalt.Seite)) + record.SetTitleStmt(NormalizeString(inhalt.Titelangabe)) + record.SetIncipitStmt(NormalizeString(inhalt.Incipit)) counting, ok := dbmodels.MUSENALM_PAGINATION_VALUES[inhalt.Paginierung] if ok { - record.Set(dbmodels.MUSENALM_PAGINATION_FIELD, counting) + record.SetMusenalmPagination(counting) } - record.Set(dbmodels.NUMBERING_FIELD, NormalizeString(inhalt.Objektnummer)) + + no, err := strconv.ParseFloat(NormalizeString(inhalt.Objektnummer), 64) + if err != nil { + app.Logger().Error("Error parsing object number", "error", err, "object number", inhalt.Objektnummer) + } + record.SetNumbering(no) handlePreferredTitle(inhalt, record) - n := record.GetString(dbmodels.PREFERRED_TITLE_FIELD) - if n == "" || n == "No Title" { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1]) + n := record.PreferredTitle() + if n == "" || n == NO_TITLE { + record.SetEditState(dbmodels.EDITORSTATE_VALUES[1]) } else { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) } records = append(records, record) @@ -53,14 +61,14 @@ func RecordsFromInhalte(app core.App, inhalte xmlmodels.Inhalte) ([]*core.Record return records, nil } -func handlePreferredTitle(inhalt xmlmodels.Inhalt, record *core.Record) { +func handlePreferredTitle(inhalt xmlmodels.Inhalt, record *dbmodels.Content) { if inhalt.Titelangabe != "" { - record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(inhalt.Titelangabe)) + record.SetPreferredTitle(NormalizeString(inhalt.Titelangabe)) return } if inhalt.Incipit != "" { - record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(inhalt.Incipit)+"…") + record.SetPreferredTitle(NormalizeString(inhalt.Incipit) + "…") return } @@ -76,12 +84,12 @@ func handlePreferredTitle(inhalt xmlmodels.Inhalt, record *core.Record) { urhh = NormalizeString(urhh) str += " (" + urhh + ")" } - record.Set(dbmodels.PREFERRED_TITLE_FIELD, "["+str+"]") + record.SetPreferredTitle("[" + str + "]") return } } - record.Set(dbmodels.PREFERRED_TITLE_FIELD, "[Kein Titel]") + record.SetPreferredTitle(NO_TITLE) } func commatizeArray(array []string) string { diff --git a/migrations/seed/entries.go b/migrations/seed/entries.go index 84426b6..f4efa95 100644 --- a/migrations/seed/entries.go +++ b/migrations/seed/entries.go @@ -15,58 +15,61 @@ import ( func RecordsFromBände( app core.App, adb xmlmodels.AccessDB, -) ([]*core.Record, error) { +) ([]*dbmodels.Entry, error) { collection, err := app.FindCollectionByNameOrId(dbmodels.ENTRIES_TABLE) - records := make([]*core.Record, 0, len(adb.Bände.Bände)) + records := make([]*dbmodels.Entry, 0, len(adb.Bände.Bände)) if err != nil { fmt.Println(err) return records, err } - omap := datatypes.MakeMap(adb.Orte.Orte, func(o xmlmodels.Ort) string { return o.ID }) - relmap := datatypes.MakeMultiMap( - adb.Relationen_Bände_Reihen.Relationen, - func(r xmlmodels.Relation_Band_Reihe) string { return r.Band }, - ) - rmap := datatypes.MakeMap(adb.Reihen.Reihen, func(r xmlmodels.Reihe) string { return r.ID }) ocoll, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE) if err != nil { app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.PLACES_TABLE) return records, err } + // INFO: lets make some maps to speed this up + omap := datatypes.MakeMap(adb.Orte.Orte, func(o xmlmodels.Ort) string { return o.ID }) + relmap := datatypes.MakeMultiMap( + adb.Relationen_Bände_Reihen.Relationen, + func(r xmlmodels.Relation_Band_Reihe) string { return r.Band }, + ) + rmap := datatypes.MakeMap(adb.Reihen.Reihen, func(r xmlmodels.Reihe) string { return r.ID }) + for i := 0; i < len(adb.Bände.Bände); i++ { band := adb.Bände.Bände[i] - record := core.NewRecord(collection) + record := dbmodels.NewEntry(core.NewRecord(collection)) // TODO: Hier bevorzugter reihentitel + jahr, oder irgendein reihentitel, oder reihentitelALT if band.ReihentitelALT == "" { continue } - record.Set(dbmodels.TITLE_STMT_FIELD, NormalizeString(band.Titelangabe)) - record.Set(dbmodels.REFERENCES_FIELD, NormalizeString(band.Nachweis)) - record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(band.Anmerkungen)) - if band.Jahr != 0 { - record.Set(dbmodels.YEAR_FIELD, band.Jahr) - } - record.Set(dbmodels.RESPONSIBILITY_STMT_FIELD, NormalizeString(band.Verantwortlichkeitsangabe)) - record.Set(dbmodels.PUBLICATION_STMT_FIELD, NormalizeString(band.Ortsangabe)) - record.Set(dbmodels.EXTENT_FIELD, NormalizeString(band.Struktur)) - record.Set(dbmodels.CARRIER_TYPE_FIELD, "Band") - record.Set(dbmodels.CONTENT_TYPE_FIELD, []string{"unbewegtes Bild", "Text"}) - record.Set(dbmodels.MEDIA_TYPE_FIELD, "ohne Hilfsmittel") - record.Set(dbmodels.LANGUAGE_FIELD, "ger") - record.Set(dbmodels.MUSENALMID_FIELD, band.ID) + record.SetTitleStmt(NormalizeString(band.Titelangabe)) + record.SetReferences(NormalizeString(band.Nachweis)) + record.SetAnnotation(NormalizeString(band.Anmerkungen)) + record.SetResponsibilityStmt(NormalizeString(band.Verantwortlichkeitsangabe)) + record.SetPublicationStmt(NormalizeString(band.Ortsangabe)) + record.SetExtent(NormalizeString(band.Struktur)) + record.SetCarrierType([]string{"Band"}) + record.SetContentType([]string{"unbewegtes Bild", "Text"}) + record.SetMediaType([]string{"ohne Hilfsmittel"}) + record.SetLanguage([]string{"ger"}) + record.SetMusenalmID(band.ID) + + if band.Jahr != 0 { + record.SetYear(band.Jahr) + } if band.Erfasst { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) } else if band.Gesichtet { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[2]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[2]) } else if band.BiblioID != 0 { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[1]) } else { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[0]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[0]) } handlePreferredTitleEntry(record, band, rmap, relmap) @@ -80,15 +83,15 @@ func RecordsFromBände( } func handlePreferredTitleEntry( - record *core.Record, + record *dbmodels.Entry, band xmlmodels.Band, rmap map[string]xmlmodels.Reihe, rrelmap map[string][]xmlmodels.Relation_Band_Reihe, ) { rels := rrelmap[band.ID] if len(rels) == 0 { - record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(band.ReihentitelALT)) - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) + record.SetPreferredTitle(NormalizeString(band.ReihentitelALT)) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) return } @@ -102,7 +105,7 @@ func handlePreferredTitleEntry( bevti := slices.IndexFunc(rels, func(r xmlmodels.Relation_Band_Reihe) bool { return r.Relation == "1" }) if bevti != -1 { bevt := rmap[rels[bevti].Reihe] - record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(bevt.Titel)+" "+jahr) + record.SetPreferredTitle(NormalizeString(bevt.Titel) + " " + jahr) return } @@ -110,11 +113,11 @@ func handlePreferredTitleEntry( return strings.Compare(a.Relation, b.Relation) }) - record.Set(dbmodels.PREFERRED_TITLE_FIELD, NormalizeString(rmap[rels[0].Reihe].Titel)+jahr) + record.SetPreferredTitle(NormalizeString(rmap[rels[0].Reihe].Titel) + jahr) } func handleOrte( - record *core.Record, + record *dbmodels.Entry, band xmlmodels.Band, orte map[string]xmlmodels.Ort, app core.App, @@ -132,35 +135,32 @@ func handleOrte( ort, err := app.FindFirstRecordByData(dbmodels.PLACES_TABLE, dbmodels.PLACES_NAME_FIELD, n) if err == nil { - before := record.GetStringSlice(dbmodels.PLACES_TABLE) - record.Set(dbmodels.PLACES_TABLE, append(before, ort.Id)) + before := record.Places() + record.SetPlaces(append(before, ort.Id)) } else { - orec := core.NewRecord(ocollection) - orec.Set(dbmodels.PLACES_NAME_FIELD, n) - orec.Set(dbmodels.ANNOTATION_FIELD, o.Anmerkungen) - orec.Set(dbmodels.PLACES_FICTIONAL_FIELD, o.Fiktiv) - orec.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) + orec := dbmodels.NewPlace(core.NewRecord(ocollection)) + orec.SetName(n) + orec.SetAnnotation(o.Anmerkungen) + orec.SetFictional(o.Fiktiv) + orec.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) if err := app.Save(orec); err != nil { app.Logger().Error("Error saving record", "error", err, "record", orec) continue } else { - before := record.GetStringSlice(dbmodels.PLACES_TABLE) - record.Set(dbmodels.PLACES_TABLE, append(before, orec.Id)) + before := record.Places() + record.SetPlaces(append(before, orec.Id)) } } if e { // INFO: We do not need to get the record metadata here, as we know that the record is new - record.Set( - dbmodels.META_FIELD, - map[string]dbmodels.MetaData{dbmodels.PLACES_TABLE: {Conjecture: true}}, - ) + record.SetMeta(map[string]dbmodels.MetaData{dbmodels.PLACES_TABLE: {Conjecture: true}}) } } } } -func handleDeprecated(record *core.Record, band xmlmodels.Band) { +func handleDeprecated(record *dbmodels.Entry, band xmlmodels.Band) { depr := dbmodels.Deprecated{ Reihentitel: NormalizeString(band.ReihentitelALT), Norm: NormalizeString(band.Norm), @@ -170,5 +170,5 @@ func handleDeprecated(record *core.Record, band xmlmodels.Band) { Erfasst: band.Erfasst, } - record.Set(dbmodels.MUSENALM_DEPRECATED_FIELD, depr) + record.SetDeprecated(depr) } diff --git a/migrations/seed/items.go b/migrations/seed/items.go index 1f3f745..6d1d15c 100644 --- a/migrations/seed/items.go +++ b/migrations/seed/items.go @@ -16,9 +16,9 @@ func ItemsFromBändeAndBIBLIO( app core.App, entries xmlmodels.Bände, biblio map[int]xmlmodels.BIBLIOEintrag, -) ([]*core.Record, error) { +) ([]*dbmodels.Item, error) { collection, err := app.FindCollectionByNameOrId(dbmodels.ITEMS_TABLE) - records := make([]*core.Record, 0, len(entries.Bände)) + records := make([]*dbmodels.Item, 0, len(entries.Bände)) r := regexp.MustCompile("\\d{6}") if err != nil { fmt.Println(err) @@ -66,65 +66,63 @@ func ItemsFromBändeAndBIBLIO( } } - var exemlist []dbmodels.Item - if band.BiblioID != 0 { - exem := dbmodels.Item{Identifier: strconv.Itoa(band.BiblioID)} + exem := dbmodels.NewItem(core.NewRecord(collection)) + exem.SetIdentifier(strconv.Itoa(band.BiblioID)) if e, ok := biblio[band.BiblioID]; ok { - exem.Location = strings.TrimSpace(e.Standort) - exem.Condition = strings.TrimSpace(e.Zustand) + exem.SetLocation(strings.TrimSpace(e.Standort)) + exem.SetCondition(strings.TrimSpace(e.Zustand)) message := "" message = appendMessage(e.NotizÄusseres, message) message = appendMessage(e.NotizInhalt, message) message = appendMessage(e.Anmerkungen, message) - exem.Annotation = message + exem.SetAnnotation(message) } - exemlist = append(exemlist, exem) + records = append(records, exem) } for nr, m := range t { - exem := dbmodels.Item{Identifier: nr} + exem := dbmodels.NewItem(core.NewRecord(collection)) + exem.SetIdentifier(nr) no, err := strconv.Atoi(strings.TrimSpace(nr)) message := strings.TrimSpace(m) if err != nil { if e, ok := biblio[no]; ok { - exem.Location = strings.TrimSpace(e.Standort) - exem.Condition = strings.TrimSpace(e.Zustand) + exem.SetLocation(strings.TrimSpace(e.Standort)) + exem.SetCondition(strings.TrimSpace(e.Zustand)) message = appendMessage(e.NotizÄusseres, message) message = appendMessage(e.NotizInhalt, message) message = appendMessage(e.Anmerkungen, message) } } - exem.Annotation = message + exem.SetAnnotation(message) - if exem.Identifier != "" { - exemlist = append(exemlist, exem) + if exem.Identifier() != "" { + records = append(records, exem) } } - if len(exemlist) > 0 { - for _, exem := range exemlist { - record := core.NewRecord(collection) - record.Set(dbmodels.ENTRIES_TABLE, banddb.Id) - record.Set(dbmodels.ITEMS_IDENTIFIER_FIELD, exem.Identifier) - record.Set(dbmodels.ITEMS_LOCATION_FIELD, exem.Location) - record.Set(dbmodels.ITEMS_OWNER_FIELD, "Theodor Springmann Stiftung") - record.Set(dbmodels.ITEMS_CONDITION_FIELD, exem.Condition) + if len(records) > 0 { + for _, exem := range records { + exem.SetEntry(banddb.Id) + exem.SetOwner("Theodor Springmann Stiftung") if slices.Contains(band.Status.Value, "Original vorhanden") { - record.Set(dbmodels.ITEMS_MEDIA_FIELD, dbmodels.ITEM_TYPE_VALUES[0]) + exem.SetMedia([]string{dbmodels.ITEM_TYPE_VALUES[0]}) } if slices.Contains(band.Status.Value, "Reprint vorhanden") { - med := record.GetStringSlice(dbmodels.ITEMS_MEDIA_FIELD) - record.Set(dbmodels.ITEMS_MEDIA_FIELD, append(med, dbmodels.ITEM_TYPE_VALUES[1])) + med := exem.Media() + exem.SetMedia(append(med, dbmodels.ITEM_TYPE_VALUES[1])) } - record.Set(dbmodels.ANNOTATION_FIELD, exem.Annotation) - - records = append(records, record) + if exem.Location() == "" { + exem.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) + } else { + exem.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) + } } } } diff --git a/migrations/seed/places.go b/migrations/seed/places.go index 4e02f48..569fdeb 100644 --- a/migrations/seed/places.go +++ b/migrations/seed/places.go @@ -8,9 +8,9 @@ import ( "github.com/pocketbase/pocketbase/core" ) -func RecordsFromOrte(app core.App, orte xmlmodels.Orte) ([]*core.Record, error) { +func RecordsFromOrte(app core.App, orte xmlmodels.Orte) ([]*dbmodels.Place, error) { collection, err := app.FindCollectionByNameOrId(dbmodels.PLACES_TABLE) - records := make([]*core.Record, 0, len(orte.Orte)) + records := make([]*dbmodels.Place, 0, len(orte.Orte)) if err != nil { fmt.Println(err) return records, err @@ -18,17 +18,17 @@ func RecordsFromOrte(app core.App, orte xmlmodels.Orte) ([]*core.Record, error) for i := 0; i < len(orte.Orte); i++ { ort := orte.Orte[i] - record := core.NewRecord(collection) - record.Set(dbmodels.PLACES_NAME_FIELD, NormalizeString(ort.Name)) - record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(ort.Anmerkungen)) - record.Set(dbmodels.PLACES_FICTIONAL_FIELD, ort.Fiktiv) - record.Set(dbmodels.MUSENALMID_FIELD, ort.ID) + record := dbmodels.NewPlace(core.NewRecord(collection)) + record.SetName(NormalizeString(ort.Name)) + record.SetAnnotation(NormalizeString(ort.Anmerkungen)) + record.SetFictional(ort.Fiktiv) + record.SetMusenalmID(ort.ID) n := ort.Name if n == "" { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[1]) } else { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) } records = append(records, record) diff --git a/migrations/seed/r_contents_agents.go b/migrations/seed/r_contents_agents.go index 4bb94e7..421a920 100644 --- a/migrations/seed/r_contents_agents.go +++ b/migrations/seed/r_contents_agents.go @@ -9,8 +9,8 @@ import ( "github.com/pocketbase/pocketbase/core" ) -func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relationen_Inhalte_Akteure) ([]*core.Record, error) { - records := make([]*core.Record, 0, len(relations.Relationen)) +func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relationen_Inhalte_Akteure) ([]*dbmodels.RContentsAgents, error) { + records := make([]*dbmodels.RContentsAgents, 0, len(relations.Relationen)) collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE)) if err != nil { app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE)) @@ -18,27 +18,29 @@ func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relatio } for _, relation := range relations.Relationen { - content, err := app.FindFirstRecordByData(dbmodels.CONTENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Inhalt) + c, err := app.FindFirstRecordByData(dbmodels.CONTENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Inhalt) if err != nil { app.Logger().Error("Error finding Inhalt", "error", err, "relation", relation) continue } + content := dbmodels.NewContent(c) - agent, err := app.FindFirstRecordByData(dbmodels.AGENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Akteur) + a, err := app.FindFirstRecordByData(dbmodels.AGENTS_TABLE, dbmodels.MUSENALMID_FIELD, relation.Akteur) if err != nil { app.Logger().Error("Error finding Content", "error", err, "relation", relation) continue } + agent := dbmodels.NewAgent(a) - record := core.NewRecord(collection) - record.Set(dbmodels.CONTENTS_TABLE, content.Id) - record.Set(dbmodels.AGENTS_TABLE, agent.Id) + record := dbmodels.NewRContentsAgents(core.NewRecord(collection)) + record.SetContent(content.Id) + record.SetAgent(agent.Id) switch relation.Relation { case "1": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Schöpfer") - cat := content.GetStringSlice(dbmodels.MUSENALM_INHALTE_TYPE_FIELD) - ber := agent.GetString(dbmodels.AGENTS_PROFESSION_FIELD) + record.SetType("Schöpfer") + cat := content.MusenalmType() + ber := agent.Profession() probt := 0 probm := 0 probg := 0 @@ -81,32 +83,32 @@ func RecordsFromRelationInhalteAkteure(app core.App, relations xmlmodels.Relatio } if probt == 3 && probm <= 1 && probg <= 1 { - record.Set(dbmodels.RELATION_TYPE_FIELD, "Autor:in") + record.SetType("Autor:in") break } if probm == 3 && probt <= 1 && probg <= 1 { - record.Set(dbmodels.RELATION_TYPE_FIELD, "Komponist:in") + record.SetType("Komponist:in") break } if probg == 3 && probt <= 1 && probm <= 1 { - record.Set(dbmodels.RELATION_TYPE_FIELD, "Künstler:in") + record.SetType("Künstler:in") break } - record.Set(dbmodels.RELATION_TYPE_FIELD, "Schöpfer") + record.SetType("Schöpfer") case "2": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Autor:in") + record.SetType("Autor:in") case "3": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Zeichner:in") + record.SetType("Herausgeber:in") case "4": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Kupferstecher:in") + record.SetType("Verlag") } - rel := record.GetString(dbmodels.RELATION_TYPE_FIELD) - ent := record.GetString(dbmodels.CONTENTS_TABLE) - ser := record.GetString(dbmodels.AGENTS_TABLE) + rel := record.Type() + ent := record.Content() + ser := record.Agent() if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" { content.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) diff --git a/migrations/seed/r_entries_agents.go b/migrations/seed/r_entries_agents.go index 82434f1..c9be477 100644 --- a/migrations/seed/r_entries_agents.go +++ b/migrations/seed/r_entries_agents.go @@ -8,8 +8,8 @@ import ( "github.com/pocketbase/pocketbase/core" ) -func RecordsFromRelationBändeAkteure(app core.App, relations xmlmodels.Relationen_Bände_Akteure) ([]*core.Record, error) { - records := make([]*core.Record, 0, len(relations.Relationen)) +func RecordsFromRelationBändeAkteure(app core.App, relations xmlmodels.Relationen_Bände_Akteure) ([]*dbmodels.REntriesAgents, error) { + records := make([]*dbmodels.REntriesAgents, 0, len(relations.Relationen)) collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE)) if err != nil { app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.RelationTableName(dbmodels.CONTENTS_TABLE, dbmodels.AGENTS_TABLE)) @@ -29,28 +29,29 @@ func RecordsFromRelationBändeAkteure(app core.App, relations xmlmodels.Relation continue } - record := core.NewRecord(collection) - record.Set(dbmodels.ENTRIES_TABLE, entry.Id) - record.Set(dbmodels.AGENTS_TABLE, agent.Id) + record := dbmodels.NewREntriesAgents(core.NewRecord(collection)) + record.SetEntry(entry.Id) + record.SetAgent(agent.Id) switch relation.Relation { case "8": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Vertrieb") + record.SetType("Vertrieb") case "7": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Druck") + record.SetType("Druck") case "6": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Verlag") + record.SetType("Verlag") case "5": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Herausgeber:in") + record.SetType("Herausgeber:in") } - rel := record.GetString(dbmodels.RELATION_TYPE_FIELD) - ent := record.GetString(dbmodels.ENTRIES_TABLE) - ser := record.GetString(dbmodels.AGENTS_TABLE) + rel := record.Type() + ent := record.Entry() + ser := record.Agent() if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" { - entry.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) - _ = app.Save(entry) + e := dbmodels.NewEntry(entry) + e.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) + _ = app.Save(e) } records = append(records, record) } diff --git a/migrations/seed/r_entries_series.go b/migrations/seed/r_entries_series.go index 189c8f6..78f234b 100644 --- a/migrations/seed/r_entries_series.go +++ b/migrations/seed/r_entries_series.go @@ -8,8 +8,8 @@ import ( "github.com/pocketbase/pocketbase/core" ) -func RecordsFromRelationBändeReihen(app core.App, relations xmlmodels.Relationen_Bände_Reihen) ([]*core.Record, error) { - records := make([]*core.Record, 0, len(relations.Relationen)) +func RecordsFromRelationBändeReihen(app core.App, relations xmlmodels.Relationen_Bände_Reihen) ([]*dbmodels.REntriesSeries, error) { + records := make([]*dbmodels.REntriesSeries, 0, len(relations.Relationen)) collection, err := app.FindCollectionByNameOrId(dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE)) if err != nil { app.Logger().Error("Error finding collection", "error", err, "collection", dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.SERIES_TABLE)) @@ -17,47 +17,49 @@ func RecordsFromRelationBändeReihen(app core.App, relations xmlmodels.Relatione } for _, relation := range relations.Relationen { - entry, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, relation.Band) + e, err := app.FindFirstRecordByData(dbmodels.ENTRIES_TABLE, dbmodels.MUSENALMID_FIELD, relation.Band) if err != nil { app.Logger().Error("Error finding Entry", "error", err, "relation", relation) continue } + entry := dbmodels.NewEntry(e) + series, err := app.FindFirstRecordByData(dbmodels.SERIES_TABLE, dbmodels.MUSENALMID_FIELD, relation.Reihe) if err != nil { app.Logger().Error("Error finding Series", "error", err, "relation", relation) continue } - record := core.NewRecord(collection) - record.Set(dbmodels.ENTRIES_TABLE, entry.Id) - record.Set(dbmodels.SERIES_TABLE, series.Id) + record := dbmodels.NewREntriesSeries(core.NewRecord(collection)) + record.SetEntry(entry.Id) + record.SetSeries(series.Id) switch relation.Relation { case "1": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Bevorzugter Reihentitel") + record.SetType("Bevorzugter Reihentitel") case "2": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Alternativer Reihentitel") + record.SetType("Alternativer Reihentitel") case "3": - record.Set(dbmodels.RELATION_TYPE_FIELD, "In anderer Sprache") + record.SetType("In anderer Sprache") case "4": - entry.Set(dbmodels.LANGUAGE_FIELD, "fre") + entry.SetLanguage([]string{"fre"}) _ = app.Save(entry) - record.Set(dbmodels.RELATION_TYPE_FIELD, "In anderer Sprache") + record.SetType("In anderer Sprache") case "5": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Alternativer Reihentitel") + record.SetType("Alternativer Reihentitel") case "6": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Früherer Reihentitel") + record.SetType("Früherer Reihentitel") case "7": - record.Set(dbmodels.RELATION_TYPE_FIELD, "Späterer Reihentitel") + record.SetType("Späterer Reihentitel") } - rel := record.GetString(dbmodels.RELATION_TYPE_FIELD) - ent := record.GetString(dbmodels.ENTRIES_TABLE) - ser := record.GetString(dbmodels.SERIES_TABLE) + rel := record.Type() + ent := record.Entry() + ser := record.Series() if strings.TrimSpace(rel) == "" || strings.TrimSpace(ent) == "" || strings.TrimSpace(ser) == "" { - entry.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) + entry.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-2]) _ = app.Save(entry) } diff --git a/migrations/seed/series.go b/migrations/seed/series.go index 88fdb12..59ed8da 100644 --- a/migrations/seed/series.go +++ b/migrations/seed/series.go @@ -8,33 +8,33 @@ import ( "github.com/pocketbase/pocketbase/core" ) -func RecordsFromReihentitel(app core.App, reihen xmlmodels.Reihentitel) ([]*core.Record, error) { +func RecordsFromReihentitel(app core.App, reihen xmlmodels.Reihentitel) ([]*dbmodels.Series, error) { collection, err := app.FindCollectionByNameOrId(dbmodels.SERIES_TABLE) - records := make([]*core.Record, 0, len(reihen.Reihen)) + records := make([]*dbmodels.Series, 0, len(reihen.Reihen)) if err != nil { fmt.Println(err) return records, err } for i := 0; i < len(reihen.Reihen); i++ { - record := core.NewRecord(collection) + record := dbmodels.NewSeries(core.NewRecord(collection)) reihe := reihen.Reihen[i] if reihe.Titel == "" { - record.Set(dbmodels.SERIES_NAME_FIELD, reihe.Sortiername) + record.SetTitle(NormalizeString(reihe.Sortiername)) } else { - record.Set(dbmodels.SERIES_NAME_FIELD, reihe.Titel) + record.SetTitle(NormalizeString(reihe.Titel)) } - record.Set(dbmodels.REFERENCES_FIELD, NormalizeString(reihe.Nachweis)) - record.Set(dbmodels.ANNOTATION_FIELD, NormalizeString(reihe.Anmerkungen)) - record.Set(dbmodels.SERIES_FREQUENCY_FIELD, "jährlich") - record.Set(dbmodels.MUSENALMID_FIELD, reihe.ID) + record.SetReferences(NormalizeString(reihe.Nachweis)) + record.SetAnnotation(NormalizeString(reihe.Anmerkungen)) + record.SetFrequency("jährlich") + record.SetMusenalmID(reihe.ID) - n := record.GetString(dbmodels.SERIES_NAME_FIELD) + n := record.Title() if n == "" { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[1]) } else { - record.Set(dbmodels.EDITSTATE_FIELD, dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) + record.SetEditState(dbmodels.EDITORSTATE_VALUES[len(dbmodels.EDITORSTATE_VALUES)-1]) } records = append(records, record)