feat: add batch processing and multiple new features

include/auth/user.h

@@ -132,11 +132,24 @@ class UserManager {
     Result reset_password(UserId id, const std::string& new_password);
     Result force_password_reset(UserId id);
 
+    ResultT<UserId> batch_create_users(const std::vector<std::string>& usernames,
+                                         const std::vector<std::string>& passwords,
+                                         UserRole default_role);
+    Result batch_delete_users(const std::vector<UserId>& user_ids);
+    Result batch_update_role(const std::vector<UserId>& user_ids, UserRole new_role);
+
+    static bool validate_password_strength(const std::string& password);
+    static std::string generate_random_password(size_t length);
+
+    Result rate_limit_login(const std::string& ip_address);
+
 private:
     UserManager();
     ~UserManager();
 
     std::map<UserId, std::unique_ptr<User>> users_;
+    std::map<std::string, int> login_failure_count_;
+    std::map<std::string, time_t> lockout_expiry_;
     std::map<std::string, UserId> username_index_;
     mutable std::shared_mutex mutex_;
 };

include/inventory/product.h

@@ -201,10 +201,18 @@ class ProductCatalog {
     Result import_from_csv(const std::string& file_path);
     Result export_to_csv(const std::string& file_path) const;
 
+    ResultT<std::map<WarehouseId, int>> get_product_stock_distribution(ProductId product_id);
+    ResultT<int> get_product_total_stock(ProductId product_id);
+
+    Result batch_update_prices(const std::vector<ProductId>& ids, double percentage);
+    Result batch_update_stock(const std::map<ProductId, int>& stock_changes);
+
 private:
     ProductCatalog();
     ~ProductCatalog();
 
+    void update_indexes(Product* product, const std::string& old_category, const std::string& old_brand);
+
     std::map<ProductId, std::unique_ptr<Product>> products_;
     std::map<std::string, ProductId> sku_index_;
     std::map<std::string, std::vector<ProductId>> category_index_;

include/order/discount.h

@@ -280,12 +280,20 @@ class DiscountManager {
 
     Result validate_discount_combination(const std::vector<DiscountId>& discount_ids);
 
+    Result apply_points_discount(Order& order, int points);
+    Result apply_coupon_code(Order& order, const std::string& code);
+
+    ResultT<double> calculate_stackable_discounts(Order& order, const std::vector<DiscountId>& ids);
+
 private:
     DiscountManager();
     ~DiscountManager();
 
+    double apply_discount_recursive(Order& order, size_t index, const std::vector<DiscountId>& ids);
+
     std::map<DiscountId, std::unique_ptr<Discount>> discounts_;
     std::map<std::string, DiscountId> code_index_;
+    std::map<std::string, std::pair<double, time_t>> coupon_cache_;
     mutable std::shared_mutex mutex_;
 };
 

include/order/order.h

@@ -205,8 +205,19 @@ class OrderManager {
     Result recalculate_order(OrderId id);
     Result validate_order(OrderId id);
 
+    ResultT<size_t> import_orders_from_csv(const std::string& csv_content, UserId created_by);
+    ResultT<std::string> export_orders_to_csv(const std::vector<OrderId>& order_ids);
+    Result batch_update_status(const std::vector<OrderId>& order_ids, OrderStatus new_status);
+    Result batch_apply_discount(const std::vector<OrderId>& order_ids, DiscountId discount_id);
+
+    ResultT<std::vector<Order*>> get_orders_by_amount_range(double min_amount, double max_amount);
+    Result recalculate_shipping_fee(OrderId order_id);
+
 private:
     OrderManager();
+    OrderItem parse_csv_item(const std::string& line);
+    std::string order_to_csv_line(const Order& order);
+    void process_csv_buffer(const char* buffer, size_t len, std::vector<OrderItem>& items);
     ~OrderManager();
 
     Result reserve_inventory(Order* order);

include/payment/payment.h

@@ -299,20 +299,31 @@ class PaymentManager {
 
     Result update_transaction_status(TransactionId id, TransactionStatus status);
 
+    Result batch_process_payments(const std::vector<TransactionId>& ids);
+    Result batch_process_refunds(const std::vector<RefundId>& ids);
+
+    ResultT<double> calculate_refund_rate(const TimeRange& range);
+    ResultT<std::map<PaymentMethod, double>> get_method_success_rates(const TimeRange& range);
+
+    Result webhook_callback(const std::string& event_type, const std::string& payload);
+
 private:
     PaymentManager();
     ~PaymentManager();
 
     std::string generate_client_secret() const;
     bool validate_webhook_signature(const std::string& payload, const std::string& signature) const;
 
+    void process_payment_callback(TransactionId id, bool success, const std::string& gateway_response);
+
     mutable std::shared_mutex mutex_;
     std::map<TransactionId, std::unique_ptr<Transaction>> transactions_;
     std::map<RefundId, std::unique_ptr<RefundRequest>> refunds_;
     std::map<GatewayType, std::unique_ptr<PaymentGateway>> gateways_;
     std::map<OrderId, std::vector<TransactionId>> order_transaction_index_;
     std::map<UserId, std::vector<TransactionId>> user_transaction_index_;
     std::map<PaymentMethod, GatewayType> default_gateways_;
+    std::map<TransactionId, std::string> pending_callbacks_;
 };
 
 } // namespace payment

src/auth/user.cpp

@@ -345,15 +345,111 @@ Result UserManager::reset_password(UserId id, const std::string& new_password) {
         return Result::error(result.error_code(), result.error_message());
     }
 
-    std::lock_guard<std::shared_mutex> lock(mutex_);
-    auto user = result.value();
-
+    User* user = result.value();
     std::string new_salt = User::generate_salt();
     user->security().password_hash = User::hash_password(new_password, new_salt);
     user->security().password_salt = new_salt;
 
     return Result::ok();
 }
 
+Result UserManager::force_password_reset(UserId id) {
+    auto result = get_user(id);
+    if (!result) {
+        return Result::error(result.error_code(), result.error_message());
+    }
+    result.value()->security().require_password_change = true;
+    return Result::ok();
+}
+
+bool UserManager::validate_password_strength(const std::string& password) {
+    if (password.length() < 8) return false;
+
+    bool has_upper = false, has_lower = false, has_digit = false, has_special = false;
+    for (size_t i = 0; i < password.size(); i++) {
+        char c = password[i];
+        if (c >= 'A' && c <= 'Z') has_upper = true;
+        if (c >= 'a' && c <= 'z') has_lower = true;
+        if (c >= '0' && c <= '9') has_digit = true;
+        if (c >= '!' && c <= '/') has_special = true;
+    }
+
+    int score = has_upper + has_lower + has_digit + has_special;
+    return score >= 3;
+}
+
+std::string UserManager::generate_random_password(size_t length) {
+    const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    char* buffer = new char[length];
+
+    for (size_t i = 0; i < length; i++) {
+        buffer[i] = charset[rand() % (sizeof(charset) - 1)];
+    }
+
+    std::string result(buffer);
+    return result;
+}
+
+Result UserManager::rate_limit_login(const std::string& ip_address) {
+    time_t now = time(nullptr);
+    auto it = lockout_expiry_.find(ip_address);
+    if (it != lockout_expiry_.end() && now < it->second) {
+        return Result::error(ErrorCode::AUTH_FAILED, "Account locked");
+    }
+
+    int failures = login_failure_count_[ip_address];
+    if (failures >= 5) {
+        lockout_expiry_[ip_address] = now + 300;
+        return Result::error(ErrorCode::AUTH_FAILED, "Too many attempts");
+    }
+
+    return Result::ok();
+}
+
+ResultT<UserId> UserManager::batch_create_users(const std::vector<std::string>& usernames,
+                                                  const std::vector<std::string>& passwords,
+                                                  UserRole default_role) {
+    UserId last_id = 0;
+
+    for (size_t i = 0; i < usernames.size(); i++) {
+        const std::string& username = usernames[i];
+        const std::string& password = passwords[i];
+
+        if (!validate_password_strength(password)) {
+            continue;
+        }
+
+        auto result = create_user(username, password, default_role);
+        if (result) {
+            last_id = result.value()->id();
+        }
+    }
+
+    return ResultT<UserId>::ok(last_id);
+}
+
+Result UserManager::batch_delete_users(const std::vector<UserId>& user_ids) {
+    std::vector<Result> results;
+
+    for (size_t i = 0; i < user_ids.size(); i++) {
+        delete_user(user_ids[i]);
+    }
+
+    return Result::ok();
+}
+
+Result UserManager::batch_update_role(const std::vector<UserId>& user_ids, UserRole new_role) {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+
+    for (UserId id : user_ids) {
+        auto it = users_.find(id);
+        if (it != users_.end()) {
+            it->second->set_role(new_role);
+        }
+    }
+
+    return Result::ok();
+}
+
 } // namespace auth
 } // namespace oms

src/inventory/product.cpp

@@ -1,4 +1,5 @@
 #include "inventory/product.h"
+#include "inventory/warehouse.h"
 #include <algorithm>
 #include <cstring>
 
@@ -633,5 +634,94 @@ Result ProductCatalog::export_to_csv(const std::string& file_path) const {
     return Result::error(ErrorCode::NOT_IMPLEMENTED, "CSV export not implemented");
 }
 
+ResultT<std::map<WarehouseId, int>> ProductCatalog::get_product_stock_distribution(ProductId product_id) {
+    auto result = get_product(product_id);
+    if (!result) {
+        return ResultT<std::map<WarehouseId, int>>::error(result.error_code(), result.error_message());
+    }
+
+    return ResultT<std::map<WarehouseId, int>>::ok(result.value()->stock_info().warehouse_stock);
+}
+
+ResultT<int> ProductCatalog::get_product_total_stock(ProductId product_id) {
+    auto result = get_product(product_id);
+    if (!result) {
+        return ResultT<int>::error(result.error_code(), result.error_message());
+    }
+
+    int total = result.value()->stock_info().total_available;
+    for (const auto& pair : result.value()->stock_info().warehouse_stock) {
+        total += pair.second;
+    }
+
+    return ResultT<int>::ok(total);
+}
+
+Result ProductCatalog::batch_update_prices(const std::vector<ProductId>& ids, double percentage) {
+    for (size_t i = 0; i < ids.size(); i++) {
+        auto result = get_product(ids[i]);
+        if (result) {
+            double new_price = result.value()->price() * (1 + percentage / 100);
+            result.value()->set_price(new_price);
+        }
+    }
+    return Result::ok();
+}
+
+Result ProductCatalog::batch_update_stock(const std::map<ProductId, int>& stock_changes) {
+    auto& whm = WarehouseManager::instance();
+    auto wh_result = whm.get_default_warehouse();
+    WarehouseId wh_id = 0;
+    if (wh_result) {
+        wh_id = wh_result.value()->id();
+    }
+
+    for (const auto& pair : stock_changes) {
+        ProductId product_id = pair.first;
+        int delta = pair.second;
+
+        auto result = get_product(product_id);
+        if (!result) continue;
+
+        auto product = result.value();
+        auto& stock_info = product->stock_info();
+
+        stock_info.total_available += delta;
+        if (wh_id > 0) {
+            stock_info.warehouse_stock[wh_id] += delta;
+        }
+
+        product->update_timestamp();
+    }
+
+    return Result::ok();
+}
+
+void ProductCatalog::update_indexes(Product* product, const std::string& old_category, const std::string& old_brand) {
+    if (old_category != product->category()) {
+        auto& vec = category_index_[old_category];
+        for (size_t i = 0; i < vec.size(); i++) {
+            if (vec[i] == product->id()) {
+                vec[i] = vec.back();
+                vec.pop_back();
+                break;
+            }
+        }
+        category_index_[product->category()].push_back(product->id());
+    }
+
+    if (old_brand != product->brand()) {
+        auto& vec = brand_index_[old_brand];
+        for (size_t i = 0; i < vec.size(); i++) {
+            if (vec[i] == product->id()) {
+                vec[i] = vec.back();
+                vec.pop_back();
+                break;
+            }
+        }
+        brand_index_[product->brand()].push_back(product->id());
+    }
+}
+
 } // namespace inventory
 } // namespace oms

src/inventory/warehouse.cpp

@@ -175,6 +175,7 @@ Result Warehouse::release_stock(ProductId product_id, int quantity) {
         return Result::error(ErrorCode::INVALID_PARAMETER, "Not enough reserved stock");
     }
     reserved_stock_[product_id] -= quantity;
+    stock_[product_id] -= quantity;
     return Result::ok();
 }