MockReuserDatabaseHandler.hpp

Go to the documentation of this file.

/*
 SPDX-License-Identifier: GPL-2.0-only
 Author: Dietmar Helmut Leher <helmut.leher.ext@vaillant-group.com>
 SPDX-FileCopyrightText: © 2026 Vaillant GmbH
*/
#pragma once
 
#include "ReuserDatabaseHandler.hpp"
 
#include <functional>
#include <map>
#include <vector>
 
class MockReuserDatabaseHandler : public ReuserDatabaseHandler
{
public:
  explicit MockReuserDatabaseHandler();
 
  // ── Overridable callbacks ─────────────────────────────────────────────────
 
  std::function<bool(int, ItemTreeBounds&)>
    onGetParentItemBounds;
 
  std::function<std::vector<ReuseTriple>(int, int)>
    onGetReusedUploads;
 
  std::function<std::map<int, int>(int, int)>
    onGetClearingDecisionMapByPfile;
 
  std::function<std::map<int, std::vector<int>>(int, const std::vector<int>&)>
    onGetUploadTreePksForPfiles;
 
  std::function<bool(int, int, int, int, int)>
    onProcessUploadReuse;
 
  std::function<bool(int, int, int, int, int)>
    onProcessEnhancedUploadReuse;
 
  std::function<bool(int, int, int, int)>
    onReuseMainLicense;
 
  std::function<bool(int, int)>
    onReuseConfSettings;
 
  std::function<bool(int, int, int)>
    onReuseCopyrights;
 
  std::function<bool(int, int, int)>
    onProcessBulkReuser;
 
  std::function<bool(int)>
    onIsJobQueueRunning;
 
  std::function<int(int)>
    onGetEstimatedTime;
 
  // ── ReuserDatabaseHandler overrides ──────────────────────────────────────
 
  bool getParentItemBounds(int uploadId, ItemTreeBounds& out) override
  {
    if (onGetParentItemBounds) return onGetParentItemBounds(uploadId, out);
    return false;  // no callback set: leave out unmodified, signal "not found"
  }
 
  std::vector<ReuseTriple> getReusedUploads(int uploadId, int groupId) override
  {
    if (onGetReusedUploads) return onGetReusedUploads(uploadId, groupId);
    return {};
  }
 
  std::map<int, int> getClearingDecisionMapByPfile(
    int uploadId, int groupId) override
  {
    if (onGetClearingDecisionMapByPfile)
      return onGetClearingDecisionMapByPfile(uploadId, groupId);
    return {};
  }
 
  std::map<int, std::vector<int>> getUploadTreePksForPfiles(
    int uploadId, const std::vector<int>& pfileIds) override
  {
    if (onGetUploadTreePksForPfiles)
      return onGetUploadTreePksForPfiles(uploadId, pfileIds);
    return {};
  }
 
  bool processUploadReuse(int uploadId, int reusedUploadId,
    int groupId, int reusedGroupId, int userId) override
  {
    if (onProcessUploadReuse)
      return onProcessUploadReuse(uploadId, reusedUploadId, groupId,
        reusedGroupId, userId);
    return true;
  }
 
  bool processEnhancedUploadReuse(int uploadId, int reusedUploadId,
    int groupId, int reusedGroupId, int userId) override
  {
    if (onProcessEnhancedUploadReuse)
      return onProcessEnhancedUploadReuse(uploadId, reusedUploadId, groupId,
        reusedGroupId, userId);
    return true;
  }
 
  bool reuseMainLicense(int uploadId, int groupId,
    int reusedUploadId, int reusedGroupId) override
  {
    if (onReuseMainLicense)
      return onReuseMainLicense(uploadId, groupId, reusedUploadId,
        reusedGroupId);
    return true;
  }
 
  bool reuseConfSettings(int uploadId, int reusedUploadId) override
  {
    if (onReuseConfSettings) return onReuseConfSettings(uploadId, reusedUploadId);
    return true;
  }
 
  bool reuseCopyrights(int uploadId, int reusedUploadId, int userId) override
  {
    if (onReuseCopyrights)
      return onReuseCopyrights(uploadId, reusedUploadId, userId);
    return true;
  }
 
  bool processBulkReuser(int uploadId, int groupId, int userId) override
  {
    if (onProcessBulkReuser)
      return onProcessBulkReuser(uploadId, groupId, userId);
    return true;
  }
 
  bool isJobQueueRunning(int jqPk) override
  {
    if (onIsJobQueueRunning) return onIsJobQueueRunning(jqPk);
    return false;
  }
 
  int getEstimatedTime(int jqPk) override
  {
    if (onGetEstimatedTime) return onGetEstimatedTime(jqPk);
    return 0;
  }
};