Method findMatchingInternalTransaction

reconciliation.go:958–1012

findMatchingInternalTransaction attempts to find an internal transaction that matches the given external transaction. It processes the transactions in batches and applies the matching rules. Parameters: - ctx: The context controlling the operation. - externalTxn: The external transaction to match. -

(ctx context.Context, externalTxn *model.Transaction, matchingRules []model.MatchingRule, matchChan chan model.Match, unMatchChan chan string)

// Returns:
// - error: If any error occurs during processing.
func (s *LedgerForge) findMatchingInternalTransaction(ctx context.Context, externalTxn *model.Transaction, matchingRules []model.MatchingRule, matchChan chan model.Match, unMatchChan chan string) error {
	conf, err := config.Fetch()
	if err != nil {
		return err
	}

	matchFound := false

	minAmount, maxAmount, minDate, maxDate, currency := s.calculateMatchingBounds(externalTxn, matchingRules)

	_, err = s.ProcessTransactionInBatches(
		ctx,
		externalTxn.TransactionID,
		big.NewInt(int64(externalTxn.Amount)),
		conf.Transaction.MaxWorkers,
		false, // Stream mode
		func(ctx context.Context, id string, limit int, offset int64) ([]*model.Transaction, error) {
			return s.datasource.GetTransactionsByCriteria(ctx, minAmount, maxAmount, currency, minDate, maxDate, limit, offset)
		},

		func(ctx context.Context, jobs <-chan *model.Transaction, results chan<- BatchJobResult, wg *sync.WaitGroup, amount *big.Int) {
			defer wg.Done()
			for internalTxn := range jobs {
				select {
				case <-ctx.Done():
					return
				default:
					if s.matchesRules(externalTxn, *internalTxn, matchingRules) {
						matchChan <- model.Match{
							ExternalTransactionID: externalTxn.TransactionID,
							InternalTransactionID: internalTxn.TransactionID,
							Amount:                externalTxn.Amount,
							Date:                  externalTxn.CreatedAt,
						}
						matchFound = true
						return
					}
				}
			}
		},
	)
	if err != nil && err != context.Canceled {
		return err
	}

	if !matchFound {
		select {
		case unMatchChan <- externalTxn.TransactionID:
		default:
			return fmt.Errorf("failed to send unmatched transaction ID to channel")
		}
	}

	return nil
}

// getExternalTransactionsPaginated retrieves paginated external transactions from the data source.
// Parameters: