Method oneToOneReconciliation

reconciliation.go:622–672

oneToOneReconciliation performs a one-to-one reconciliation, where each external transaction is matched against a single internal transaction. The process is parallelized using goroutines. Parameters: - ctx: Context for managing cancellation and timeouts. - externalTxns: The list of external transac

(ctx context.Context, externalTxns []*model.Transaction, matchingRules []model.MatchingRule)

// - []model.Match: A list of matched transactions.
// - []string: A list of unmatched transaction IDs.
func (s *LedgerForge) oneToOneReconciliation(ctx context.Context, externalTxns []*model.Transaction, matchingRules []model.MatchingRule) ([]model.Match, []string) {
	conf, err := config.Fetch()
	if err != nil {
		logrus.Errorf("Error fetching configuration: %v", err)
	}
	maxWorkers := 10 // Default
	if conf != nil {
		maxWorkers = conf.Transaction.MaxWorkers
	}

	var matches []model.Match
	var unmatched []string

	matchChan := make(chan model.Match, len(externalTxns)) // Channel to collect matched transactions.
	unmatchedChan := make(chan string, len(externalTxns))  // Channel to collect unmatched transactions.
	var wg sync.WaitGroup                                  // WaitGroup to manage concurrent goroutines.
	sem := make(chan struct{}, maxWorkers)                 // Semaphore to limit concurrency

	// Iterate over each external transaction and attempt to match it against internal transactions.
	for _, externalTxn := range externalTxns {
		wg.Add(1)
		go func(extTxn *model.Transaction) {
			defer wg.Done()
			sem <- struct{}{}        // Acquire token
			defer func() { <-sem }() // Release token

			err := s.findMatchingInternalTransaction(ctx, extTxn, matchingRules, matchChan, unmatchedChan)
			if err != nil {
				unmatchedChan <- extTxn.TransactionID
				logrus.Errorf("No match found for external transaction %s: %v", extTxn.TransactionID, err)
			}
		}(externalTxn)
	}

	// Close the channels after all goroutines are finished.
	go func() {
		wg.Wait()
		close(matchChan)
		close(unmatchedChan)
	}()

	// Collect matches and unmatched transactions from channels.
	for match := range matchChan {
		matches = append(matches, match)
	}
	for unmatchedID := range unmatchedChan {
		unmatched = append(unmatched, unmatchedID)
	}

	return matches, unmatched
}

// oneToManyReconciliation performs a one-to-many reconciliation, where each external transaction can match
// multiple internal transactions grouped by specific criteria.