CROSSLINK-264 retry-action

broker/cmd/archive/main_test.go

@@ -25,7 +25,7 @@ func TestMain(m *testing.M) {
 		postgres.WithPassword("crosslink"),
 		testcontainers.WithWaitStrategy(
 			wait.ForLog("database system is ready to accept connections").
-				WithOccurrence(2).WithStartupTimeout(5*time.Second)),
+				WithOccurrence(2).WithStartupTimeout(30*time.Second)),
 	)
 	test.Expect(err, "failed to start db container")
 

broker/cmd/broker/main_test.go

@@ -31,7 +31,7 @@ func TestMain(m *testing.M) {
 		postgres.WithPassword("crosslink"),
 		testcontainers.WithWaitStrategy(
 			wait.ForLog("database system is ready to accept connections").
-				WithOccurrence(2).WithStartupTimeout(5*time.Second)),
+				WithOccurrence(2).WithStartupTimeout(30*time.Second)),
 	)
 	test.Expect(err, "failed to start db container")
 

broker/handler/iso18626-handler.go

@@ -215,6 +215,17 @@ func handleRetryRequest(ctx common.ExtendedContext, request *iso18626.Request, r
 		illTrans.Timestamp = timestamp
 
 		_, err = repo.SaveIllTransaction(ctx, ill_db.SaveIllTransactionParams(illTrans))
+		if err != nil {
+			return err
+		}
+
+		// Keep the selected supplier's LocalID in sync with the updated SupplierUniqueRecordId.
+		// createRequestMessage overwrites BibliographicInfo.SupplierUniqueRecordId with LocalID, so
+		// without this update the stale LocalID from the original holdings lookup would be sent.
+		if newLocalId := request.BibliographicInfo.SupplierUniqueRecordId; newLocalId != "" {
+			selSup.LocalID = pgtype.Text{String: newLocalId, Valid: true}
+			_, err = repo.SaveLocatedSupplier(ctx, ill_db.SaveLocatedSupplierParams(selSup))
+		}
 		return err
 	})
 	return id, err

broker/migrations/046_add_patron_links.down.sql

@@ -0,0 +1,30 @@
+DROP VIEW IF EXISTS patron_request_search_view;
+ALTER TABLE patron_request DROP COLUMN next_req_id;
+ALTER TABLE patron_request DROP COLUMN prev_req_id;
+ALTER TABLE patron_request DROP COLUMN retry_bib_info;
+
+CREATE VIEW patron_request_search_view AS
+SELECT
+    pr.*,
+    EXISTS (
+        SELECT 1
+        FROM notification n
+        WHERE n.pr_id = pr.id
+    ) AS has_notification,
+    EXISTS (
+        SELECT 1
+        FROM notification n
+        WHERE n.pr_id = pr.id and cost is not null
+    ) AS has_cost,
+    (unread.unread_notifications_count > 0) AS has_unread_notification,
+    (pr.internal_note IS NOT NULL AND btrim(pr.internal_note) <> '') AS has_internal_note,
+    pr.ill_request -> 'serviceInfo' ->> 'serviceType' AS service_type,
+    pr.ill_request -> 'serviceInfo' -> 'serviceLevel' ->> '#text' AS service_level,
+    immutable_to_timestamp(pr.ill_request -> 'serviceInfo' ->> 'needBeforeDate') AS needed_at,
+    unread.unread_notifications_count AS unread_notifications_count
+FROM patron_request pr
+LEFT JOIN LATERAL (
+    SELECT COUNT(*) AS unread_notifications_count
+    FROM notification n
+    WHERE n.pr_id = pr.id and n.acknowledged_at is null
+) unread ON true;

broker/migrations/046_add_patron_links.up.sql

@@ -0,0 +1,31 @@
+ALTER TABLE patron_request ADD COLUMN next_req_id VARCHAR;
+ALTER TABLE patron_request ADD COLUMN prev_req_id VARCHAR;
+ALTER TABLE patron_request ADD COLUMN retry_bib_info JSONB;
+
+DROP VIEW IF EXISTS patron_request_search_view;
+
+CREATE VIEW patron_request_search_view AS
+SELECT
+    pr.*,
+    EXISTS (
+        SELECT 1
+        FROM notification n
+        WHERE n.pr_id = pr.id
+    ) AS has_notification,
+    EXISTS (
+        SELECT 1
+        FROM notification n
+        WHERE n.pr_id = pr.id and cost is not null
+    ) AS has_cost,
+    (unread.unread_notifications_count > 0) AS has_unread_notification,
+    (pr.internal_note IS NOT NULL AND btrim(pr.internal_note) <> '') AS has_internal_note,
+    pr.ill_request -> 'serviceInfo' ->> 'serviceType' AS service_type,
+    pr.ill_request -> 'serviceInfo' -> 'serviceLevel' ->> '#text' AS service_level,
+    immutable_to_timestamp(pr.ill_request -> 'serviceInfo' ->> 'needBeforeDate') AS needed_at,
+    unread.unread_notifications_count AS unread_notifications_count
+FROM patron_request pr
+LEFT JOIN LATERAL (
+    SELECT COUNT(*) AS unread_notifications_count
+    FROM notification n
+    WHERE n.pr_id = pr.id and n.acknowledged_at is null
+) unread ON true;

broker/oapi/open-api.yaml

@@ -582,6 +582,15 @@ components:
         internalNote:
           type: string
           description: Staff-only internal note, local to this request and never shared with peers
+        nextReqId:
+          type: string
+          description: ID of the next patron request in the sequence
+        prevReqId:
+          type: string
+          description: ID of the previous patron request in the sequence
+        retryBibInfo:
+          type: object
+          description: Bibliographic information for the item to retry the request for when in retrying state
       required:
         - id
         - createdAt

broker/patron_request/api/api-handler.go

@@ -964,6 +964,9 @@ func toApiPatronRequest(r *http.Request, request pr_db.PatronRequestSearchView)
 		EventsLink:               eventsLink,
 		TerminalState:            request.TerminalState,
 		InternalNote:             toString(request.InternalNote),
+		NextReqId:                toString(request.NextReqID),
+		PrevReqId:                toString(request.PrevReqID),
+		RetryBibInfo:             bibInfoToMap(request.RetryBibInfo),
 	}
 	if request.UpdatedAt.Valid {
 		pr.UpdatedAt = &request.UpdatedAt.Time
@@ -982,6 +985,21 @@ func toString(text pgtype.Text) *string {
 	return value
 }
 
+func bibInfoToMap(info *iso18626.BibliographicInfo) *map[string]interface{} {
+	if info == nil {
+		return nil
+	}
+	b, err := json.Marshal(info)
+	if err != nil {
+		return nil
+	}
+	var m map[string]interface{}
+	if err := json.Unmarshal(b, &m); err != nil {
+		return nil
+	}
+	return &m
+}
+
 func (a *PatronRequestApiHandler) parseAndValidateIllRequest(
 	ctx common.ExtendedContext,
 	request *proapi.CreatePatronRequest,

broker/patron_request/db/prcql.go

@@ -293,6 +293,9 @@ func (q *Queries) ListPatronRequestsCql(ctx context.Context, db DBTX, arg ListPa
 			&i.PatronRequestSearchView.UpdatedAt,
 			&i.PatronRequestSearchView.IllResponse,
 			&i.PatronRequestSearchView.InternalNote,
+			&i.PatronRequestSearchView.NextReqID,
+			&i.PatronRequestSearchView.PrevReqID,
+			&i.PatronRequestSearchView.RetryBibInfo,
 			&i.PatronRequestSearchView.HasNotification,
 			&i.PatronRequestSearchView.HasCost,
 			&i.PatronRequestSearchView.HasUnreadNotification,

broker/patron_request/service/action.go

@@ -31,9 +31,10 @@ type PatronRequestActionService struct {
 }
 
 type actionExecutionResult struct {
-	status events.EventStatus
-	result *events.EventResult
-	pr     pr_db.PatronRequest
+	status  events.EventStatus
+	result  *events.EventResult
+	pr      pr_db.PatronRequest
+	retryPr pr_db.PatronRequest
 }
 
 type autoActionFailure struct {
@@ -51,6 +52,8 @@ type actionParams struct {
 	Cost           *float64 `json:"cost,omitempty"`
 	Currency       string   `json:"currency,omitempty"`
 	ReasonUnfilled string   `json:"reasonUnfilled,omitempty"`
+	ReasonRetry    string   `json:"reasonRetry,omitempty"`
+	ItemID         string   `json:"itemId,omitempty"`
 }
 
 func CreatePatronRequestActionService(prRepo pr_db.PrRepo, eventBus events.EventBus, iso18626Handler handler.Iso18626HandlerInterface, lmsCreator lms.LmsCreator) *PatronRequestActionService {
@@ -186,12 +189,30 @@ func (a *PatronRequestActionService) finalizeActionExecution(ctx common.Extended
 		stateChanged = true
 	}
 
-	var err error
-	updatedPr, err = a.prRepo.UpdatePatronRequest(ctx, pr_db.UpdatePatronRequestParams(updatedPr))
+	var retryPr pr_db.PatronRequest
+	err := a.prRepo.WithTxFunc(ctx, func(repo pr_db.PrRepo) error {
+		var err error
+		if execResult.retryPr.ID != "" {
+			retryPr, err = repo.CreatePatronRequest(ctx, pr_db.CreatePatronRequestParams(execResult.retryPr))
+			if err != nil {
+				return fmt.Errorf("create retry patron request: %w", err)
+			}
+		}
+		updatedPr, err = repo.UpdatePatronRequest(ctx, pr_db.UpdatePatronRequestParams(updatedPr))
+		if err != nil {
+			return fmt.Errorf("update patron request: %w", err)
+		}
+		return nil
+	})
 	if err != nil {
-		return logActionErrorAndReturnResult(ctx, "failed to update patron request", err)
+		return logActionErrorAndReturnResult(ctx, "failed to persist patron request", err)
+	}
+	if retryPr.ID != "" {
+		err := a.RunAutoActionsOnStateEntry(ctx, retryPr, &event.ID, event.EventData.User)
+		if err != nil {
+			return logActionErrorAndReturnResult(ctx, "failed to run auto actions on state entry", err)
+		}
 	}
-
 	if stateChanged {
 		err := a.RunAutoActionsOnStateEntry(ctx, updatedPr, &event.ID, event.EventData.User)
 		if err != nil {
@@ -314,6 +335,10 @@ func (a *PatronRequestActionService) handleBorrowingAction(ctx common.ExtendedCo
 		return a.acceptConditionBorrowingRequest(ctx, pr)
 	case BorrowerActionRejectCondition:
 		return a.rejectConditionBorrowingRequest(ctx, pr)
+	case BorrowerActionRejectRetry:
+		return a.rejectRetryBorrowingRequest(pr)
+	case BorrowerActionAcceptRetry:
+		return a.acceptRetryBorrowingRequest(ctx, pr)
 	default:
 		status, result := logActionErrorAndReturnResult(ctx, "borrower action "+string(action)+" is not implemented yet", errors.New("invalid action"))
 		return actionExecutionResult{status: status, result: result, pr: pr}
@@ -368,6 +393,8 @@ func (a *PatronRequestActionService) handleLenderAction(ctx common.ExtendedConte
 		return a.markReceivedLenderRequest(ctx, pr, lms)
 	case LenderActionAcceptCancel:
 		return a.acceptCancelLenderRequest(ctx, pr)
+	case LenderActionAskRetry:
+		return a.askRetryLenderRequest(ctx, pr, params)
 	default:
 		status, result := logActionErrorAndReturnResult(ctx, "lender action "+string(action)+" is not implemented yet", errors.New("invalid action"))
 		return actionExecutionResult{status: status, result: result, pr: pr}
@@ -567,6 +594,53 @@ func (a *PatronRequestActionService) rejectConditionBorrowingRequest(ctx common.
 	return actionExecutionResult{status: events.EventStatusSuccess, result: &result, pr: pr}
 }
 
+func (a *PatronRequestActionService) rejectRetryBorrowingRequest(pr pr_db.PatronRequest) actionExecutionResult {
+	result := events.EventResult{}
+	return actionExecutionResult{status: events.EventStatusSuccess, result: &result, pr: pr}
+}
+
+func (a *PatronRequestActionService) acceptRetryBorrowingRequest(ctx common.ExtendedContext, pr pr_db.PatronRequest) actionExecutionResult {
+	result := events.EventResult{}
+
+	retryPr := pr_db.PatronRequest{}
+	retryPr.Side = pr.Side
+	retryPr.RequesterSymbol = pr.RequesterSymbol
+	retryPr.SupplierSymbol = pr.SupplierSymbol
+	retryPr.Patron = pr.Patron
+	retryPr.Tenant = pr.Tenant
+	var err error
+	retryPr.IllRequest, err = deepCopyISO18626Request(pr.IllRequest)
+	if err != nil {
+		status, result := logActionErrorAndReturnResult(ctx, "failed to clone IllRequest for retry", err)
+		return actionExecutionResult{status: status, result: result, pr: pr}
+	}
+	retryPr.State = BorrowerStateNew
+	retryPr.TerminalState = false
+	retryPr.ID = uuid.NewString()
+	retryPr.RequesterReqID = getDbTextPtr(&retryPr.ID)
+	retryPr.CreatedAt = pgtype.Timestamp{Valid: true, Time: time.Now()}
+	retryPr.IllRequest.Header.RequestingAgencyRequestId = retryPr.ID
+	retryPr.IllRequest.Header.Timestamp = utils.XSDDateTime{Time: retryPr.CreatedAt.Time}
+	retryPr.PrevReqID = getDbTextPtr(&pr.ID)
+	retryPr.Language = pr.Language
+	retryPr.Items = []pr_db.PrItem{}
+	retryPr.RetryBibInfo = nil
+	if pr.RetryBibInfo != nil {
+		// only take selected fields from retry bib info to allow for corrections without affecting other fields
+		if pr.RetryBibInfo.SupplierUniqueRecordId != "" {
+			retryPr.IllRequest.BibliographicInfo.SupplierUniqueRecordId = pr.RetryBibInfo.SupplierUniqueRecordId
+		}
+		if pr.RetryBibInfo.Title != "" {
+			retryPr.IllRequest.BibliographicInfo.Title = pr.RetryBibInfo.Title
+		}
+		if pr.RetryBibInfo.Author != "" {
+			retryPr.IllRequest.BibliographicInfo.Author = pr.RetryBibInfo.Author
+		}
+	}
+	pr.NextReqID = getDbTextPtr(&retryPr.ID)
+	return actionExecutionResult{status: events.EventStatusSuccess, result: &result, pr: pr, retryPr: retryPr}
+}
+
 func (a *PatronRequestActionService) validateLenderRequest(ctx common.ExtendedContext, pr pr_db.PatronRequest, lms lms.LmsAdapter) actionExecutionResult {
 	institutionalPatron := lms.InstitutionalPatron(pr.RequesterSymbol.String)
 	_, err := lms.LookupUser(institutionalPatron)
@@ -811,6 +885,32 @@ func (a *PatronRequestActionService) acceptCancelLenderRequest(ctx common.Extend
 	return a.checkSupplyingResponse(status, eventResult, &result, httpStatus, pr)
 }
 
+func (a *PatronRequestActionService) askRetryLenderRequest(ctx common.ExtendedContext, pr pr_db.PatronRequest, params actionParams) actionExecutionResult {
+	var deliveryInfo *iso18626.DeliveryInfo
+	if params.ItemID != "" {
+		deliveryInfo = &iso18626.DeliveryInfo{
+			ItemId: params.ItemID,
+		}
+	}
+	reasonRetry := string(iso18626.ReasonRetryNotFoundAsCited)
+	if params.ReasonRetry != "" {
+		reasonRetry = params.ReasonRetry
+	}
+	result := events.EventResult{}
+	status, eventResult, httpStatus := a.sendSupplyingAgencyMessage(ctx, pr, &result,
+		iso18626.MessageInfo{
+			ReasonRetry:      &iso18626.TypeSchemeValuePair{Text: reasonRetry},
+			ReasonForMessage: iso18626.TypeReasonForMessageStatusChange,
+			Note:             params.Note,
+		},
+		iso18626.StatusInfo{Status: iso18626.TypeStatusRetryPossible},
+		deliveryInfo)
+	if result.OutgoingMessage.SupplyingAgencyMessage != nil {
+		setSupplierMessage(*result.OutgoingMessage.SupplyingAgencyMessage, &pr)
+	}
+	return a.checkSupplyingResponse(status, eventResult, &result, httpStatus, pr)
+}
+
 func (a *PatronRequestActionService) checkSupplyingResponse(status events.EventStatus, eventResult *events.EventResult, result *events.EventResult, httpStatus *int, pr pr_db.PatronRequest) actionExecutionResult {
 	if httpStatus == nil {
 		return actionExecutionResult{status: status, result: eventResult, pr: pr}

broker/patron_request/service/action_mapping_test.go

@@ -22,12 +22,13 @@ func TestNewReturnableActionMapping(t *testing.T) {
 		BorrowerStateReceived:         {{actionName: BorrowerActionCheckOut}},
 		BorrowerStateCheckedOut:       {{actionName: BorrowerActionCheckIn}},
 		BorrowerStateCheckedIn:        {{actionName: BorrowerActionShipReturn}},
+		BorrowerStateRetryPending:     {{actionName: BorrowerActionAcceptRetry}, {actionName: BorrowerActionRejectRetry}},
 	}
 
 	lenderStateActionMapping := map[pr_db.PatronRequestState][]PatronRequestAction{
 		LenderStateNew:               {{actionName: LenderActionValidate, auto: true}},
-		LenderStateValidated:         {{actionName: LenderActionWillSupply, auto: true}, {actionName: LenderActionCannotSupply}, {actionName: LenderActionAddCondition}},
-		LenderStateWillSupply:        {{actionName: LenderActionAddCondition}, {actionName: LenderActionShip}, {actionName: LenderActionCannotSupply}},
+		LenderStateValidated:         {{actionName: LenderActionWillSupply, auto: true}, {actionName: LenderActionCannotSupply}, {actionName: LenderActionAddCondition}, {actionName: LenderActionAskRetry}},
+		LenderStateWillSupply:        {{actionName: LenderActionAddCondition}, {actionName: LenderActionShip}, {actionName: LenderActionCannotSupply}, {actionName: LenderActionAskRetry}},
 		LenderStateConditionPending:  {{actionName: LenderActionAddCondition}, {actionName: LenderActionCannotSupply}},
 		LenderStateConditionAccepted: {{actionName: LenderActionAddCondition}, {actionName: LenderActionShip}, {actionName: LenderActionCannotSupply}},
 		LenderStateShippedReturn:     {{actionName: LenderActionMarkReceived}},
@@ -40,9 +41,9 @@ func TestNewReturnableActionMapping(t *testing.T) {
 
 	assert.NotNil(t, returnableActionMapping)
 
-	mapCompare(t, returnableActionMapping.borrowerStateActionMapping, borrowerStateActionMapping)
+	mapCompare(t, borrowerStateActionMapping, returnableActionMapping.borrowerStateActionMapping)
 
-	mapCompare(t, returnableActionMapping.lenderStateActionMapping, lenderStateActionMapping)
+	mapCompare(t, lenderStateActionMapping, returnableActionMapping.lenderStateActionMapping)
 }
 
 var actionMappingService = ActionMappingService{}
@@ -93,7 +94,7 @@ func TestGetActionsForPatronRequest(t *testing.T) {
 	listCompare(t, []pr_db.PatronRequestAction{BorrowerActionAcceptCondition, BorrowerActionRejectCondition}, mapping.GetActionsForPatronRequest(pr_db.PatronRequest{Side: SideBorrowing, State: BorrowerStateConditionPending}))
 
 	// Lender
-	listCompare(t, []pr_db.PatronRequestAction{LenderActionAddCondition, LenderActionCannotSupply, LenderActionShip}, mapping.GetActionsForPatronRequest(pr_db.PatronRequest{Side: SideLending, State: LenderStateWillSupply}))
+	listCompare(t, []pr_db.PatronRequestAction{LenderActionAddCondition, LenderActionCannotSupply, LenderActionShip, LenderActionAskRetry}, mapping.GetActionsForPatronRequest(pr_db.PatronRequest{Side: SideLending, State: LenderStateWillSupply}))
 	listCompare(t, []pr_db.PatronRequestAction{LenderActionAddCondition, LenderActionCannotSupply}, mapping.GetActionsForPatronRequest(pr_db.PatronRequest{Side: SideLending, State: LenderStateConditionPending}))
 	listCompare(t, []pr_db.PatronRequestAction{LenderActionAddCondition, LenderActionCannotSupply, LenderActionShip}, mapping.GetActionsForPatronRequest(pr_db.PatronRequest{Side: SideLending, State: LenderStateConditionAccepted}))
 	listCompare(t, []pr_db.PatronRequestAction{}, mapping.GetActionsForPatronRequest(pr_db.PatronRequest{Side: SideLending, State: LenderStateShipped}))
@@ -144,6 +145,7 @@ func TestGetAllowedActionsForPatronRequest1(t *testing.T) {
 		{Name: string(LenderActionAddCondition), Parameters: []string{"note", "loanCondition", "cost", "currency"}},
 		{Name: string(LenderActionShip), Parameters: []string{"note"}, Primary: &tt},
 		{Name: string(LenderActionCannotSupply), Parameters: []string{"note", "reasonUnfilled"}},
+		{Name: string(LenderActionAskRetry), Parameters: []string{"note", "reasonRetry", "itemId"}},
 	}}, mapping.GetAllowedActionsForPatronRequest(pr_db.PatronRequest{Side: SideLending, State: LenderStateWillSupply}))
 }
 
@@ -198,7 +200,7 @@ func mapCompare(t *testing.T, map1 map[pr_db.PatronRequestState][]PatronRequestA
 	for stateName := range map1 {
 		listOne := map1[stateName]
 		listTwo := map2[stateName]
-		assert.Equal(t, len(listOne), len(listTwo))
+		assert.Equal(t, len(listOne), len(listTwo), "State %s has different number of actions in the two maps", stateName)
 		for i := range listOne {
 			assert.Equal(t, listOne[i].actionName, listTwo[i].actionName)
 			assert.Equal(t, listOne[i].auto, listTwo[i].auto)