383 lines
12 KiB
Dart
383 lines
12 KiB
Dart
/// Local labels / notes / recurring annotations for bank transactions.
|
|
library;
|
|
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../models/bank.dart';
|
|
import '../models/transaction_meta.dart';
|
|
import '../services/storage_service.dart';
|
|
|
|
class TxMetaController extends ChangeNotifier {
|
|
TxMetaController(this._storage) {
|
|
final loaded = _storage.loadTxMetaStore();
|
|
_byId = Map.of(loaded.byId);
|
|
_labelsByMerchant = {
|
|
for (final e in loaded.labelsByMerchant.entries)
|
|
e.key: List<String>.of(e.value),
|
|
};
|
|
_notesByMerchant = Map.of(loaded.notesByMerchant);
|
|
_exactTemplates = Map.of(loaded.exactTemplates);
|
|
_customLabels = List.of(loaded.customLabels);
|
|
}
|
|
|
|
final StorageService _storage;
|
|
|
|
Map<String, TxMeta> _byId = {};
|
|
Map<String, List<String>> _labelsByMerchant = {};
|
|
Map<String, String> _notesByMerchant = {};
|
|
Map<String, TxExactTemplate> _exactTemplates = {};
|
|
List<TxLabel> _customLabels = [];
|
|
|
|
/// Built-in + custom labels available for picking.
|
|
List<TxLabel> get allLabels => [...kBuiltinLabels, ..._customLabels];
|
|
|
|
List<TxLabel> get customLabels => List.unmodifiable(_customLabels);
|
|
|
|
TxLabel? labelById(String? id) {
|
|
if (id == null || id.isEmpty) return null;
|
|
for (final label in allLabels) {
|
|
if (label.id == id) return label;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
List<TxLabel> labelsFor(TxMeta meta) {
|
|
return [
|
|
for (final id in meta.labelIds)
|
|
if (labelById(id) != null) labelById(id)!,
|
|
];
|
|
}
|
|
|
|
/// Resolved meta: per-id overrides + inherited merchant rules.
|
|
TxMeta metaFor(BankTransaction tx) {
|
|
final stored = _byId[tx.id];
|
|
final template = _exactTemplates[tx.exactKey];
|
|
final inheritedLabels = _labelsByMerchant[tx.merchantKey] ??
|
|
_labelsByMerchant[tx.descriptionKey];
|
|
final inheritedNotes = _notesByMerchant[tx.merchantKey] ??
|
|
_notesByMerchant[tx.descriptionKey];
|
|
|
|
final labelIds = stored != null && stored.hasLabel
|
|
? stored.labelIds
|
|
: (inheritedLabels ?? const <String>[]);
|
|
|
|
final notes = stored != null && stored.hasNotes
|
|
? stored.notes
|
|
: (template != null && template.notes.trim().isNotEmpty
|
|
? template.notes
|
|
: (inheritedNotes ?? ''));
|
|
|
|
final recurring = stored?.recurring ?? template?.recurring ?? false;
|
|
|
|
return TxMeta(
|
|
labelIds: List<String>.of(labelIds),
|
|
notes: notes,
|
|
recurring: recurring,
|
|
);
|
|
}
|
|
|
|
int countSimilar(
|
|
BankTransaction prototype,
|
|
List<BankTransaction> all,
|
|
) {
|
|
final key = prototype.merchantKey;
|
|
if (key.isEmpty) return 1;
|
|
return all.where((tx) => tx.merchantKey == key).length;
|
|
}
|
|
|
|
List<BankTransaction> similarTo(
|
|
BankTransaction prototype,
|
|
List<BankTransaction> all,
|
|
) {
|
|
final key = prototype.merchantKey;
|
|
if (key.isEmpty) return [prototype];
|
|
return [
|
|
for (final tx in all)
|
|
if (tx.merchantKey == key) tx,
|
|
];
|
|
}
|
|
|
|
Future<void> setLabels(
|
|
BankTransaction tx,
|
|
List<String> labelIds, {
|
|
List<BankTransaction> applyToSimilar = const [],
|
|
}) async {
|
|
final cleaned = <String>[
|
|
for (final id in labelIds)
|
|
if (id.isNotEmpty) id,
|
|
];
|
|
// Deduplicate while preserving order.
|
|
final unique = <String>[];
|
|
for (final id in cleaned) {
|
|
if (!unique.contains(id)) unique.add(id);
|
|
}
|
|
|
|
final scope = applyToSimilar.isEmpty ? [tx] : applyToSimilar;
|
|
final nextById = Map<String, TxMeta>.of(_byId);
|
|
for (final other in scope) {
|
|
if (applyToSimilar.isNotEmpty &&
|
|
other.merchantKey != tx.merchantKey) {
|
|
continue;
|
|
}
|
|
final current = metaFor(other);
|
|
nextById[other.id] = unique.isEmpty
|
|
? current.copyWith(clearLabels: true)
|
|
: current.copyWith(labelIds: unique);
|
|
}
|
|
_byId = nextById;
|
|
|
|
final nextRules = Map<String, List<String>>.of(_labelsByMerchant);
|
|
if (unique.isEmpty) {
|
|
nextRules.remove(tx.merchantKey);
|
|
nextRules.remove(tx.descriptionKey);
|
|
} else {
|
|
nextRules[tx.merchantKey] = unique;
|
|
}
|
|
_labelsByMerchant = nextRules;
|
|
await _persist();
|
|
}
|
|
|
|
Future<void> toggleLabel(
|
|
BankTransaction tx,
|
|
String labelId, {
|
|
List<BankTransaction> applyToSimilar = const [],
|
|
}) async {
|
|
final current = List<String>.of(metaFor(tx).labelIds);
|
|
if (current.contains(labelId)) {
|
|
current.remove(labelId);
|
|
} else {
|
|
current.add(labelId);
|
|
}
|
|
await setLabels(tx, current, applyToSimilar: applyToSimilar);
|
|
}
|
|
|
|
Future<void> clearLabels(
|
|
BankTransaction tx, {
|
|
List<BankTransaction> applyToSimilar = const [],
|
|
}) {
|
|
return setLabels(tx, const [], applyToSimilar: applyToSimilar);
|
|
}
|
|
|
|
Future<TxLabel> createLabel(String name) async {
|
|
final trimmed = name.trim();
|
|
if (trimmed.isEmpty) {
|
|
throw ArgumentError('Label name required');
|
|
}
|
|
final color =
|
|
kCustomLabelColors[_customLabels.length % kCustomLabelColors.length];
|
|
final label = TxLabel(
|
|
id: 'custom_${DateTime.now().millisecondsSinceEpoch}',
|
|
name: trimmed,
|
|
color: color,
|
|
icon: Icons.label_outline,
|
|
custom: true,
|
|
);
|
|
_customLabels = [..._customLabels, label];
|
|
await _persist();
|
|
return label;
|
|
}
|
|
|
|
Future<void> removeLabel(String labelId) async {
|
|
_customLabels =
|
|
_customLabels.where((label) => label.id != labelId).toList();
|
|
final nextById = <String, TxMeta>{};
|
|
for (final entry in _byId.entries) {
|
|
if (entry.value.labelIds.contains(labelId)) {
|
|
final next = entry.value.labelIds.where((id) => id != labelId).toList();
|
|
nextById[entry.key] = next.isEmpty
|
|
? entry.value.copyWith(clearLabels: true)
|
|
: entry.value.copyWith(labelIds: next);
|
|
} else {
|
|
nextById[entry.key] = entry.value;
|
|
}
|
|
}
|
|
_byId = nextById;
|
|
_labelsByMerchant = {
|
|
for (final entry in _labelsByMerchant.entries)
|
|
if (entry.value.any((id) => id != labelId))
|
|
entry.key: [
|
|
for (final id in entry.value)
|
|
if (id != labelId) id,
|
|
],
|
|
};
|
|
await _persist();
|
|
}
|
|
|
|
Future<void> setRecurring(BankTransaction tx, bool recurring) async {
|
|
final current = metaFor(tx);
|
|
_byId = {
|
|
..._byId,
|
|
tx.id: current.copyWith(recurring: recurring),
|
|
};
|
|
final existing = _exactTemplates[tx.exactKey] ?? const TxExactTemplate();
|
|
_exactTemplates = {
|
|
..._exactTemplates,
|
|
tx.exactKey: TxExactTemplate(
|
|
notes: existing.notes.isNotEmpty ? existing.notes : current.notes,
|
|
recurring: recurring,
|
|
),
|
|
};
|
|
await _persist();
|
|
}
|
|
|
|
Future<void> setNotes(
|
|
BankTransaction tx,
|
|
String notes, {
|
|
List<BankTransaction> applyToSimilar = const [],
|
|
}) async {
|
|
final trimmed = notes.trim();
|
|
final scope = applyToSimilar.isEmpty ? [tx] : applyToSimilar;
|
|
final nextById = Map<String, TxMeta>.of(_byId);
|
|
for (final other in scope) {
|
|
if (applyToSimilar.isNotEmpty &&
|
|
other.merchantKey != tx.merchantKey) {
|
|
continue;
|
|
}
|
|
final current = metaFor(other);
|
|
nextById[other.id] = current.copyWith(notes: trimmed);
|
|
}
|
|
_byId = nextById;
|
|
|
|
if (applyToSimilar.isEmpty) {
|
|
final current = metaFor(tx);
|
|
final existing = _exactTemplates[tx.exactKey] ?? const TxExactTemplate();
|
|
if (trimmed.isEmpty && !existing.recurring && !current.recurring) {
|
|
_exactTemplates = Map.of(_exactTemplates)..remove(tx.exactKey);
|
|
} else {
|
|
_exactTemplates = {
|
|
..._exactTemplates,
|
|
tx.exactKey: TxExactTemplate(
|
|
notes: trimmed,
|
|
recurring: existing.recurring || current.recurring,
|
|
),
|
|
};
|
|
}
|
|
if (trimmed.isEmpty) {
|
|
_notesByMerchant = Map.of(_notesByMerchant)
|
|
..remove(tx.merchantKey)
|
|
..remove(tx.descriptionKey);
|
|
}
|
|
} else {
|
|
if (trimmed.isEmpty) {
|
|
_notesByMerchant = Map.of(_notesByMerchant)
|
|
..remove(tx.merchantKey)
|
|
..remove(tx.descriptionKey);
|
|
} else {
|
|
_notesByMerchant = {
|
|
..._notesByMerchant,
|
|
tx.merchantKey: trimmed,
|
|
};
|
|
}
|
|
}
|
|
await _persist();
|
|
}
|
|
|
|
Future<void> toggleRecurring(BankTransaction tx) {
|
|
return setRecurring(tx, !metaFor(tx).recurring);
|
|
}
|
|
|
|
/// Search description, notes, label name, and date.
|
|
List<BankTransaction> search(
|
|
List<BankTransaction> txs,
|
|
String query, {
|
|
Set<String> labelIds = const {},
|
|
}) {
|
|
final needle = query.trim().toLowerCase();
|
|
final hasText = needle.isNotEmpty;
|
|
final hasLabels = labelIds.isNotEmpty;
|
|
if (!hasText && !hasLabels) return txs;
|
|
|
|
return txs.where((tx) {
|
|
final meta = metaFor(tx);
|
|
if (hasLabels && !meta.labelIds.any(labelIds.contains)) {
|
|
return false;
|
|
}
|
|
if (!hasText) return true;
|
|
final labelNames = labelsFor(meta).map((l) => l.name.toLowerCase());
|
|
return tx.description.toLowerCase().contains(needle) ||
|
|
meta.notes.toLowerCase().contains(needle) ||
|
|
labelNames.any((name) => name.contains(needle)) ||
|
|
tx.date.toLowerCase().contains(needle) ||
|
|
tx.amount.toString().contains(needle);
|
|
}).toList(growable: false);
|
|
}
|
|
|
|
/// Labels currently used by [transactions].
|
|
List<TxLabel> usedLabels(List<BankTransaction> transactions) {
|
|
final found = <String>{};
|
|
for (final tx in transactions) {
|
|
found.addAll(metaFor(tx).labelIds);
|
|
}
|
|
final list = [
|
|
for (final label in allLabels)
|
|
if (found.contains(label.id)) label,
|
|
];
|
|
list.sort((a, b) => a.name.compareTo(b.name));
|
|
return list;
|
|
}
|
|
|
|
Future<void> _persist() async {
|
|
notifyListeners();
|
|
await _storage.saveTxMetaStore(
|
|
TxMetaStoreData(
|
|
byId: _byId,
|
|
labelsByMerchant: _labelsByMerchant,
|
|
notesByMerchant: _notesByMerchant,
|
|
exactTemplates: _exactTemplates,
|
|
customLabels: _customLabels,
|
|
),
|
|
);
|
|
}
|
|
|
|
/// Absolute spend (outflows) per label. Multi-label txs count fully in each.
|
|
Map<String, double> spendByLabel(List<BankTransaction> txs) {
|
|
final totals = <String, double>{};
|
|
for (final tx in txs) {
|
|
if (tx.amount >= 0) continue;
|
|
final ids = metaFor(tx).labelIds;
|
|
if (ids.isEmpty) continue;
|
|
final amount = tx.amount.abs();
|
|
for (final id in ids) {
|
|
totals[id] = (totals[id] ?? 0) + amount;
|
|
}
|
|
}
|
|
return totals;
|
|
}
|
|
|
|
/// Unique labeled outflow total (no double-count for multi-label txs).
|
|
double labeledSpendTotal(List<BankTransaction> txs) {
|
|
var total = 0.0;
|
|
for (final tx in txs) {
|
|
if (tx.amount >= 0) continue;
|
|
if (!metaFor(tx).hasLabel) continue;
|
|
total += tx.amount.abs();
|
|
}
|
|
return total;
|
|
}
|
|
|
|
/// Absolute spend for each day in [month] (`yyyy-MM-dd` → amount).
|
|
Map<String, double> spendByDayInMonth(
|
|
List<BankTransaction> txs,
|
|
DateTime month,
|
|
) {
|
|
final start = DateTime(month.year, month.month, 1);
|
|
final end = DateTime(month.year, month.month + 1, 0);
|
|
final totals = <String, double>{};
|
|
for (var day = 1; day <= end.day; day++) {
|
|
final key =
|
|
'${start.year}-${start.month.toString().padLeft(2, '0')}-${day.toString().padLeft(2, '0')}';
|
|
totals[key] = 0;
|
|
}
|
|
for (final tx in txs) {
|
|
if (tx.amount >= 0) continue;
|
|
final parsed = DateTime.tryParse(tx.date);
|
|
if (parsed == null) continue;
|
|
if (parsed.year != month.year || parsed.month != month.month) continue;
|
|
final key =
|
|
'${parsed.year}-${parsed.month.toString().padLeft(2, '0')}-${parsed.day.toString().padLeft(2, '0')}';
|
|
totals[key] = (totals[key] ?? 0) + tx.amount.abs();
|
|
}
|
|
return totals;
|
|
}
|
|
}
|