bibliomane/internal/inventaire/inventaireedition.go

package inventaire

import (
	"encoding/json"
	"net/url"
	"strings"

	"git.artlef.fr/bibliomane/internal/callapiutils"
)

type inventaireEditionQueryResult struct {
	Entities      []inventaireEditionQueryEntity
	inventaireUrl string
}

type inventaireEditionQueryEntity struct {
	WdId        string
	WorkId      string
	EditionId   string
	Title       string
	ISBN        string
	Uri         string
	Image       string
	Lang        string
	ReleaseDate string
}

func (i *inventaireEditionQueryResult) UnmarshalJSON(b []byte) error {
	var parsed struct {
		Entities map[string]json.RawMessage `json:"entities"`
	}
	err := json.Unmarshal(b, &parsed)
	if err != nil {
		return err
	}
	for _, entity := range parsed.Entities {
		var parsedEntity struct {
			WdId   string                     `json:"wdId"`
			Labels map[string]json.RawMessage `json:"labels"`
			Type   string                     `json:"type"`
			Uri    string                     `json:"uri"`
			Image  map[string]json.RawMessage `json:"image"`
			Lang   string                     `json:"originalLang"`
			Claims map[string]json.RawMessage `json:"claims"`
		}
		err = json.Unmarshal(entity, &parsedEntity)
		if err != nil {
			return err
		}
		if parsedEntity.Type == "edition" {
			workId, err := parseStringArrayFieldInJsonRaw(parsedEntity.Claims, "wdt:P629")
			if err != nil {
				return err
			}
			editionId, err := parseStringArrayFieldInJsonRaw(parsedEntity.Claims, "wdt:P123")
			if err != nil {
				return err
			}
			releaseDate, err := parseStringArrayFieldInJsonRaw(parsedEntity.Claims, "wdt:P577")
			if err != nil {
				return err
			}
			isbn, err := parseStringArrayFieldInJsonRaw(parsedEntity.Claims, "wdt:P212")
			if err != nil {
				return err
			}
			label, err := findLangageField(parsedEntity.Labels, "fromclaims")
			if err != nil {
				return err
			}
			image := ""
			imageFieldToParse, ok := parsedEntity.Image["url"]
			if ok {
				err := json.Unmarshal(imageFieldToParse, &image)
				if err != nil {
					return err
				}
				if image != "" {
					image = i.inventaireUrl + image
				}
			}
			i.Entities = append(i.Entities, inventaireEditionQueryEntity{
				WdId:        parsedEntity.WdId,
				WorkId:      workId,
				EditionId:   editionId,
				Title:       label,
				ISBN:        isbn,
				Uri:         parsedEntity.Uri,
				Image:       image,
				Lang:        parsedEntity.Lang,
				ReleaseDate: releaseDate,
			})
		}
	}
	return err
}

func parseStringArrayFieldInJsonRaw(jsonRawMap map[string]json.RawMessage, key string) (string, error) {
	fieldToParse, ok := jsonRawMap[key]
	if !ok {
		return "", nil
	}
	var fieldArray []string
	s := ""
	err := json.Unmarshal(fieldToParse, &fieldArray)
	if err != nil {
		return s, err
	}
	if len(fieldArray) > 0 {
		s = fieldArray[0]
	}
	return s, err
}

func callInventaireEditionEntities(inventaireUrl string, uris []string) (inventaireEditionQueryResult, error) {
	queryResult := inventaireEditionQueryResult{inventaireUrl: inventaireUrl}
	u, err := getInventaireEditionEntitiesUri(inventaireUrl, strings.Join(uris, "|"))
	if err != nil {
		return queryResult, err
	}
	err = callapiutils.FetchAndParseResult(u, &queryResult)
	return queryResult, err
}

func getInventaireEditionEntitiesUri(inventaireUrl string, uris string) (*url.URL, error) {
	u, err := computeInventaireApiUrl(inventaireUrl, "entities")
	if err != nil {
		return u, err
	}

	callapiutils.AddQueryParam(u, "action", "by-uris")
	callapiutils.AddQueryParam(u, "uris", uris)

	return u, err
}

type inventaireEditionPublisherResult struct {
	Lang  string
	Label string
}

func (i *inventaireEditionPublisherResult) UnmarshalJSON(b []byte) error {
	var parsed struct {
		Entities map[string]json.RawMessage
	}
	err := json.Unmarshal(b, &parsed)
	if err != nil {
		return err
	}

	for _, entity := range parsed.Entities {
		var publisherEntity struct {
			Type   string                     `json:"type"`
			Labels map[string]json.RawMessage `json:"labels"`
		}
		err := json.Unmarshal(entity, &publisherEntity)
		if err != nil {
			return err
		}
		label, _ := findLangageField(publisherEntity.Labels, i.Lang)
		i.Label = label
	}
	return err
}

func callInventairePublisherGetName(inventaireUrl string, editionId string, lang string) (string, error) {
	var queryResult inventaireEditionPublisherResult
	u, err := computeInventaireApiUrl(inventaireUrl, "entities")
	if err != nil {
		return "", err
	}
	queryResult.Lang = lang

	callapiutils.AddQueryParam(u, "action", "by-uris")
	callapiutils.AddQueryParam(u, "uris", editionId)
	callapiutils.AddQueryParam(u, "attributes", "info|labels")

	err = callapiutils.FetchAndParseResult(u, &queryResult)
	return queryResult.Label, err
}