DraftMatcher.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
 
#include "core/domain/catalog/WorkspaceCatalog.h"
#include "core/application/import/draft/StatementDraft.h"
#include "core/application/import/draft/TransactionDraft.h"
 
namespace core::application::importing::draft {

struct DraftSuggestionCandidate {
    std::string entityId;
    std::string label;
    std::string entityType;
    std::string sourceText;
    std::string rationale;
    std::string lastUsedAt;
    std::vector<std::string> matchedAliases;
    double confidence = 0.0;
    double score = 0.0;
    double aliasWeight = 0.0;
    double recencyWeight = 0.0;
    int hitCount = 0;
};

struct DraftSuggestionBucket {
    std::string sourceText;
    std::vector<DraftSuggestionCandidate> candidates;
};

struct DraftImportSuggestions {
    DraftSuggestionBucket actor;
    DraftSuggestionBucket property;
    DraftSuggestionBucket contract;
};

struct DraftTextSignals {
    std::string sharedText;
    std::string actorText;
    std::string propertyText;
    std::string contractText;
    std::string typeText;
};

struct DraftLinkSelection {
    std::string name;
    std::string metadata;
    std::string actorText;
    std::string propertyText;
    std::string actorId;
    bool actorSelected = false;
    std::string contractId;
    bool contractSelected = false;
    std::string type;
    bool allocatable = false;
    bool allocatableSelected = false;
    std::vector<std::string> propertyIds;
    DraftSuggestionBucket actorSuggestions;
    DraftSuggestionBucket propertySuggestions;
    DraftSuggestionBucket contractSuggestions;
};

struct DraftChoiceRow {
    std::string id;
    std::string name;
    std::string display;
    std::string type;
    std::string allocatableMode;
    std::vector<std::string> aliases;
    std::vector<std::string> actorIds;
    std::vector<std::string> propertyIds;
    bool synthetic = false;
    double confidence = 0.0;
    std::string sourceText;
};

struct DraftDerivedState {
    std::string proofSource;
    std::string actorSeedText;
    std::string actorDisplayText;
    std::string contractSeedText;
    std::string contractDisplayText;
    std::string actorSuggestionSummary;
    std::string propertySuggestionSummary;
    std::string contractSuggestionSummary;
    std::string allocatableSuggestionSummary;
    double actorSuggestionConfidence = 0.0;
    double propertySuggestionConfidence = 0.0;
    double contractSuggestionConfidence = 0.0;
    double allocatableSuggestionConfidence = 0.0;
    bool effectiveAllocatable = false;
    int actorCurrentIndex = -1;
    int contractCurrentIndex = -1;
    DraftSuggestionCandidate actorTopSuggestion;
    DraftSuggestionCandidate propertyTopSuggestion;
    DraftSuggestionCandidate contractTopSuggestion;
    bool hasActorTopSuggestion = false;
    bool hasPropertyTopSuggestion = false;
    bool hasContractTopSuggestion = false;
    std::vector<DraftChoiceRow> actorChoices;
    std::vector<DraftChoiceRow> contractChoices;
    std::vector<DraftChoiceRow> propertyRows;
    std::vector<std::string> autoPropertyIds;
};
 
enum class DraftAutoSelectionMode { InitialImport, InteractiveSync };
 
struct TransactionDraftPatch {
    bool hasName = false;
    std::string name;
    bool hasBookingDate = false;
    std::string bookingDate;
    bool hasValuta = false;
    std::string valuta;
    bool hasAmount = false;
    double amount = 0.0;
    bool hasStatus = false;
    int status = 0;
    bool hasAllocatable = false;
    bool allocatable = false;
    bool allocatableSelected = false;
};

std::string normalizeDraftText(const std::string& text);
bool matchesDraftText(const std::string& left, const std::string& right);
std::vector<std::string> referenceAliasesFromMetadata(const std::string& metadata);
DraftTextSignals buildDraftTextSignals(const core::domain::catalog::WorkspaceCatalog& state,
                                       const TransactionDraft& transaction);
DraftImportSuggestions buildImportSuggestions(const core::domain::catalog::WorkspaceCatalog& state,
                                              const TransactionDraft& transaction);
std::string resolveActorId(const core::domain::catalog::WorkspaceCatalog& state, const std::string& text);
std::string resolveContractId(const core::domain::catalog::WorkspaceCatalog& state, const std::string& text);
bool contractIsFullyAllocatable(const core::domain::catalog::WorkspaceCatalog& state, const std::string& contractId);
core::domain::catalog::WorkspaceCatalog mergeCatalogState(core::domain::catalog::WorkspaceCatalog primary,
                                                           const core::domain::catalog::WorkspaceCatalog& secondary);
DraftDerivedState buildDraftDerivedState(const core::domain::catalog::WorkspaceCatalog& state,
                                         const DraftLinkSelection& selection);
 
bool applyDerivedSelections(TransactionDraft& draft,
                            const DraftDerivedState& derived,
                            DraftAutoSelectionMode mode);
 
bool applyActorSelection(TransactionDraft& draft, const std::string& actorId);
bool clearActorSelection(TransactionDraft& draft);
bool applyPropertySelection(TransactionDraft& draft,
                            const std::string& propertyId);
bool setPropertySelected(TransactionDraft& draft,
                         const std::string& propertyId,
                         bool selected);
bool applyContractSelection(TransactionDraft& draft,
                            const DraftChoiceRow& contract);
bool applyContractSelection(TransactionDraft& draft,
                            const core::domain::catalog::WorkspaceCatalog& state,
                            const std::string& contractId);
bool clearContractSelection(TransactionDraft& draft);
bool applyTransactionPatch(TransactionDraft& draft,
                           const TransactionDraftPatch& patch);
int insertTransactionAfter(StatementDraft& draft, int currentIndex);
int removeTransactionAt(StatementDraft& draft, int index);
bool renameStatementDraft(StatementDraft& draft, const std::string& name);
 
}