ILLDEV-423

broker/app/app.go

@@ -192,13 +192,17 @@ func Init(ctx context.Context) (Context, error) {
 	prActionService := prservice.CreatePatronRequestActionService(prRepo, illRepo, eventBus, &iso18626Handler, lmsCreator, email.NewEmailService())
 	prMessageHandler.SetAutoActionRunner(prActionService)
 	iso18626Client := client.CreateIso18626Client(eventBus, illRepo, prMessageHandler, MAX_MESSAGE_SIZE, delay)
-	supplierLocator := service.CreateSupplierLocator(eventBus, illRepo, dirAdapter, holdingsAdapter, availabilityCreator, CONSORTIUM_SYMBOL)
+	lookupAdapterFactory := service.NewLookupAdapterFactory(illRepo, dirAdapter, CONSORTIUM_SYMBOL, holdingsAdapter, availabilityCreator)
+	supplierLocator := service.CreateSupplierLocator(eventBus, illRepo, dirAdapter, lookupAdapterFactory)
 	workflowManager := service.CreateWorkflowManager(eventBus, illRepo, service.WorkflowConfig{})
 	tenantResolver := tenant.NewResolver().WithIllRepo(illRepo).WithLookupAdapter(dirAdapter).WithTenantToSymbol(TENANT_TO_SYMBOL)
 	apiHandler := api.NewApiHandler(eventRepo, illRepo, tenantResolver, API_PAGE_SIZE)
 	prApiHandler := prapi.NewPrApiHandler(prRepo, eventBus, eventRepo, tenantResolver, &iso18626Handler, API_PAGE_SIZE)
 	prApiHandler.SetAutoActionRunner(prActionService)
 	prApiHandler.SetActionTaskProcessor(prActionService)
+	prApiHandler.SetIllRepo(illRepo)
+	prApiHandler.SetDirectoryLookupAdapter(dirAdapter)
+	prApiHandler.SetLookupAdapterFactory(lookupAdapterFactory)
 	sseBroker := api.NewSseBroker(appCtx, tenantResolver)
 	psApiHandler := psapi.NewPsApiHandler(psRepo, prRepo, tenantResolver)
 

broker/handler/iso18626-handler.go

@@ -11,7 +11,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/indexdata/crosslink/broker/service"
+	"github.com/indexdata/crosslink/broker/holdings"
 	"github.com/indexdata/crosslink/broker/shim"
 
 	"github.com/indexdata/crosslink/broker/adapter"
@@ -198,7 +198,7 @@ func handleRetryRequest(ctx common.ExtendedContext, request *iso18626.Request, r
 
 		illTrans.LastRequesterAction = createPgText("Request")
 
-		oldParams := service.CreateHoldingsParams(illTrans.IllTransactionData)
+		oldParams := holdings.LookupParamsFromBibliographicInfo(illTrans.IllTransactionData.BibliographicInfo, illTrans.IllTransactionData.ServiceInfo)
 
 		illTransactionData := ill_db.IllTransactionData{
 			BibliographicInfo:     request.BibliographicInfo,
@@ -212,7 +212,7 @@ func handleRetryRequest(ctx common.ExtendedContext, request *iso18626.Request, r
 		}
 		illTrans.IllTransactionData = illTransactionData
 
-		newParams := service.CreateHoldingsParams(illTrans.IllTransactionData)
+		newParams := holdings.LookupParamsFromBibliographicInfo(illTrans.IllTransactionData.BibliographicInfo, illTrans.IllTransactionData.ServiceInfo)
 		retryLookupChanged = oldParams != newParams
 
 		timestamp := pgtype.Timestamp{

broker/holdings/adapter_metaproxy.go

@@ -10,13 +10,13 @@ type MetaproxyAvailabilityAdapter struct {
 	holdingsLookupAdapter LookupAdapter
 }
 
-func NewMetaproxyAvailabilityAdapter(config directory.ZoomConfig, metaproxyUrl string, queryBuilder LookupQueryBuilder, holdingsParser HoldingsParser) (LookupAdapter, error) {
+func NewMetaproxyAvailabilityAdapter(config directory.ZoomConfig, metaproxyUrl string, queryBuilder LookupQueryBuilder, holdingsParser HoldingsParser, metadataParser MetadataParser) (LookupAdapter, error) {
 	a := &MetaproxyAvailabilityAdapter{
-		holdingsLookupAdapter: CreateSruHoldingsLookupAdapter(http.DefaultClient, []string{metaproxyUrl}, config.Address, queryBuilder, holdingsParser, "marcxml"),
+		holdingsLookupAdapter: CreateSruHoldingsLookupAdapter(http.DefaultClient, []string{metaproxyUrl}, config.Address, queryBuilder, holdingsParser, metadataParser, "marcxml"),
 	}
 	return a, nil
 }
 
-func (a *MetaproxyAvailabilityAdapter) Lookup(params LookupParams) ([]Holding, string, error) {
+func (a *MetaproxyAvailabilityAdapter) Lookup(params LookupParams) (LookupResult, error) {
 	return a.holdingsLookupAdapter.Lookup(params)
 }

broker/holdings/adapter_mock.go

@@ -10,6 +10,11 @@ import (
 type MockAvailabilityAdapter struct {
 	Err      error
 	Holdings []Holding
+	Metadata Metadata
+}
+
+type MockAvailabilityLookupResult struct {
+	parent *MockAvailabilityAdapter
 }
 
 func NewMockAvailabilityAdapter(config directory.HoldingsConfig) (LookupAdapter, error) {
@@ -38,9 +43,21 @@ func NewMockAvailabilityAdapter(config directory.HoldingsConfig) (LookupAdapter,
 	return &MockAvailabilityAdapter{}, nil
 }
 
-func (a *MockAvailabilityAdapter) Lookup(params LookupParams) ([]Holding, string, error) {
+func (a *MockAvailabilityAdapter) Lookup(params LookupParams) (LookupResult, error) {
 	if a.Err != nil {
-		return nil, "", a.Err
+		return nil, a.Err
 	}
-	return a.Holdings, "", nil
+	return &MockAvailabilityLookupResult{parent: a}, nil
+}
+
+func (a *MockAvailabilityLookupResult) GetHoldings() ([]Holding, error) {
+	return a.parent.Holdings, nil
+}
+
+func (a *MockAvailabilityLookupResult) GetMetadata() (Metadata, error) {
+	return a.parent.Metadata, nil
+}
+
+func (a *MockAvailabilityLookupResult) GetQuery() string {
+	return ""
 }

broker/holdings/adapter_mock_shared.go

@@ -10,22 +10,38 @@ import (
 type MockHoldingsLookupAdapter struct {
 }
 
+type MockHoldingsLookupResult struct {
+	holdings    []Holding
+	holdingsErr error
+	query       string
+}
+
 // the original mock holdings adapter that we used for shared index testing
-func (m *MockHoldingsLookupAdapter) Lookup(params LookupParams) ([]Holding, string, error) {
+func (m *MockHoldingsLookupAdapter) Lookup(params LookupParams) (LookupResult, error) {
+	var result MockHoldingsLookupResult
+	result.holdings = []Holding{}
+	result.query = params.Identifier
 	ids := strings.Split(params.Identifier, ";")
 	i := 1
-	var holdings []Holding
 	for _, id := range ids {
+		if id == "" {
+			// if the identifier is empty, we return an error to simulate a missing parameter
+			return &result, errors.New("missing lookup parameter: identifier")
+		}
+		// LookupResult should return an error if the identifier is "error"
 		if id == "error" {
-			return []Holding{}, id, errors.New("there is error")
+			return &result, errors.New("there is error")
+		}
+		if id == "error-holdings" {
+			result.holdingsErr = errors.New("there is error in holdings")
 		}
 		if id == "not-found" { // we could also just not append?
-			return []Holding{}, id, nil
+			return &result, nil
 		}
 		if strings.Index(id, "return-") == 0 {
 			val := strings.SplitN(strings.TrimPrefix(id, "return-"), "::", 2)
 			if len(val) < 1 || len(val[0]) < 1 {
-				return nil, id, fmt.Errorf("invalid return- value")
+				return &result, fmt.Errorf("invalid return- value")
 			}
 			var s, l string
 			if len(val) == 1 {
@@ -36,17 +52,34 @@ func (m *MockHoldingsLookupAdapter) Lookup(params LookupParams) ([]Holding, stri
 				s = val[0]
 				l = val[1]
 			}
-			holdings = append(holdings, Holding{
+			result.holdings = append(result.holdings, Holding{
 				Symbol:          s,
 				LocalIdentifier: l,
 			})
 		} else {
-			holdings = append(holdings, Holding{
+			result.holdings = append(result.holdings, Holding{
 				Symbol:          "ISIL:SUP" + strconv.Itoa(i),
 				LocalIdentifier: id,
 			})
 		}
 		i++
 	}
-	return holdings, params.Identifier, nil
+	return &result, nil
+}
+
+func (m *MockHoldingsLookupResult) GetMetadata() (Metadata, error) {
+	var metadata Metadata
+	metadata.Identifier = m.query
+	return metadata, nil
+}
+
+func (m *MockHoldingsLookupResult) GetHoldings() ([]Holding, error) {
+	if m.holdingsErr != nil {
+		return nil, m.holdingsErr
+	}
+	return m.holdings, nil
+}
+
+func (m *MockHoldingsLookupResult) GetQuery() string {
+	return m.query
 }

broker/holdings/adapter_sru.go

@@ -18,52 +18,53 @@ type SruHoldingsLookupAdapter struct {
 	sruUrl         []string
 	client         *http.Client
 	holdingsParser HoldingsParser
+	metadataParser MetadataParser
 	queryBuilder   LookupQueryBuilder
 	xTarget        string
 	recordSchema   string
 }
 
-func CreateSruHoldingsLookupAdapter(client *http.Client, sruUrl []string, xTarget string, queryBuilder LookupQueryBuilder, parser HoldingsParser, recordSchema string) LookupAdapter {
-	return &SruHoldingsLookupAdapter{client: client, sruUrl: sruUrl, queryBuilder: queryBuilder, holdingsParser: parser, xTarget: xTarget, recordSchema: recordSchema}
+type SruLookupResult struct {
+	query    string
+	holdings []Holding
+	metadata *Metadata
 }
 
-func NewSruAvailabilityAdapter(config directory.SruConfig, queryBuilder LookupQueryBuilder, holdingsParser HoldingsParser) (LookupAdapter, error) {
+func CreateSruHoldingsLookupAdapter(client *http.Client, sruUrl []string, xTarget string, queryBuilder LookupQueryBuilder, parser HoldingsParser, metadataParser MetadataParser, recordSchema string) LookupAdapter {
+	return &SruHoldingsLookupAdapter{client: client, sruUrl: sruUrl, queryBuilder: queryBuilder, holdingsParser: parser, metadataParser: metadataParser, xTarget: xTarget, recordSchema: recordSchema}
+}
+
+func NewSruAvailabilityAdapter(config directory.SruConfig, queryBuilder LookupQueryBuilder, holdingsParser HoldingsParser, metadataParser MetadataParser) (LookupAdapter, error) {
 	var recordSchema string
 	if config.RecordSchema != nil {
 		recordSchema = *config.RecordSchema
 	}
 	if recordSchema == "" {
 		recordSchema = "marcxml" // default to marcxml if not specified
 	}
-	return CreateSruHoldingsLookupAdapter(http.DefaultClient, []string{config.Address}, "", queryBuilder, holdingsParser, recordSchema), nil
+	return CreateSruHoldingsLookupAdapter(http.DefaultClient, []string{config.Address}, "", queryBuilder, holdingsParser, metadataParser, recordSchema), nil
 }
 
-func (s *SruHoldingsLookupAdapter) parseRecord(record *sru.RecordDefinition, params LookupParams, holdings *[]Holding) error {
+func (s *SruHoldingsLookupAdapter) parseRecord(record *sru.RecordDefinition, processRecord func([]byte) (bool, error)) (bool, error) {
 	if record.RecordXMLEscaping != nil && *record.RecordXMLEscaping != sru.RecordXMLEscapingDefinitionXml {
-		return fmt.Errorf("unsupported RecordXMLEscaping: %s", *record.RecordXMLEscaping)
+		return false, fmt.Errorf("unsupported RecordXMLEscaping: %s", *record.RecordXMLEscaping)
 	}
 	receivedSchema := record.RecordSchema
 	if receivedSchema == "info:srw/schema/1/diagnostics-v1.1" { // surrogate diagnostic record
 		var diagnostic diag.Diagnostic
 		err := xml.Unmarshal(record.RecordData.XMLContent, &diagnostic)
 		if err != nil {
-			return fmt.Errorf("decoding surrogate diagnostic failed: %s", err.Error())
+			return false, fmt.Errorf("decoding surrogate diagnostic failed: %s", err.Error())
 		}
-		return errors.New("surrogate diagnostic: " + diagnostic.Message + ": " + diagnostic.Details)
+		return false, errors.New("surrogate diagnostic: " + diagnostic.Message + ": " + diagnostic.Details)
 	}
 	if receivedSchema == "info:srw/schema/1/marcxml-v1.1" {
 		receivedSchema = "marcxml"
 	}
 	if receivedSchema != "" && receivedSchema != s.recordSchema {
-		return fmt.Errorf("unsupported RecordSchema: %s", record.RecordSchema)
-	}
-
-	ret, err := s.holdingsParser.Parse(record.RecordData.XMLContent, params)
-	if err != nil {
-		return fmt.Errorf("parsing holdings failed: %s", err.Error())
+		return false, fmt.Errorf("unsupported RecordSchema: %s", record.RecordSchema)
 	}
-	*holdings = append(*holdings, ret...)
-	return nil
+	return processRecord(record.RecordData.XMLContent)
 }
 
 func encodeCqlSearchClause(field string, value string) (string, error) {
@@ -74,76 +75,110 @@ func encodeCqlSearchClause(field string, value string) (string, error) {
 	return cqlQuery.String(), nil
 }
 
-func (s *SruHoldingsLookupAdapter) search(sruUrl string, params LookupParams, query string) ([]Holding, string, error) {
+func (s *SruHoldingsLookupAdapter) search(sruUrl string, params LookupParams, query string, processRecord func([]byte) (bool, error)) (bool, error) {
 	var sruResponse sru.SearchRetrieveResponse
 	query = "?maximumRecords=1000&recordSchema=" + url.QueryEscape(s.recordSchema) + "&" + query
 	if s.xTarget != "" {
 		query += "&x-target=" + url.QueryEscape(s.xTarget)
 	}
+	found := false
 	err := httpclient.NewClient().GetXml(s.client, sruUrl+query, &sruResponse)
 	// notice: returning query even in case of error, to allow logging the query that caused the error
 	if err != nil {
-		return nil, query, err
+		return false, err
 	}
 	if sruResponse.Diagnostics != nil {
 		// non-surrogate diagnostics
 		diags := sruResponse.Diagnostics.Diagnostic
 		if len(diags) > 0 {
-			return nil, query, errors.New(diags[0].Message + ": " + diags[0].Details)
+			return false, errors.New(diags[0].Message + ": " + diags[0].Details)
 		}
 	}
-	var holdings []Holding
 	if sruResponse.Records != nil {
 		for _, record := range sruResponse.Records.Record {
-			err := s.parseRecord(&record, params, &holdings)
+			foundRecord, err := s.parseRecord(&record, processRecord)
 			if err != nil {
-				return nil, query, err
+				return false, fmt.Errorf("failed to parse holdings from SRU record: %w", err)
+			}
+			if foundRecord {
+				found = true
 			}
 		}
 	}
-	return holdings, query, nil
+	return found, nil
 }
 
-func (s *SruHoldingsLookupAdapter) getHoldings(sruUrl string, params LookupParams) ([]Holding, string, error) {
-	var holdings []Holding
+func (s *SruHoldingsLookupAdapter) lookupServer(sruUrl string, params LookupParams, processRecord func([]byte) (bool, error)) (bool, string, error) {
 	cqlList, pqfList, err := s.queryBuilder.Build(params)
 	if err != nil {
-		return nil, "", err
+		return false, "", err
 	}
-	var queryParams string
+	var query string
+	var found bool
 	for _, cql := range cqlList {
+		query = cql
 		sruQuery := "query=" + url.QueryEscape(cql)
-		holdings, queryParams, err = s.search(sruUrl, params, sruQuery)
-		if err != nil {
-			return nil, queryParams, err
-		}
-		if len(holdings) > 0 {
-			return holdings, queryParams, nil
+		found, err = s.search(sruUrl, params, sruQuery, processRecord)
+		if err != nil || found {
+			return found, query, err
 		}
 	}
 	for _, pqf := range pqfList {
+		query = pqf
 		sruQuery := "x-pquery=" + url.QueryEscape(pqf)
-		holdings, queryParams, err = s.search(sruUrl, params, sruQuery)
-		if err != nil {
-			return nil, queryParams, err
-		}
-		if len(holdings) > 0 {
-			return holdings, queryParams, nil
+		found, err = s.search(sruUrl, params, sruQuery, processRecord)
+		if err != nil || found {
+			return found, query, err
 		}
 	}
-	return holdings, queryParams, nil
+	return false, query, nil
 }
 
-func (s *SruHoldingsLookupAdapter) Lookup(params LookupParams) ([]Holding, string, error) {
-	var holdings []Holding
-	logQuery := ""
+func (s *SruHoldingsLookupAdapter) Lookup(params LookupParams) (LookupResult, error) {
+	var result SruLookupResult
+
 	for _, sruUrl := range s.sruUrl {
-		h, query, err := s.getHoldings(sruUrl, params)
+		var err error
+		found, query, err := s.lookupServer(sruUrl, params, func(xmlBuffer []byte) (bool, error) {
+			h, err := s.holdingsParser.Parse(xmlBuffer, params)
+			if err != nil {
+				return false, err
+			}
+			if result.metadata == nil && s.metadataParser != nil {
+				metadata, err := s.metadataParser.Parse(xmlBuffer)
+				if err != nil {
+					return false, fmt.Errorf("failed to parse metadata from SRU record: %w", err)
+				}
+				result.metadata = &metadata
+			}
+			if len(h) == 0 {
+				return false, nil
+			}
+			result.holdings = append(result.holdings, h...)
+			return true, nil
+		})
+		result.query = query
 		if err != nil {
-			return nil, query, err
+			return &result, err
 		}
-		holdings = append(holdings, h...)
-		logQuery = query
+		if found {
+			break
+		}
+	}
+	return &result, nil
+}
+
+func (r *SruLookupResult) GetQuery() string {
+	return r.query
+}
+
+func (s *SruLookupResult) GetHoldings() ([]Holding, error) {
+	return s.holdings, nil
+}
+
+func (s *SruLookupResult) GetMetadata() (Metadata, error) {
+	if s.metadata == nil {
+		return Metadata{}, nil
 	}
-	return holdings, logQuery, nil
+	return *s.metadata, nil
 }