Method StartInstantReconciliation

reconciliation.go:194–249

StartInstantReconciliation initiates a reconciliation process directly with provided transactions instead of loading them from an uploaded file. Parameters: - ctx: The context controlling the reconciliation process. - externalTransactions: The array of external transactions to reconcile. - strategy:

(ctx context.Context, externalTransactions []model.ExternalTransaction,
	strategy string, groupCriteria string, matchingRuleIDs []string, isDryRun bool,
)

// - string: The ID of the reconciliation process.
// - error: If the reconciliation fails to start.
func (s *LedgerForge) StartInstantReconciliation(ctx context.Context, externalTransactions []model.ExternalTransaction,
	strategy string, groupCriteria string, matchingRuleIDs []string, isDryRun bool,
) (string, error) {
	// Generate a unique ID for the reconciliation
	reconciliationID := model.GenerateUUIDWithSuffix("recon")

	// Use a temporary ID for the transactions
	tempID := model.GenerateUUIDWithSuffix("instant")

	// Initialize a new reconciliation object with the provided parameters
	reconciliation := model.Reconciliation{
		ReconciliationID: reconciliationID,
		UploadID:         tempID,
		Status:           StatusStarted,
		StartedAt:        time.Now(),
		IsDryRun:         isDryRun,
	}

	// Record the reconciliation in the data source
	if err := s.datasource.RecordReconciliation(ctx, &reconciliation); err != nil {
		return "", err
	}

	// Store the provided transactions in the database with the temporary ID
	for _, txn := range externalTransactions {
		if err := s.storeExternalTransaction(ctx, tempID, txn); err != nil {
			// Log error and update reconciliation status
			logrus.Errorf("Error storing transaction: %v", err)
			err := s.datasource.UpdateReconciliationStatus(ctx, reconciliationID, StatusFailed, 0, 0)
			if err != nil {
				logrus.Errorf("Error updating reconciliation status: %v", err)
				return "", fmt.Errorf("failed to store external transaction: %w", err)
			}
			return "", fmt.Errorf("failed to store external transaction: %w", err)
		}
	}

	// Detach the context to allow the reconciliation process to run in the background
	detachedCtx := context.Background()
	ctxWithTrace := trace.ContextWithSpan(detachedCtx, trace.SpanFromContext(ctx))

	// Start the reconciliation process asynchronously
	go func() {
		err := s.processReconciliation(ctxWithTrace, reconciliation, strategy, groupCriteria, matchingRuleIDs)
		if err != nil {
			// If an error occurs during the reconciliation, log it and update the reconciliation status to "failed"
			logrus.Errorf("Error in instant reconciliation process: %v", err)
			err := s.datasource.UpdateReconciliationStatus(ctxWithTrace, reconciliationID, StatusFailed, 0, 0)
			if err != nil {
				logrus.Errorf("Error updating reconciliation status: %v", err)
			}
		}
	}()

	return reconciliationID, nil
}

// GetReconciliation retrieves a reconciliation by its ID.