ImportWorkflow.h

Go to the documentation of this file.

 
#pragma once
 
#include <QHash>
#include <QObject>
#include <QString>
#include <QStringList>
#include <functional>
#include <memory>
 
#include "core/ports/diagnostics/IErrorReporter.h"
#include "core/ports/usecases/import/IImportRunner.h"
#include "core/ports/workspace/WorkspaceSnapshot.h"
 
namespace ui {

struct TransactionDraftView {
  QString id;
  QString name;
  QString bookingDate;
  QString valuta;
  QString amountText;
  QString metadata;
  QString proofSource;
  QString actorId;
  QString contractId;
  QStringList propertyIds;
  int status = 0;
  bool effectiveAllocatable = false;
  double actorSuggestionConfidence = 0.0;
  QString actorSuggestionSummary;
  double propertySuggestionConfidence = 0.0;
  QString propertySuggestionSummary;
  double contractSuggestionConfidence = 0.0;
  QString contractSuggestionSummary;
  double allocatableSuggestionConfidence = 0.0;
  QString allocatableSuggestionSummary;
};
 
class WorkspaceCommands;
class WorkspaceSelectors;
 
namespace adapters {
class ImportAdapter;
}
 
namespace importing {
class ImportWorkflowState;
 
} // namespace importing

class ImportWorkflow : public QObject {
  Q_OBJECT
 
public:
  using StateSnapshotProvider =
      std::function<core::ports::workspace::WorkspaceSnapshot()>;

  explicit ImportWorkflow(
      std::shared_ptr<ui::adapters::ImportAdapter> importAdapter,
      std::shared_ptr<core::ports::diagnostics::IErrorReporter> errorReporter,
      StateSnapshotProvider stateSnapshotProvider = {},
      WorkspaceCommands* commands = nullptr,
      WorkspaceSelectors* selectors = nullptr, QObject* parent = nullptr);
  ~ImportWorkflow() override;

  void setWorkspaceRoles(WorkspaceCommands* commands,
                         WorkspaceSelectors* selectors);

  bool isRunning() const noexcept;
  bool isPaused() const noexcept;
  double progress() const noexcept;
  QString phase() const;
  QString error() const;
  QString selectedFile() const;
  void setSelectedFile(const QString& path);
  int queuedCount() const noexcept;
  QStringList queuedFiles() const;
  bool hasDraft() const noexcept;
  QString currentDraftId() const;
  int currentTransactionIndex() const noexcept;
  void setCurrentTransactionIndex(int index);
  int transactionCount() const noexcept;

  QString currentStatementName() const;

  void flushActiveDraftToWorkspace();
  bool renameCurrentStatementDraft(const QString& name);
  int insertTransactionAfterCurrent();
  int removeCurrentTransaction();
  bool commitCurrentTransactionName(const QString& name);
  bool commitCurrentTransactionBookingDate(const QString& bookingDate);
  bool commitCurrentTransactionValuta(const QString& valuta);
  bool setCurrentTransactionStatus(int status);
  bool setCurrentTransactionAllocatable(bool allocatable);
  bool applyCurrentTransactionAmountText(const QString& amountText);
  bool selectCurrentTransactionActor(const QString& actorId);
  bool clearCurrentTransactionActor();
  bool setCurrentTransactionPropertySelected(const QString& propertyId,
                                             bool selected);
  bool selectCurrentTransactionContract(const QString& contractId);
  bool clearCurrentTransactionContract();
  bool createActorForCurrentTransaction(const QString& actorName);
  bool createPropertyForCurrentTransaction(const QString& propertyName);
  bool
  createOrSelectContractForCurrentTransaction(const QString& contractName,
                                              const QString& contractType,
                                              const QString& allocatableMode);
  TransactionDraftView currentTransactionView() const;
  void pauseActiveDraft();
  void discardActiveDraft();
  void finalizeActiveDraft();
  void removeAttachedImportLog(const QString& logId, bool draftAttached,
                               const QString& draftId);

  void startStatementImport();
  void addFiles(const QStringList& paths);
  void resetStatus();
  void clearDraft();
  bool openStoredDraft(const QString& draftId = {});
  void cancelImport();
  void cancelQueuedImports();
  void pauseImport();
  void resumeImport();
 
signals:
  void stateChanged();
  void importFinished();
  void importCanceled();
  void importFailed(const QString& error);
 
private slots:
  void updateProgress(double progress, const QString& phase);
  void onJobTerminal(core::ports::importing::StatementImportState state,
                     const QString& message);
 
private:
  bool hasActiveImportHandle() const noexcept;
  void clearActiveImportSubscription();
  void rejectImportStart(const QString& errorMessage, const char* traceMessage);
  void requestImportCancellation(bool clearQueue, const char* origin,
                                 const char* traceMessage);
  void setImportPaused(bool paused);
  void
  handleImportEvent(const core::ports::importing::StatementImportEvent& event);
  void handleImportCanceled();
  void handleImportFailed(const QString& errorMessage,
                          const char* traceMessage);
  bool populateDraftFromResult();
  void startNextQueuedImport();
  void startImportForFile(const QString& path);
  void reportException(const char* origin, std::exception_ptr exception) const;
  void saveImportLog(const QString& logId, const QString& status,
                     const QString& message, bool draftAttached = false,
                     const QString& draftId = {},
                     const QString& statementId = {},
                     const QString& importFile = {});
  void clearStoredDraft(const QString& draftId);
  void rememberCurrentDraftTransactionIndex();
  bool applyCurrentTransactionPatch(
      const core::ports::importing::draft::TransactionDraftPatch& patch);
  core::ports::importing::draft::TransactionDraft* currentTransactionDraft();
  const core::ports::importing::draft::TransactionDraft*
  currentTransactionDraft() const;
  core::ports::workspace::WorkspaceSnapshot stateSnapshot() const;
  core::ports::workspace::WorkspaceSnapshot catalogSnapshotForDraft() const;
  void notifyDraftChanged();
  core::ports::workspace::StatementDraftSnapshot
  currentStatementDraftSnapshot() const;
  QString finalizeCurrentStatementDraft();
  core::ports::importing::draft::StatementDraft* statementDraft() noexcept;
  const core::ports::importing::draft::StatementDraft*
  statementDraft() const noexcept;
  bool restoreDraftFromState(
      const core::ports::workspace::WorkspaceSnapshot& snapshot);
  QString resolveDraftContextId() const;
  int rememberedDraftTransactionIndex(const QString& draftId) const;
 
  std::unique_ptr<importing::ImportWorkflowState> state_;
  std::shared_ptr<ui::adapters::ImportAdapter> importAdapter_;
  StateSnapshotProvider stateSnapshotProvider_;
  WorkspaceCommands* commands_ = nullptr;
  WorkspaceSelectors* selectors_ = nullptr;
  std::shared_ptr<core::ports::diagnostics::IErrorReporter> errorReporter_;
 
  QString activeDraftId_;
  QHash<QString, int> draftTransactionIndexByDraftId_;
  QString activeImportLogId_;
  bool activeImportTerminalHandled_ = false;
  bool hasPendingTerminalEvent_ = false;
  bool hasActiveImportHandle_ = false;
  core::ports::importing::StatementImportHandle activeImportHandle_;
  core::ports::importing::StatementImportState pendingTerminalState_ =
      core::ports::importing::StatementImportState::Pending;
  QString pendingTerminalMessage_;
};
 
} // namespace ui