Financial Transaction Processing System. More...

Collaboration diagram for scenarios::FinancialTransactionSystem:

Classes
struct	Transaction

Public Member Functions
void	simulate_financial_scenario ()

Private Member Functions
void	process_transaction (const Transaction &transaction)

Private Attributes
std::atomic< int >	transactions_processed_ {0}

std::atomic< int >	fraud_alerts_ {0}

double	total_amount_ {0.0}

std::mutex	amount_mutex_

Detailed Description

Financial Transaction Processing System.

Examples: real_world_scenarios.cpp.

Definition at line 186 of file real_world_scenarios.cpp.

Member Function Documentation

◆ process_transaction()

void scenarios::FinancialTransactionSystem::process_transaction ( const Transaction & transaction )

inlineprivate

Examples: real_world_scenarios.cpp.

Definition at line 272 of file real_world_scenarios.cpp.

                                                             {
        bool is_suspicious = (transaction.amount > 5000.0) ||
                           (transaction.account_from == transaction.account_to);
 
        {
            std::lock_guard<std::mutex> lock(amount_mutex_);
            total_amount_ += transaction.amount;
        }
 
        auto container = std::make_shared<value_container>();
        container->set_source("transaction_processor", "fraud_detection");
        container->set_target("compliance_service", "transaction_monitor");
        container->set_message_type(is_suspicious ? "suspicious_transaction" : "normal_transaction");
 
        container->set("transaction_id", transaction.transaction_id);
        container->set("account_from", transaction.account_from);
        container->set("account_to", transaction.account_to);
        container->set("amount", transaction.amount);
        container->set("currency", transaction.currency);
        container->set("transaction_type", transaction.transaction_type);
        container->set("timestamp", static_cast<int64_t>(
            std::chrono::duration_cast<std::chrono::milliseconds>(
                transaction.timestamp.time_since_epoch()).count()));
        container->set("risk_score", is_suspicious ? 85.0 : 15.0);
 
        if (is_suspicious) {
            fraud_alerts_++;
            container->set("alert_reason",
                std::string(transaction.amount > 5000.0 ? "high_amount" : "same_account"));
            container->set("requires_manual_review", true);
 
            std::cout << "  FRAUD ALERT: " << transaction.transaction_id
                      << " Amount: $" << transaction.amount << std::endl;
        }
 
        container->serialize_string(value_container::serialization_format::binary).value();
    }

References scenarios::FinancialTransactionSystem::Transaction::account_from, scenarios::FinancialTransactionSystem::Transaction::account_to, scenarios::FinancialTransactionSystem::Transaction::amount, amount_mutex_, scenarios::FinancialTransactionSystem::Transaction::currency, fraud_alerts_, scenarios::FinancialTransactionSystem::Transaction::timestamp, total_amount_, scenarios::FinancialTransactionSystem::Transaction::transaction_id, and scenarios::FinancialTransactionSystem::Transaction::transaction_type.

Referenced by simulate_financial_scenario().

Here is the caller graph for this function:

◆ simulate_financial_scenario()

void scenarios::FinancialTransactionSystem::simulate_financial_scenario ( )

inline

Examples: real_world_scenarios.cpp.

Definition at line 204 of file real_world_scenarios.cpp.

                                       {
        std::cout << "\n=== Financial Transaction Processing Scenario ===" << std::endl;
 
        const int num_transactions = 100;
 
        std::queue<Transaction> transaction_queue;
        std::mutex transaction_mutex;
        std::condition_variable transaction_cv;
        std::atomic<bool> processing_active{true};
 
        std::thread fraud_detector([&]() {
            while (processing_active || !transaction_queue.empty()) {
                std::unique_lock<std::mutex> lock(transaction_mutex);
                transaction_cv.wait(lock, [&]() { return !transaction_queue.empty() || !processing_active; });
 
                if (!transaction_queue.empty()) {
                    Transaction transaction = transaction_queue.front();
                    transaction_queue.pop();
                    lock.unlock();
 
                    process_transaction(transaction);
                    transactions_processed_++;
                }
            }
        });
 
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_real_distribution<> amount_dist(10.0, 10000.0);
        std::uniform_int_distribution<> account_dist(1000, 9999);
        std::vector<std::string> currencies = {"USD", "EUR", "GBP"};
        std::vector<std::string> types = {"transfer", "payment", "withdrawal"};
 
        for (int i = 0; i < num_transactions; ++i) {
            Transaction transaction;
            transaction.transaction_id = "TXN" + std::to_string(1000000 + i);
            transaction.account_from = "ACC" + std::to_string(account_dist(gen));
            transaction.account_to = "ACC" + std::to_string(account_dist(gen));
            transaction.amount = amount_dist(gen);
            transaction.currency = currencies[i % currencies.size()];
            transaction.transaction_type = types[i % types.size()];
            transaction.timestamp = std::chrono::system_clock::now();
 
            {
                std::lock_guard<std::mutex> lock(transaction_mutex);
                transaction_queue.push(transaction);
            }
            transaction_cv.notify_one();
 
            std::this_thread::sleep_for(std::chrono::milliseconds(5));
        }
 
        processing_active = false;
        transaction_cv.notify_all();
        fraud_detector.join();
 
        std::cout << "Financial processing completed:" << std::endl;
        std::cout << "  Transactions processed: " << transactions_processed_.load() << std::endl;
        std::cout << "  Fraud alerts generated: " << fraud_alerts_.load() << std::endl;
        double total;
        {
            std::lock_guard<std::mutex> lock(amount_mutex_);
            total = total_amount_;
        }
        std::cout << "  Total amount processed: $" << std::fixed << std::setprecision(2) << total << std::endl;
    }