Finalized resolver

xmlmodels/common.go

@@ -61,6 +61,13 @@ func (i Identifier) Keys() []string {
 	return i.keys
 }
 
+type Reference struct {
+	Ref      string `xml:"ref,attr"`
+	Category string `xml:"kat,attr"`
+	Unsicher bool   `xml:"unsicher,attr"`
+	Inner    Inner
+}
+
 type Value struct {
 	Chardata string `xml:",chardata"`
 }

xmlmodels/library.go

@@ -40,12 +40,12 @@ func (l *Library) String() string {
 // INFO: this is the only place where the providers are created. There is no need for locking on access.
 func NewLibrary() *Library {
 	return &Library{
-		Agents:     &xmlprovider.XMLProvider[Agent]{},
-		Places:     &xmlprovider.XMLProvider[Place]{},
-		Works:      &xmlprovider.XMLProvider[Work]{},
-		Categories: &xmlprovider.XMLProvider[Category]{},
-		Issues:     &xmlprovider.XMLProvider[Issue]{},
-		Pieces:     &xmlprovider.XMLProvider[Piece]{},
+		Agents:     xmlprovider.NewXMLProvider[Agent](),
+		Places:     xmlprovider.NewXMLProvider[Place](),
+		Works:      xmlprovider.NewXMLProvider[Work](),
+		Categories: xmlprovider.NewXMLProvider[Category](),
+		Issues:     xmlprovider.NewXMLProvider[Issue](),
+		Pieces:     xmlprovider.NewXMLProvider[Piece](),
 	}
 }
 

xmlmodels/pieces.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/Theodor-Springmann-Stiftung/kgpz_web/providers/xmlprovider"
 	"github.com/google/uuid"
 )
 
@@ -66,6 +67,111 @@ func (p Piece) ReferencesIssue(y, no int) (*IssueRef, bool) {
 	return nil, false
 }
 
+func (p Piece) References() xmlprovider.ResolvingMap[Piece] {
+	refs := make(xmlprovider.ResolvingMap[Piece])
+	x := CategoryRef{}
+
+	for _, ref := range p.IssueRefs {
+		if ref.When.Year == 0 || ref.Nr == 0 {
+			continue
+		}
+		if ref.Category != "" {
+			refs[x.Name()] = append(refs[x.Name()], xmlprovider.Resolved[Piece]{
+				Reference:  ref.Category,
+				Cert:       !ref.Unsicher,
+				Conjecture: false,
+				Comment:    ref.Inner.InnerXML,
+			})
+		}
+		refs[ref.Name()] = append(refs[ref.Name()], xmlprovider.Resolved[Piece]{
+			Reference:  strconv.Itoa(ref.When.Year) + "-" + strconv.Itoa(ref.Nr),
+			Category:   ref.Category,
+			Cert:       !ref.Unsicher,
+			Conjecture: false,
+			Comment:    ref.Inner.InnerXML,
+			MetaData:   map[string]string{"Von": strconv.Itoa(ref.Von), "Bis": strconv.Itoa(ref.Bis)},
+		})
+	}
+
+	for _, ref := range p.PlaceRefs {
+		if ref.Category != "" {
+			refs[x.Name()] = append(refs[x.Name()], xmlprovider.Resolved[Piece]{
+				Reference:  ref.Category,
+				Cert:       !ref.Unsicher,
+				Conjecture: false,
+				Comment:    ref.Inner.InnerXML,
+			})
+		}
+		refs[ref.Name()] = append(refs[ref.Name()], xmlprovider.Resolved[Piece]{
+			Reference:  ref.Ref,
+			Category:   ref.Category,
+			Cert:       !ref.Unsicher,
+			Conjecture: false,
+			Comment:    ref.Inner.InnerXML,
+			MetaData:   map[string]string{},
+		})
+	}
+
+	for _, ref := range p.AgentRefs {
+		if ref.Category != "" {
+			refs[x.Name()] = append(refs[x.Name()], xmlprovider.Resolved[Piece]{
+				Reference:  ref.Category,
+				Cert:       !ref.Unsicher,
+				Conjecture: false,
+				Comment:    ref.Inner.InnerXML,
+			})
+		}
+		refs[ref.Name()] = append(refs[ref.Name()], xmlprovider.Resolved[Piece]{
+			Reference:  ref.Ref,
+			Category:   ref.Category,
+			Cert:       !ref.Unsicher,
+			Conjecture: false,
+			Comment:    ref.Inner.InnerXML,
+			MetaData:   map[string]string{},
+		})
+	}
+
+	for _, ref := range p.WorkRefs {
+		if ref.Category != "" {
+			refs[x.Name()] = append(refs[x.Name()], xmlprovider.Resolved[Piece]{
+				Reference:  ref.Category,
+				Cert:       !ref.Unsicher,
+				Conjecture: false,
+				Comment:    ref.Inner.InnerXML,
+			})
+		}
+		refs[ref.Name()] = append(refs[ref.Name()], xmlprovider.Resolved[Piece]{
+			Reference:  ref.Ref,
+			Category:   ref.Category,
+			Cert:       !ref.Unsicher,
+			Conjecture: false,
+			MetaData:   map[string]string{},
+		})
+	}
+
+	for _, ref := range p.PieceRefs {
+		if ref.Category != "" {
+			refs[x.Name()] = append(refs[x.Name()], xmlprovider.Resolved[Piece]{
+				Reference:  ref.Category,
+				Cert:       !ref.Unsicher,
+				Conjecture: false,
+				Comment:    ref.Inner.InnerXML,
+				MetaData:   map[string]string{},
+			})
+		}
+		refs[ref.Name()] = append(refs[ref.Name()], xmlprovider.Resolved[Piece]{
+			Reference:  ref.Ref,
+			Category:   ref.Category,
+			Cert:       !ref.Unsicher,
+			Conjecture: false,
+			Comment:    ref.Inner.InnerXML,
+			MetaData:   map[string]string{},
+		})
+	}
+
+	return refs
+}
+
 func (p Piece) ReferencesAgent(a string) (*AgentRef, bool) {
 	for _, i := range p.AgentRefs {
 		if strings.HasPrefix(i.Ref, a) {

xmlmodels/references.go

@@ -2,18 +2,16 @@ package xmlmodels
 
 import "encoding/xml"
 
-type Reference struct {
-	Ref      string `xml:"ref,attr"`
-	Category string `xml:"kat,attr"`
-	Unsicher bool   `xml:"unsicher,attr"`
-	Value
-}
-
 type AgentRef struct {
 	XMLName xml.Name `xml:"akteur"`
 	Reference
 }
 
+func (ar AgentRef) Name() string {
+	var x Agent
+	return x.Name()
+}
+
 type IssueRef struct {
 	XMLName xml.Name `xml:"stueck"`
 	Nr      int      `xml:"nr,attr"`
@@ -24,24 +22,49 @@ type IssueRef struct {
 	Reference // Nicht im Schema
 }
 
+func (ir IssueRef) Name() string {
+	var x Issue
+	return x.Name()
+}
+
 type PlaceRef struct {
 	XMLName xml.Name `xml:"ort"`
 	Reference
 }
 
+func (pr PlaceRef) Name() string {
+	var x Place
+	return x.Name()
+}
+
 type CategoryRef struct {
 	XMLName xml.Name `xml:"kategorie"`
 	Reference
 }
 
+func (cr CategoryRef) Name() string {
+	var x Category
+	return x.Name()
+}
+
 type WorkRef struct {
 	XMLName xml.Name `xml:"werk"`
 	Page    string   `xml:"s,attr"`
 	Reference
 }
 
+func (wr WorkRef) Name() string {
+	var x Work
+	return x.Name()
+}
+
 type PieceRef struct {
 	XMLName xml.Name `xml:"beitrag"`
 	Page    string   `xml:"s,attr"`
 	Reference
 }
+
+func (pr PieceRef) Name() string {
+	var x Piece
+	return x.Name()
+}

xmlmodels/works.go

@@ -3,7 +3,8 @@ package xmlmodels
 import (
 	"encoding/json"
 	"encoding/xml"
-	"strings"
+
+	"github.com/Theodor-Springmann-Stiftung/kgpz_web/providers/xmlprovider"
 )
 
 type Work struct {
@@ -20,15 +21,6 @@ func (w Work) Name() string {
 	return "work"
 }
 
-func (p Work) ReferencesAgent(a string) (*AgentRef, bool) {
-	for _, i := range p.AgentRefs {
-		if strings.HasPrefix(i.Ref, a) {
-			return &i, true
-		}
-	}
-	return nil, false
-}
-
 type Citation struct {
 	XMLName xml.Name `xml:"zitation"`
 	Title   string   `xml:"title"`
@@ -37,6 +29,22 @@ type Citation struct {
 	Inner
 }
 
+func (w Work) References() xmlprovider.ResolvingMap[Work] {
+	refs := make(xmlprovider.ResolvingMap[Work])
+
+	for _, ref := range w.AgentRefs {
+		refs[ref.Name()] = append(refs[ref.Name()], xmlprovider.Resolved[Work]{
+			Item:       &w,            // Reference to the current Work item
+			Reference:  ref.Ref,       // Reference ID
+			Category:   ref.Category,  // Category of the reference
+			Cert:       !ref.Unsicher, // Certainty flag (true if not unsure)
+			Conjecture: false,
+			Comment:    ref.Inner.InnerXML,
+		})
+	}
+
+	return refs
+}
 func (w Work) String() string {
 	data, _ := json.MarshalIndent(w, "", "  ")
 	return string(data)