diff options
Diffstat (limited to 'cashflow.cpp')
| -rw-r--r-- | cashflow.cpp | 907 |
1 files changed, 907 insertions, 0 deletions
diff --git a/cashflow.cpp b/cashflow.cpp new file mode 100644 index 0000000..8e48d27 --- /dev/null +++ b/cashflow.cpp @@ -0,0 +1,907 @@ +#include "cashflow.h" +#include "ui_cashflow.h" +#include <QMessageBox> +#include <QDir> +#include <QStandardPaths> +#include <QFontDialog> +#include <QLocale> + +CashFlow::CashFlow(QWidget *parent) + : QMainWindow(parent) + , ui(new Ui::CashFlow) + , currentTransactionId(-1) + , currentRecurringId(-1) + , startingBalance(0.0) + , currentAmountFont("Courier New", 10) +{ + ui->setupUi(this); + + // Initialize database + database = new Database(); + QString dbPath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/cashflow.db"; + QDir().mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)); + + if (!database->open(dbPath)) { + QMessageBox::critical(this, "Database Error", "Failed to open database: " + database->lastError()); + return; + } + + setupConnections(); + loadSettings(); + + // Set default date range (current month to 3 months out) + QDate today = QDate::currentDate(); + ui->dateFromEdit->setDate(QDate(today.year(), today.month(), 1)); + ui->dateToEdit->setDate(today.addMonths(3)); + + clearTransactionEntry(); + clearRecurringEntry(); + refreshView(); +} + +CashFlow::~CashFlow() +{ + delete database; + delete ui; +} + +void CashFlow::setupConnections() { + // Transaction tab + connect(ui->dateFromEdit, &QDateEdit::dateChanged, this, &CashFlow::onDateRangeChanged); + connect(ui->dateToEdit, &QDateEdit::dateChanged, this, &CashFlow::onDateRangeChanged); + connect(ui->periodCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &CashFlow::onPeriodChanged); + connect(ui->accountFilterCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &CashFlow::onDateRangeChanged); + connect(ui->showAccountBalancesCheck, &QCheckBox::stateChanged, this, &CashFlow::onDateRangeChanged); + + // Auto-save period and show balances settings + connect(ui->periodCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this]() { + database->setSetting("default_period", QString::number(ui->periodCombo->currentIndex())); + }); + connect(ui->showAccountBalancesCheck, &QCheckBox::stateChanged, this, [this]() { + database->setSetting("show_account_balances", QString::number(ui->showAccountBalancesCheck->isChecked() ? 1 : 0)); + }); + + connect(ui->transactionTable, &QTableWidget::itemSelectionChanged, this, &CashFlow::onTransactionSelected); + connect(ui->saveBtn, &QPushButton::clicked, this, &CashFlow::onSaveTransaction); + connect(ui->newBtn, &QPushButton::clicked, this, &CashFlow::onNewTransaction); + connect(ui->deleteBtn, &QPushButton::clicked, this, &CashFlow::onDeleteTransaction); + + // Set up Delete key shortcut for transaction table + ui->deleteBtn->setShortcut(Qt::Key_Delete); + + // Auto-save transaction fields on change + connect(ui->entryDateEdit, &QDateEdit::dateChanged, this, &CashFlow::onTransactionFieldChanged); + connect(ui->entryAmountSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &CashFlow::onTransactionFieldChanged); + connect(ui->entryAccountCombo, &QComboBox::currentTextChanged, this, &CashFlow::onTransactionFieldChanged); + connect(ui->entryCategoryCombo, &QComboBox::currentTextChanged, this, &CashFlow::onTransactionFieldChanged); + connect(ui->entryDescriptionEdit, &QLineEdit::textChanged, this, &CashFlow::onTransactionFieldChanged); + connect(ui->entryTypeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &CashFlow::onTransactionFieldChanged); + + // Color-code amount inputs + connect(ui->entryAmountSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &CashFlow::updateAmountColors); + connect(ui->recurringAmountSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &CashFlow::updateAmountColors); + + // Recurring tab + connect(ui->recurringTable, &QTableWidget::itemSelectionChanged, this, &CashFlow::onRecurringSelected); + connect(ui->saveRecurringBtn, &QPushButton::clicked, this, &CashFlow::onSaveRecurring); + connect(ui->newRecurringBtn, &QPushButton::clicked, this, &CashFlow::onNewRecurring); + connect(ui->deleteRecurringBtn, &QPushButton::clicked, this, &CashFlow::onDeleteRecurring); + + // Settings tab + connect(ui->amountFontBtn, &QPushButton::clicked, this, &CashFlow::onChooseAmountFont); + connect(ui->saveSettingsBtn, &QPushButton::clicked, this, &CashFlow::onSaveSettings); + + // Set up Delete key shortcut for recurring table + ui->deleteRecurringBtn->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_Delete)); +} + +void CashFlow::refreshView() { + // Populate account filter dropdown with unique accounts + // Block signals to prevent recursive refresh + ui->accountFilterCombo->blockSignals(true); + + QString currentFilter = ui->accountFilterCombo->currentText(); + ui->accountFilterCombo->clear(); + ui->accountFilterCombo->addItem("All Accounts"); + + // Get unique account names and categories + QSet<QString> accounts; + QSet<QString> categories; + for (const Transaction &t : database->getAllTransactions()) { + if (!t.account.isEmpty()) accounts.insert(t.account); + if (!t.category.isEmpty()) categories.insert(t.category); + } + for (const RecurringRule &r : database->getAllRecurringRules()) { + if (!r.account.isEmpty()) accounts.insert(r.account); + if (!r.category.isEmpty()) categories.insert(r.category); + } + + QStringList sortedAccounts = accounts.values(); + sortedAccounts.sort(); + ui->accountFilterCombo->addItems(sortedAccounts); + + // Populate entry form account combo + ui->entryAccountCombo->blockSignals(true); + QString currentAccount = ui->entryAccountCombo->currentText(); + ui->entryAccountCombo->clear(); + ui->entryAccountCombo->addItems(sortedAccounts); + ui->entryAccountCombo->setCurrentText(currentAccount); + ui->entryAccountCombo->blockSignals(false); + + // Populate entry form category combo + ui->entryCategoryCombo->blockSignals(true); + QString currentCategory = ui->entryCategoryCombo->currentText(); + ui->entryCategoryCombo->clear(); + QStringList sortedCategories = categories.values(); + sortedCategories.sort(); + ui->entryCategoryCombo->addItems(sortedCategories); + ui->entryCategoryCombo->setCurrentText(currentCategory); + ui->entryCategoryCombo->blockSignals(false); + + // Populate recurring rule account and category combos + ui->recurringAccountCombo->blockSignals(true); + ui->recurringAccountCombo->clear(); + ui->recurringAccountCombo->addItems(sortedAccounts); + ui->recurringAccountCombo->blockSignals(false); + + ui->recurringCategoryCombo->blockSignals(true); + ui->recurringCategoryCombo->clear(); + ui->recurringCategoryCombo->addItems(sortedCategories); + ui->recurringCategoryCombo->blockSignals(false); + + // Restore previous selection if possible + int index = ui->accountFilterCombo->findText(currentFilter); + if (index >= 0) { + ui->accountFilterCombo->setCurrentIndex(index); + } + + ui->accountFilterCombo->blockSignals(false); + + refreshTransactionTable(); + refreshRecurringTable(); + calculateAndDisplayBalance(); +} + +void CashFlow::refreshTransactionTable() { + QList<Transaction> allTransactions = getAllTransactionsInRange(); + + ui->transactionTable->setRowCount(0); + ui->transactionTable->setColumnCount(7); + ui->transactionTable->setHorizontalHeaderLabels({"Date", "Amount", "Balance", "Account", "Category", "Description", "Type"}); + + double runningBalance = startingBalance; + QMap<QString, double> accountBalances; // Track per-account balances + QDate currentPeriodEnd; + QString periodLabel; + int periodCount = 1; + + // Determine period type + PeriodType periodType = static_cast<PeriodType>(ui->periodCombo->currentIndex()); + + // Get first period end date + if (!allTransactions.isEmpty()) { + currentPeriodEnd = getPeriodEnd(allTransactions.first().date, periodType); + periodLabel = getPeriodLabel(allTransactions.first().date, periodType, periodCount); + } + + for (const Transaction &t : allTransactions) { + // Check if we've crossed into a new period + if (t.date > currentPeriodEnd) { + // Insert period end row + insertPeriodEndRow(periodLabel, runningBalance, accountBalances); + + // Move to next period + periodCount++; + currentPeriodEnd = getPeriodEnd(t.date, periodType); + periodLabel = getPeriodLabel(t.date, periodType, periodCount); + } + + // Update balances + runningBalance += t.amount; + accountBalances[t.account] += t.amount; + + // Insert transaction row + int row = ui->transactionTable->rowCount(); + ui->transactionTable->insertRow(row); + + // Store ID in first column's data for retrieval later + QTableWidgetItem *dateItem = new QTableWidgetItem(t.date.toString("MM/dd/yy")); + dateItem->setData(Qt::UserRole, t.id); + dateItem->setFlags(dateItem->flags() & ~Qt::ItemIsEditable); + ui->transactionTable->setItem(row, 0, dateItem); + + // Format amount with color, right-align, monospace + QTableWidgetItem *amountItem = new QTableWidgetItem(QString("$%1").arg(formatCurrency(t.amount))); + amountItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter); + amountItem->setFont(currentAmountFont); + amountItem->setFlags(amountItem->flags() & ~Qt::ItemIsEditable); + if (t.amount < 0) { + amountItem->setForeground(QColor(200, 0, 0)); + } else { + amountItem->setForeground(QColor(0, 150, 0)); + } + ui->transactionTable->setItem(row, 1, amountItem); + + // Format balance with right-align, monospace + QTableWidgetItem *balanceItem = new QTableWidgetItem(QString("$%1").arg(formatCurrency(runningBalance))); + balanceItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter); + balanceItem->setFont(currentAmountFont); + balanceItem->setFlags(balanceItem->flags() & ~Qt::ItemIsEditable); + if (runningBalance < 0) { + balanceItem->setForeground(QColor(200, 0, 0)); + } + ui->transactionTable->setItem(row, 2, balanceItem); + + QTableWidgetItem *accountItem = new QTableWidgetItem(t.account); + accountItem->setFlags(accountItem->flags() & ~Qt::ItemIsEditable); + ui->transactionTable->setItem(row, 3, accountItem); + + QTableWidgetItem *categoryItem = new QTableWidgetItem(t.category); + categoryItem->setFlags(categoryItem->flags() & ~Qt::ItemIsEditable); + ui->transactionTable->setItem(row, 4, categoryItem); + + QTableWidgetItem *descItem = new QTableWidgetItem(t.description); + descItem->setFlags(descItem->flags() & ~Qt::ItemIsEditable); + ui->transactionTable->setItem(row, 5, descItem); + + QTableWidgetItem *typeItem = new QTableWidgetItem( + t.type == TransactionType::Actual ? "Actual" : "Estimated"); + typeItem->setFlags(typeItem->flags() & ~Qt::ItemIsEditable); + ui->transactionTable->setItem(row, 6, typeItem); + + // Color code estimated vs actual + QColor rowColor = t.type == TransactionType::Actual ? + QColor(200, 255, 200) : QColor(255, 255, 200); + for (int col = 0; col < 7; col++) { + if (ui->transactionTable->item(row, col)) { + ui->transactionTable->item(row, col)->setBackground(rowColor); + } + } + } + + // Insert final period end row + if (!allTransactions.isEmpty()) { + insertPeriodEndRow(periodLabel, runningBalance, accountBalances); + } + + ui->transactionTable->resizeColumnsToContents(); + + // Set minimum and optimal widths for specific columns + ui->transactionTable->setColumnWidth(0, 100); // Date + ui->transactionTable->setColumnWidth(1, 100); // Amount + ui->transactionTable->setColumnWidth(2, 100); // Balance + ui->transactionTable->setColumnWidth(3, 120); // Account + ui->transactionTable->setColumnWidth(4, 120); // Category + ui->transactionTable->horizontalHeader()->setStretchLastSection(false); + ui->transactionTable->setColumnWidth(5, 250); // Description + ui->transactionTable->setColumnWidth(6, 80); // Type +} + +QDate CashFlow::getPeriodEnd(const QDate &date, PeriodType periodType) { + switch (periodType) { + case Daily: + return date; + case Weekly: { + // End on Sunday (7) + int daysUntilSunday = 7 - date.dayOfWeek(); + return date.addDays(daysUntilSunday); + } + case Monthly: + return QDate(date.year(), date.month(), date.daysInMonth()); + case Quarterly: { + int quarter = (date.month() - 1) / 3; + int lastMonthOfQuarter = (quarter + 1) * 3; + QDate lastDayOfQuarter(date.year(), lastMonthOfQuarter, 1); + return QDate(date.year(), lastMonthOfQuarter, lastDayOfQuarter.daysInMonth()); + } + } + return date; +} + +QString CashFlow::getPeriodLabel(const QDate &date, PeriodType periodType, int count) { + QDate periodStart = getPeriodStart(date, periodType); + QDate periodEnd = getPeriodEnd(date, periodType); + + QString dateRange = QString("%1 - %2").arg(periodStart.toString("MM/dd/yy")).arg(periodEnd.toString("MM/dd/yy")); + + switch (periodType) { + case Daily: + return QString("DAY %1 (%2) END").arg(count).arg(date.toString("MM/dd/yy")); + case Weekly: + return QString("WEEK %1 END (%2)").arg(count).arg(dateRange); + case Monthly: + return QString("%1 END (%2)").arg(date.toString("MMMM yyyy").toUpper()).arg(dateRange); + case Quarterly: + return QString("Q%1 %2 END (%3)").arg((date.month() - 1) / 3 + 1).arg(date.year()).arg(dateRange); + } + return ""; +} + +QDate CashFlow::getPeriodStart(const QDate &date, PeriodType periodType) { + switch (periodType) { + case Daily: + return date; + case Weekly: { + // Start on Monday (1) + int daysFromMonday = date.dayOfWeek() - 1; + return date.addDays(-daysFromMonday); + } + case Monthly: + return QDate(date.year(), date.month(), 1); + case Quarterly: { + int quarter = (date.month() - 1) / 3; + int firstMonthOfQuarter = quarter * 3 + 1; + return QDate(date.year(), firstMonthOfQuarter, 1); + } + } + return date; +} + +void CashFlow::insertPeriodEndRow(const QString &label, double balance, const QMap<QString, double> &accountBalances) { + int row = ui->transactionTable->rowCount(); + ui->transactionTable->insertRow(row); + + // Build display text with optional account balances + QString displayText = QString("%1 Balance: $%2").arg(label).arg(formatCurrency(balance)); + + if (ui->showAccountBalancesCheck->isChecked() && !accountBalances.isEmpty()) { + QStringList accountTexts; + QMapIterator<QString, double> it(accountBalances); + while (it.hasNext()) { + it.next(); + accountTexts.append(QString("%1: $%2").arg(it.key()).arg(formatCurrency(it.value()))); + } + displayText += " " + accountTexts.join(" "); + } + + QTableWidgetItem *spanItem = new QTableWidgetItem(displayText); + spanItem->setFont(QFont("Arial", 11, QFont::Bold)); + spanItem->setBackground(QColor(180, 180, 180)); + spanItem->setForeground(balance < 0 ? QColor(200, 0, 0) : QColor(0, 100, 0)); + spanItem->setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter); + spanItem->setFlags(spanItem->flags() & ~Qt::ItemIsSelectable); // Make non-selectable + + ui->transactionTable->setItem(row, 0, spanItem); + + // Span across all columns + ui->transactionTable->setSpan(row, 0, 1, 7); + + // Make the row taller + ui->transactionTable->setRowHeight(row, 30); +} + +void CashFlow::refreshRecurringTable() { + QList<RecurringRule> rules = database->getAllRecurringRules(); + + ui->recurringTable->setRowCount(0); + ui->recurringTable->setColumnCount(7); + ui->recurringTable->setHorizontalHeaderLabels({"ID", "Name", "Frequency", "Amount", "Account", "Category", "Start Date"}); + ui->recurringTable->setEditTriggers(QAbstractItemView::NoEditTriggers); + + for (const RecurringRule &r : rules) { + int row = ui->recurringTable->rowCount(); + ui->recurringTable->insertRow(row); + + ui->recurringTable->setItem(row, 0, new QTableWidgetItem(QString::number(r.id))); + ui->recurringTable->setItem(row, 1, new QTableWidgetItem(r.name)); + + QString freqStr; + switch (r.frequency) { + case RecurrenceFrequency::Daily: freqStr = "Daily"; break; + case RecurrenceFrequency::Weekly: freqStr = "Weekly"; break; + case RecurrenceFrequency::BiWeekly: freqStr = "Bi-Weekly"; break; + case RecurrenceFrequency::Monthly: freqStr = "Monthly"; break; + case RecurrenceFrequency::Yearly: freqStr = "Yearly"; break; + default: freqStr = "None"; break; + } + ui->recurringTable->setItem(row, 2, new QTableWidgetItem(freqStr)); + + // Amount with color coding, right-align, monospace + QTableWidgetItem *amountItem = new QTableWidgetItem(QString("$%1").arg(formatCurrency(r.amount))); + amountItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter); + amountItem->setFont(currentAmountFont); + if (r.amount < 0) { + amountItem->setForeground(QColor(200, 0, 0)); // Red for debits + } else { + amountItem->setForeground(QColor(0, 150, 0)); // Green for credits + } + ui->recurringTable->setItem(row, 3, amountItem); + + ui->recurringTable->setItem(row, 4, new QTableWidgetItem(r.account)); + ui->recurringTable->setItem(row, 5, new QTableWidgetItem(r.category)); + ui->recurringTable->setItem(row, 6, new QTableWidgetItem(r.startDate.toString("yyyy-MM-dd"))); + } + + ui->recurringTable->resizeColumnsToContents(); +} + +void CashFlow::calculateAndDisplayBalance() { + QList<Transaction> allTransactions = getAllTransactionsInRange(); + + double endBalance = startingBalance; + for (const Transaction &t : allTransactions) { + endBalance += t.amount; + } + + ui->startBalanceLabel->setText(QString("Starting Balance: $%1").arg(formatCurrency(startingBalance))); + ui->endBalanceLabel->setText(QString("Ending Balance: $%1").arg(formatCurrency(endBalance))); + + // Color code the ending balance + if (endBalance < 0) { + ui->endBalanceLabel->setStyleSheet("font-weight: bold; font-size: 12pt; color: red;"); + } else if (endBalance < 1000) { + ui->endBalanceLabel->setStyleSheet("font-weight: bold; font-size: 12pt; color: orange;"); + } else { + ui->endBalanceLabel->setStyleSheet("font-weight: bold; font-size: 12pt; color: green;"); + } +} + +QList<Transaction> CashFlow::getAllTransactionsInRange() { + QDate startDate = ui->dateFromEdit->date(); + QDate endDate = ui->dateToEdit->date(); + QString accountFilter = ui->accountFilterCombo->currentText(); + + // Safety check + if (accountFilter.isEmpty()) { + accountFilter = "All Accounts"; + } + + // Get actual transactions from database + QList<Transaction> actualTransactions = database->getTransactions(startDate, endDate); + + // Generate projected transactions from recurring rules + QList<Transaction> projectedTransactions = generateProjectedTransactions(); + + // Combine + QList<Transaction> allTransactions = actualTransactions + projectedTransactions; + + // Filter by account if not "All Accounts" + if (accountFilter != "All Accounts") { + QList<Transaction> filtered; + for (const Transaction &t : allTransactions) { + if (t.account == accountFilter) { + filtered.append(t); + } + } + allTransactions = filtered; + } + + // Sort by date, then by sort_order, then credits before debits + std::sort(allTransactions.begin(), allTransactions.end(), + [](const Transaction &a, const Transaction &b) { + if (a.date != b.date) return a.date < b.date; + if (a.sortOrder != b.sortOrder) return a.sortOrder < b.sortOrder; + // Credits (positive amounts) before debits (negative amounts) + return a.amount > b.amount; + }); + + return allTransactions; +} + +QList<Transaction> CashFlow::generateProjectedTransactions() { + QList<Transaction> projections; + QList<RecurringRule> rules = database->getAllRecurringRules(); + + QDate startDate = ui->dateFromEdit->date(); + QDate endDate = ui->dateToEdit->date(); + + for (const RecurringRule &rule : rules) { + QDate currentDate = rule.startDate > startDate ? rule.startDate : startDate; + + // Align to proper day based on frequency + if (rule.frequency == RecurrenceFrequency::Weekly || rule.frequency == RecurrenceFrequency::BiWeekly) { + // Find next occurrence of the specified day of week + while (currentDate <= endDate && currentDate.dayOfWeek() != rule.dayOfWeek) { + currentDate = currentDate.addDays(1); + } + } else if (rule.frequency == RecurrenceFrequency::Monthly) { + // Set to the specified day of month + int targetDay = qMin(rule.dayOfMonth, currentDate.daysInMonth()); + currentDate = QDate(currentDate.year(), currentDate.month(), targetDay); + if (currentDate < startDate) { + currentDate = currentDate.addMonths(1); + targetDay = qMin(rule.dayOfMonth, currentDate.daysInMonth()); + currentDate = QDate(currentDate.year(), currentDate.month(), targetDay); + } + } + + int count = 0; + while (currentDate <= endDate) { + if (rule.occurrences != -1 && count >= rule.occurrences) { + break; + } + + if (rule.endDate.isValid() && currentDate > rule.endDate) { + break; + } + + Transaction t; + t.id = -1; // Projected transactions have no ID + t.date = currentDate; + t.amount = rule.amount; + t.account = rule.account; + t.category = rule.category; + t.description = rule.description + " (projected)"; + t.type = TransactionType::Estimated; + t.recurringId = rule.id; + + projections.append(t); + count++; + + // Calculate next occurrence + switch (rule.frequency) { + case RecurrenceFrequency::Daily: + currentDate = currentDate.addDays(1); + break; + case RecurrenceFrequency::Weekly: + currentDate = currentDate.addDays(7); + break; + case RecurrenceFrequency::BiWeekly: + currentDate = currentDate.addDays(14); + break; + case RecurrenceFrequency::Monthly: { + currentDate = currentDate.addMonths(1); + int targetDay = qMin(rule.dayOfMonth, currentDate.daysInMonth()); + currentDate = QDate(currentDate.year(), currentDate.month(), targetDay); + break; + } + case RecurrenceFrequency::Yearly: + currentDate = currentDate.addYears(1); + break; + default: + currentDate = endDate.addDays(1); // Exit loop + break; + } + } + } + + return projections; +} + +void CashFlow::onDateRangeChanged() { + refreshView(); +} + +void CashFlow::onPeriodChanged() { + refreshView(); +} + +void CashFlow::onTransactionSelected() { + QList<QTableWidgetItem*> selected = ui->transactionTable->selectedItems(); + if (selected.isEmpty()) { + return; + } + + int row = selected[0]->row(); + int id = ui->transactionTable->item(row, 0)->data(Qt::UserRole).toInt(); + + // If it's a projected transaction (id = -1), don't load it for editing + if (id == -1) { + ui->entryStatusLabel->setText("(Projected - cannot edit)"); + currentTransactionId = -1; + return; + } + + // Load from database + QList<Transaction> allTrans = database->getAllTransactions(); + for (const Transaction &t : allTrans) { + if (t.id == id) { + currentTransactionId = id; + loadTransactionToEntry(t); + ui->entryStatusLabel->setText(QString("Editing ID: %1").arg(id)); + return; + } + } +} + +void CashFlow::onSaveTransaction() { + Transaction t; + t.id = currentTransactionId; + t.date = ui->entryDateEdit->date(); + t.amount = ui->entryAmountSpin->value(); + t.account = ui->entryAccountCombo->currentText(); + t.category = ui->entryCategoryCombo->currentText(); + t.description = ui->entryDescriptionEdit->text(); + t.type = ui->entryTypeCombo->currentText() == "Actual" ? TransactionType::Actual : TransactionType::Estimated; + t.recurringId = -1; // Manual entries don't have recurring ID + + bool success; + if (currentTransactionId == -1) { + // New transaction + success = database->addTransaction(t); + if (success) { + // Get the new ID and update currentTransactionId + QList<Transaction> allTrans = database->getAllTransactions(); + if (!allTrans.isEmpty()) { + currentTransactionId = allTrans.last().id; + } + } + } else { + // Update existing + success = database->updateTransaction(t); + } + + if (success) { + ui->entryStatusLabel->setText("Saved!"); + refreshView(); + } else { + QMessageBox::critical(this, "Error", "Failed to save: " + database->lastError()); + } +} + +void CashFlow::onTransactionFieldChanged() { + // Auto-save if we're editing an existing transaction or have data entered + if (currentTransactionId != -1 || + !ui->entryAccountCombo->currentText().isEmpty() || + ui->entryAmountSpin->value() != 0.0) { + onSaveTransaction(); + } +} + +void CashFlow::onNewTransaction() { + clearTransactionEntry(); + ui->entryDateEdit->setDate(QDate::currentDate()); + ui->entryDateEdit->setFocus(); +} + +void CashFlow::onDeleteTransaction() { + if (currentTransactionId == -1) { + QMessageBox::warning(this, "No Selection", "Please select a transaction to delete."); + return; + } + + if (QMessageBox::question(this, "Confirm Delete", + QString("Delete transaction ID %1?").arg(currentTransactionId)) == QMessageBox::Yes) { + if (database->deleteTransaction(currentTransactionId)) { + clearTransactionEntry(); + refreshView(); + } else { + QMessageBox::critical(this, "Error", "Failed to delete: " + database->lastError()); + } + } +} + +void CashFlow::onRecurringSelected() { + QList<QTableWidgetItem*> selected = ui->recurringTable->selectedItems(); + if (selected.isEmpty()) { + return; + } + + int row = selected[0]->row(); + int id = ui->recurringTable->item(row, 0)->text().toInt(); + + QList<RecurringRule> rules = database->getAllRecurringRules(); + for (const RecurringRule &r : rules) { + if (r.id == id) { + loadRecurringToEntry(r); + currentRecurringId = id; + return; + } + } +} + +void CashFlow::onSaveRecurring() { + RecurringRule r; + r.id = currentRecurringId; + r.name = ui->recurringNameEdit->text(); + r.startDate = ui->recurringStartDateEdit->date(); + r.amount = ui->recurringAmountSpin->value(); + r.account = ui->recurringAccountCombo->currentText(); + r.category = ui->recurringCategoryCombo->currentText(); + r.description = ui->recurringDescriptionEdit->text(); + r.occurrences = -1; // Default to infinite + + QString freqStr = ui->recurringFrequencyCombo->currentText(); + if (freqStr == "Daily") { + r.frequency = RecurrenceFrequency::Daily; + r.dayOfWeek = -1; + r.dayOfMonth = -1; + } + else if (freqStr == "Weekly") { + r.frequency = RecurrenceFrequency::Weekly; + r.dayOfWeek = r.startDate.dayOfWeek(); // Use the day of week from start date + r.dayOfMonth = -1; + } + else if (freqStr == "Bi-Weekly") { + r.frequency = RecurrenceFrequency::BiWeekly; + r.dayOfWeek = r.startDate.dayOfWeek(); // Use the day of week from start date + r.dayOfMonth = -1; + } + else if (freqStr == "Monthly") { + r.frequency = RecurrenceFrequency::Monthly; + r.dayOfWeek = -1; + r.dayOfMonth = r.startDate.day(); // Use the day of month from start date + } + else if (freqStr == "Yearly") { + r.frequency = RecurrenceFrequency::Yearly; + r.dayOfWeek = -1; + r.dayOfMonth = r.startDate.day(); + } + + bool success; + if (currentRecurringId == -1) { + success = database->addRecurringRule(r); + } else { + success = database->updateRecurringRule(r); + } + + if (success) { + refreshView(); + QMessageBox::information(this, "Success", "Recurring rule saved. Projections updated automatically."); + } else { + QMessageBox::critical(this, "Error", "Failed to save: " + database->lastError()); + } +} + +void CashFlow::onNewRecurring() { + clearRecurringEntry(); + ui->recurringStartDateEdit->setDate(QDate::currentDate()); + ui->recurringNameEdit->setFocus(); +} + +void CashFlow::onDeleteRecurring() { + if (currentRecurringId == -1) { + QMessageBox::warning(this, "No Selection", "Please select a recurring rule to delete."); + return; + } + + if (QMessageBox::question(this, "Confirm Delete", + "Delete this recurring rule?") == QMessageBox::Yes) { + if (database->deleteRecurringRule(currentRecurringId)) { + clearRecurringEntry(); + refreshView(); + } else { + QMessageBox::critical(this, "Error", "Failed to delete: " + database->lastError()); + } + } +} + +void CashFlow::clearTransactionEntry() { + currentTransactionId = -1; + ui->entryDateEdit->setDate(QDate::currentDate()); + ui->entryAmountSpin->setValue(0.0); + ui->entryAccountCombo->setCurrentText(""); + ui->entryCategoryCombo->setCurrentText(""); + ui->entryDescriptionEdit->clear(); + ui->entryTypeCombo->setCurrentIndex(0); + ui->entryStatusLabel->setText("(New transaction)"); + updateAmountColors(); +} + +void CashFlow::loadTransactionToEntry(const Transaction &t) { + // Block signals to prevent auto-save while loading + ui->entryDateEdit->blockSignals(true); + ui->entryAmountSpin->blockSignals(true); + ui->entryAccountCombo->blockSignals(true); + ui->entryCategoryCombo->blockSignals(true); + ui->entryDescriptionEdit->blockSignals(true); + ui->entryTypeCombo->blockSignals(true); + + ui->entryDateEdit->setDate(t.date); + ui->entryAmountSpin->setValue(t.amount); + ui->entryAccountCombo->setCurrentText(t.account); + ui->entryCategoryCombo->setCurrentText(t.category); + ui->entryDescriptionEdit->setText(t.description); + ui->entryTypeCombo->setCurrentIndex(t.type == TransactionType::Actual ? 1 : 0); + + ui->entryDateEdit->blockSignals(false); + ui->entryAmountSpin->blockSignals(false); + ui->entryAccountCombo->blockSignals(false); + ui->entryCategoryCombo->blockSignals(false); + ui->entryDescriptionEdit->blockSignals(false); + ui->entryTypeCombo->blockSignals(false); + + updateAmountColors(); +} + +void CashFlow::clearRecurringEntry() { + currentRecurringId = -1; + ui->recurringNameEdit->clear(); + ui->recurringStartDateEdit->setDate(QDate::currentDate()); + ui->recurringAmountSpin->setValue(0.0); + ui->recurringAccountCombo->setCurrentText(""); + ui->recurringCategoryCombo->setCurrentText(""); + ui->recurringDescriptionEdit->clear(); + ui->recurringFrequencyCombo->setCurrentIndex(3); // Default to Monthly + updateAmountColors(); +} + +void CashFlow::loadRecurringToEntry(const RecurringRule &r) { + ui->recurringNameEdit->setText(r.name); + ui->recurringStartDateEdit->setDate(r.startDate); + ui->recurringAmountSpin->setValue(r.amount); + ui->recurringAccountCombo->setCurrentText(r.account); + ui->recurringCategoryCombo->setCurrentText(r.category); + ui->recurringDescriptionEdit->setText(r.description); + + int freqIndex = 3; // Default monthly + switch (r.frequency) { + case RecurrenceFrequency::Daily: freqIndex = 0; break; + case RecurrenceFrequency::Weekly: freqIndex = 1; break; + case RecurrenceFrequency::BiWeekly: freqIndex = 2; break; + case RecurrenceFrequency::Monthly: freqIndex = 3; break; + case RecurrenceFrequency::Yearly: freqIndex = 4; break; + default: break; + } + ui->recurringFrequencyCombo->setCurrentIndex(freqIndex); + updateAmountColors(); +} + +void CashFlow::updateAmountColors() { + // Color code transaction amount + if (ui->entryAmountSpin->value() < 0) { + ui->entryAmountSpin->setStyleSheet("QDoubleSpinBox { color: rgb(200, 0, 0); font-weight: bold; }"); + } else if (ui->entryAmountSpin->value() > 0) { + ui->entryAmountSpin->setStyleSheet("QDoubleSpinBox { color: rgb(0, 150, 0); font-weight: bold; }"); + } else { + ui->entryAmountSpin->setStyleSheet(""); + } + + // Color code recurring amount + if (ui->recurringAmountSpin->value() < 0) { + ui->recurringAmountSpin->setStyleSheet("QDoubleSpinBox { color: rgb(200, 0, 0); font-weight: bold; }"); + } else if (ui->recurringAmountSpin->value() > 0) { + ui->recurringAmountSpin->setStyleSheet("QDoubleSpinBox { color: rgb(0, 150, 0); font-weight: bold; }"); + } else { + ui->recurringAmountSpin->setStyleSheet(""); + } +} + +void CashFlow::loadSettings() { + // Load settings from database + QString currency = database->getSetting("currency_symbol", "$"); + QString fontFamily = database->getSetting("amount_font", "Courier New"); + int fontSize = database->getSetting("amount_font_size", "10").toInt(); + int defaultPeriod = database->getSetting("default_period", "2").toInt(); // 2 = Monthly + bool showAccountBalances = database->getSetting("show_account_balances", "0").toInt(); + + // Set settings UI + ui->currencyEdit->setText(currency); + currentAmountFont = QFont(fontFamily, fontSize); + ui->amountFontBtn->setText(QString("%1, %2pt").arg(fontFamily).arg(fontSize)); + ui->defaultPeriodCombo->setCurrentIndex(defaultPeriod); + ui->defaultShowAccountBalancesCheck->setChecked(showAccountBalances); + + // Apply defaults to main UI (only on initial load) + ui->periodCombo->setCurrentIndex(defaultPeriod); + ui->showAccountBalancesCheck->setChecked(showAccountBalances); +} + +void CashFlow::applySettings() { + // Currency symbol is now part of the formatted text in line edits + // Font is already stored in currentAmountFont + + // Refresh to apply font changes + refreshView(); +} + +void CashFlow::onSaveSettings() { + // Save settings to database + database->setSetting("currency_symbol", ui->currencyEdit->text()); + database->setSetting("amount_font", currentAmountFont.family()); + database->setSetting("amount_font_size", QString::number(currentAmountFont.pointSize())); + database->setSetting("default_period", QString::number(ui->defaultPeriodCombo->currentIndex())); + database->setSetting("show_account_balances", QString::number(ui->defaultShowAccountBalancesCheck->isChecked() ? 1 : 0)); + + // Apply settings + applySettings(); + + QMessageBox::information(this, "Settings Saved", "Settings have been saved successfully."); +} + +void CashFlow::onChooseAmountFont() { + bool ok; + QFont selectedFont = QFontDialog::getFont(&ok, currentAmountFont, this, "Choose Amount Font", QFontDialog::MonospacedFonts); + + if (ok) { + currentAmountFont = selectedFont; + ui->amountFontBtn->setText(QString("%1, %2pt").arg(selectedFont.family()).arg(selectedFont.pointSize())); + } +} + +QString CashFlow::formatCurrency(double amount) const { + QLocale locale; + return locale.toString(amount, 'f', 2); +} + + |