@marcos_feitoza/personal-finance-frontend-feature-management 1.0.0

package/.circleci/config.yml

@@ -0,0 +1,23 @@
+version: 2.1
+
+jobs:
+  release:
+    docker:
+      - image: circleci/node:latest
+    steps:
+      - checkout
+      - run:
+          name: Install dependencies
+          command: npm install
+      - run:
+          name: Run semantic-release
+          command: npx semantic-release
+
+workflows:
+  build-and-release:
+    jobs:
+      - release:
+          filters:
+            branches:
+              only:
+                - main

package/.metadata

@@ -0,0 +1,10 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled and should not be manually edited.
+
+version:
+  revision: "fcf2c11572af6f390246c056bc905eca609533a0"
+  channel: "stable"
+
+project_type: package

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# 1.0.0 (2025-11-28)
+
+
+### Bug Fixes
+
+* add currency class ([c01940f](https://github.com/MarcosOps/personal-finance-frontend-feature-management/commit/c01940fae5b08c97e843bba46a15c3d443282be6))
+* add ignore and more estilo ([82c1c33](https://github.com/MarcosOps/personal-finance-frontend-feature-management/commit/82c1c3353dbe78fc4936e2ec679ac146d46b56e9))
+
+
+### Features
+
+* update readme.me ([de994b3](https://github.com/MarcosOps/personal-finance-frontend-feature-management/commit/de994b3f66d78329ff15d44a7c9225c8ec9f3073))
+
+## 0.0.1
+
+* TODO: Describe initial release.

package/LICENSE

@@ -0,0 +1 @@
+TODO: Add your license here.

package/README.md

@@ -0,0 +1,31 @@
+# Feature: Gerenciamento (Frontend Flutter)
+
+Este pacote contém a implementação das telas para gerenciamento detalhado de transações e para o processo de conciliação na aplicação Personal Finance Frontend.
+
+## Propósito
+
+O objetivo deste pacote é fornecer ao usuário ferramentas para revisar, editar e deletar transações, bem como para realizar a conciliação de contas, garantindo a exatidão dos registros financeiros.
+
+## Conteúdo Principal
+
+-   **`lib/screens/manage_transactions_screen.dart`**: Tela para visualizar, editar e deletar transações individuais.
+-   **`lib/screens/reconciliation_screen.dart`**: Tela dedicada ao processo de conciliação de contas.
+
+---
+
+## Como Usar (Instalação como Dependência)
+
+Este pacote é uma dependência local para a aplicação principal (`personal-finance-frontend`).
+
+No `pubspec.yaml` da aplicação principal, adicione a seguinte linha em `dependencies`:
+
+```yaml
+personal_finance_frontend_feature_management:
+  path: ../personal-finance-frontend-feature-management
+```
+
+## Features
+
+-   **Gestão de Transações**: Permite ao usuário visualizar um histórico completo de transações, com opções de edição e exclusão.
+-   **Conciliação de Contas**: Oferece um fluxo guiado para conciliar transações com extratos bancários, identificando e corrigindo discrepâncias.
+-   **Filtros Avançados**: Ferramentas para filtrar transações por tipo, método de pagamento, data, etc.

package/analysis_options.yaml

@@ -0,0 +1,4 @@
+include: package:flutter_lints/flutter.yaml
+
+# Additional information about this file can be found at
+# https://dart.dev/guides/language/analysis-options

package/lib/personal_finance_frontend_feature_management.dart

@@ -0,0 +1,5 @@
+/// A Calculator.
+class Calculator {
+  /// Returns [value] plus 1.
+  int addOne(int value) => value + 1;
+}

package/lib/screens/manage_transactions_screen.dart

@@ -0,0 +1,307 @@
+import 'package:flutter/material.dart';
+import 'package:intl/intl.dart';
+import 'package:provider/provider.dart';
+import '../viewmodels/manage_transactions_viewmodel.dart';
+import 'package:personal_finance_frontend_core_ui/widgets/edit_transaction_dialog.dart';
+import 'package:personal_finance_frontend_core_ui/widgets/app_widgets.dart';
+import 'package:personal_finance_frontend_core_services/models/payment_method.dart';
+import 'package:personal_finance_frontend_core_services/providers/auth_provider.dart';
+
+class ManageTransactionsScreen extends StatelessWidget {
+  const ManageTransactionsScreen({Key? key}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    final authProvider = Provider.of<AuthProvider>(context, listen: false);
+
+    return ChangeNotifierProvider(
+      create: (_) => ManageTransactionsViewModel(token: authProvider.token),
+      child: Scaffold(
+        appBar: AppBar(
+          title: const Text('Manage Transactions'),
+          actions: [
+            Consumer<ManageTransactionsViewModel>(
+              builder: (context, viewModel, child) {
+                return IconButton(
+                  icon: const Icon(Icons.delete),
+                  onPressed: viewModel.selectedTransactionIds.isEmpty
+                      ? null
+                      : () {
+                          showDialog(
+                            context: context,
+                            builder: (BuildContext context) {
+                              return AlertDialog(
+                                title: const Text('Delete Transactions'),
+                                content: Text(
+                                    'Are you sure you want to delete ${viewModel.selectedTransactionIds.length} transaction(s)?'),
+                                actions: <Widget>[
+                                  TextButton(
+                                    child: const Text('Cancel'),
+                                    onPressed: () {
+                                      Navigator.of(context).pop();
+                                    },
+                                  ),
+                                  TextButton(
+                                    child: const Text('Delete'),
+                                    onPressed: () {
+                                      viewModel.deleteSelectedTransactions();
+                                      Navigator.of(context).pop();
+                                    },
+                                  ),
+                                ],
+                              );
+                            },
+                          );
+                        },
+                );
+              },
+            ),
+          ],
+        ),
+        body: Consumer<ManageTransactionsViewModel>(
+          builder: (context, viewModel, child) {
+            if (viewModel.isLoading) {
+              return const Center(child: CircularProgressIndicator());
+            }
+            if (viewModel.errorMessage.isNotEmpty) {
+              return Center(child: Text(viewModel.errorMessage));
+            }
+            return Column(
+              children: [
+                _buildFilters(context, viewModel),
+                Expanded(
+                  child: SingleChildScrollView(
+                    child: DataTable(
+                      columns: const [
+                        DataColumn(label: Text('Select')),
+                        DataColumn(label: Text('Date')),
+                        DataColumn(label: Text('Category')),
+                        DataColumn(label: Text('Subcategory')),
+                        DataColumn(label: Text('Method')),
+                        DataColumn(label: Text('Amount')),
+                        DataColumn(label: Text('Description')),
+                        DataColumn(label: Text('Paid')), // Added Paid column
+                        DataColumn(label: Text('Actions')),
+                      ],
+                      rows: viewModel.transactions.map((transaction) {
+                        return DataRow(
+                          selected: viewModel.selectedTransactionIds
+                              .contains(transaction.id),
+                          onSelectChanged: (isSelected) {
+                            viewModel
+                                .toggleTransactionSelection(transaction.id);
+                          },
+                          cells: [
+                            DataCell(Checkbox(
+                              value: viewModel.selectedTransactionIds
+                                  .contains(transaction.id),
+                              onChanged: (isSelected) {
+                                viewModel
+                                    .toggleTransactionSelection(transaction.id);
+                              },
+                            )),
+                            DataCell(Text(DateFormat('yyyy-MM-dd')
+                                .format(transaction.date))),
+                            DataCell(Text(transaction.category)),
+                            DataCell(Text(transaction.subcategory)),
+                            DataCell(Text(transaction.paymentMethod)),
+                            DataCell(Text(NumberFormat.currency(
+                                    locale: 'en_CA', symbol: '\$')
+                                .format(transaction.amount))),
+                            DataCell(Text(transaction.description)),
+                            DataCell(Switch( // Added Switch for Paid status
+                              value: transaction.isPaid,
+                              onChanged: (bool newValue) {
+                                print('Switch onChanged: transaction.id=${transaction.id}, newValue=$newValue'); // Added log
+                                viewModel.updateTransactionPaidStatus(transaction.id, newValue);
+                              },
+                            )),
+                            DataCell(IconButton(
+                              icon: const Icon(Icons.edit),
+                              onPressed: () {
+                                showDialog(
+                                  context: context,
+                                  builder: (BuildContext context) {
+                                    return EditTransactionDialog(
+                                      transaction: transaction,
+                                      viewModel: viewModel,
+                                    );
+                                  },
+                                );
+                              },
+                            )),
+                          ],
+                        );
+                      }).toList(),
+                    ),
+                  ),
+                ),
+              ],
+            );
+          },
+        ),
+      ),
+    );
+  }
+
+  // Show Year Dialog
+  void _showYearFilter(BuildContext context, ManageTransactionsViewModel viewModel) async {
+    final selected = await showDialog<int>(
+      context: context,
+      builder: (context) => SimpleDialog(
+        title: const Text('Select Year'),
+        children: [
+          SimpleDialogOption(
+            onPressed: () => Navigator.pop(context, null),
+            child: const Text('All'),
+          ),
+          ...viewModel.availableYears.map((year) => SimpleDialogOption(
+                onPressed: () => Navigator.pop(context, year),
+                child: Text(year.toString()),
+              )),
+        ],
+      ),
+    );
+    viewModel.setSelectedYear(selected);
+  }
+
+  // Show Month Dialog
+  void _showMonthFilter(BuildContext context, ManageTransactionsViewModel viewModel) async {
+    final selected = await showDialog<int>(
+      context: context,
+      builder: (context) => SimpleDialog(
+        title: const Text('Select Month'),
+        children: viewModel.availableMonths.map((month) {
+          final text = month == null ? 'All' : DateFormat.MMM().format(DateTime(0, month));
+          return SimpleDialogOption(
+            onPressed: () => Navigator.pop(context, month),
+            child: Text(text),
+          );
+        }).toList(),
+      ),
+    );
+    viewModel.setSelectedMonth(selected);
+  }
+
+  // Show Category Dialog
+  void _showCategoryFilter(BuildContext context, ManageTransactionsViewModel viewModel) async {
+    final selected = await showDialog<String>(
+      context: context,
+      builder: (context) => SimpleDialog(
+        title: const Text('Select Category'),
+        children: viewModel.availableCategories.map((cat) {
+          return SimpleDialogOption(
+            onPressed: () => Navigator.pop(context, cat == 'All' ? null : cat),
+            child: Text(cat),
+          );
+        }).toList(),
+      ),
+    );
+    viewModel.setSelectedCategory(selected);
+  }
+
+  // Show Subcategory Dialog
+  void _showSubcategoryFilter(BuildContext context, ManageTransactionsViewModel viewModel) async {
+    final selected = await showDialog<String>(
+      context: context,
+      builder: (context) => SimpleDialog(
+        title: const Text('Select Subcategory'),
+        children: viewModel.availableSubcategories.map((sub) {
+          return SimpleDialogOption(
+            onPressed: () => Navigator.pop(context, sub == 'All' ? null : sub),
+            child: Text(sub),
+          );
+        }).toList(),
+      ),
+    );
+    viewModel.setSelectedSubcategory(selected);
+  }
+
+  // Show Payment Method Dialog
+  void _showPaymentMethodFilter(BuildContext context, ManageTransactionsViewModel viewModel) async {
+    final selected = await showDialog<String>(
+      context: context,
+      builder: (context) => SimpleDialog(
+        title: const Text('Select Payment Method'),
+        children: viewModel.availablePaymentMethods.map((method) {
+          final text = method == null ? 'All' : paymentMethodToString(paymentMethodFromString(method));
+          return SimpleDialogOption(
+            onPressed: () => Navigator.pop(context, method),
+            child: Text(text),
+          );
+        }).toList(),
+      ),
+    );
+    viewModel.setSelectedPaymentMethod(selected);
+  }
+
+  Widget _buildFilters(
+      BuildContext context, ManageTransactionsViewModel viewModel) {
+    String formatMonth(int? month) =>
+        month == null ? 'All' : DateFormat.MMM().format(DateTime(0, month));
+
+    return AppFormCard(
+      title: 'Filters',
+      child: Column(
+        children: [
+          Row(
+            children: [
+              Expanded(
+                child: FilterButton(
+                  label: 'Year:',
+                  value: viewModel.selectedYear?.toString() ?? 'All',
+                  onPressed: () => _showYearFilter(context, viewModel),
+                ),
+              ),
+              const SizedBox(width: 16),
+              Expanded(
+                child: FilterButton(
+                  label: 'Month:',
+                  value: formatMonth(viewModel.selectedMonth),
+                  onPressed: () => _showMonthFilter(context, viewModel),
+                ),
+              ),
+            ],
+          ),
+          const SizedBox(height: 8),
+          Row(
+            children: [
+              Expanded(
+                child: FilterButton(
+                  label: 'Category:',
+                  value: viewModel.selectedCategory ?? 'All',
+                  onPressed: () => _showCategoryFilter(context, viewModel),
+                ),
+              ),
+              const SizedBox(width: 16),
+              Expanded(
+                child: FilterButton(
+                  label: 'Subcategory:',
+                  value: viewModel.selectedSubcategory ?? 'All',
+                  onPressed: () => _showSubcategoryFilter(context, viewModel),
+                ),
+              ),
+            ],
+          ),
+          const SizedBox(height: 8),
+          FilterButton(
+            label: 'Method:',
+            value: viewModel.selectedPaymentMethod != null
+                ? paymentMethodToString(
+                    paymentMethodFromString(viewModel.selectedPaymentMethod!))
+                : 'All',
+            onPressed: () => _showPaymentMethodFilter(context, viewModel),
+          ),
+          const SizedBox(height: 16),
+          Align(
+            alignment: Alignment.centerRight,
+            child: TextButton(
+              onPressed: viewModel.clearFilters,
+              child: const Text('Clear Filters'),
+            ),
+          )
+        ],
+      ),
+    );
+  }
+}

package/lib/screens/reconciliation_screen.dart

@@ -0,0 +1,335 @@
+import 'package:flutter/material.dart';
+import 'package:personal_finance_frontend_core_services/services/transaction_service.dart';
+import 'package:intl/intl.dart';
+import 'package:personal_finance_frontend_core_services/models/payment_method.dart';
+import 'package:personal_finance_frontend_core_ui/widgets/app_widgets.dart';
+import 'package:provider/provider.dart';
+import 'package:personal_finance_frontend_core_services/providers/auth_provider.dart';
+
+class ReconciliationScreen extends StatefulWidget {
+  final String paymentMethod;
+
+  const ReconciliationScreen({Key? key, required this.paymentMethod})
+      : super(key: key);
+
+  @override
+  _ReconciliationScreenState createState() => _ReconciliationScreenState();
+}
+
+class _ReconciliationScreenState extends State<ReconciliationScreen> {
+  final TransactionService _transactionService = TransactionService();
+  List<Map<String, dynamic>> _unpaidTransactions = [];
+  List<String> _availablePaymentMethods = []; // To hold dynamic payment methods
+  Set<int> _selectedIds = {};
+  double _selectedTotal = 0.0;
+  bool _isLoading = true;
+  String? _token;
+
+  DateTime? _startDate;
+  DateTime? _endDate;
+  String? _selectedPaymentMethod;
+
+  @override
+  void initState() {
+    super.initState();
+    _selectedPaymentMethod =
+        widget.paymentMethod.isNotEmpty ? widget.paymentMethod.toUpperCase() : null;
+    
+    // Get token from AuthProvider
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      final authProvider = Provider.of<AuthProvider>(context, listen: false);
+      setState(() {
+        _token = authProvider.token;
+      });
+      _fetchInitialData();
+    });
+  }
+
+  Future<void> _fetchInitialData() async {
+    if (_selectedPaymentMethod != null) {
+      await _fetchUnpaidTransactions();
+    } else {
+      await _fetchAvailablePaymentMethods();
+    }
+  }
+
+  Future<void> _fetchAvailablePaymentMethods() async {
+    setState(() {
+      _isLoading = true;
+    });
+    final summary = await _transactionService.getSummaryByPaymentMethod(token: _token);
+    setState(() {
+      _availablePaymentMethods = summary.map((s) => s['payment_method'] as String).toList();
+      if (_selectedPaymentMethod != null && !_availablePaymentMethods.contains(_selectedPaymentMethod)) {
+        _selectedPaymentMethod = null; // Clear selection if not in the new list
+      }
+      _isLoading = false;
+    });
+  }
+
+  String currencySymbol = r'$'; // ou poderia vir de configuração, API, etc.
+
+  String _formatCurrency(double value) {
+    return '$currencySymbol${value.toStringAsFixed(2)}';
+  }
+
+  Future<void> _fetchUnpaidTransactions() async {
+    setState(() {
+      _isLoading = true;
+    });
+    final transactions = await _transactionService.fetchTransactions(
+      paymentMethod: _selectedPaymentMethod?.toUpperCase(),
+      isPaid: false,
+      startDate: _startDate,
+      endDate: _endDate,
+      token: _token,
+    );
+    setState(() {
+      _unpaidTransactions = transactions;
+      _isLoading = false;
+    });
+  }
+
+  void _onTransactionSelected(
+      bool? selected, Map<String, dynamic> transaction) {
+    final int transactionId = transaction['id'];
+    setState(() {
+      if (selected == true) {
+        _selectedIds.add(transactionId);
+      } else {
+        _selectedIds.remove(transactionId);
+      }
+      _recalculateTotal();
+    });
+  }
+
+  void _recalculateTotal() {
+    _selectedTotal = 0;
+    for (int id in _selectedIds) {
+      final transaction = _unpaidTransactions.firstWhere((t) => t['id'] == id);
+      final double amount = double.parse(transaction['amount'].toString());
+      final String type = transaction['type'];
+      _selectedTotal += type == 'debit' ? amount : -amount;
+    }
+  }
+
+  Future<void> _reconcile() async {
+    if (_selectedIds.isEmpty) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(
+            content: Text('Please select transactions to reconcile.')),
+      );
+      return;
+    }
+
+    if (_selectedPaymentMethod == null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(content: Text('Please select a payment method.')),
+      );
+      return;
+    }
+
+    final newBalance = await _transactionService.reconcileTransactions(
+      _selectedIds.toList(),
+      _selectedPaymentMethod!,
+      _selectedTotal,
+      token: _token,
+    );
+
+    if (newBalance != null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(content: Text('Reconciliation successful!')),
+      );
+      Navigator.of(context).pop(true); // Pop with a success result
+    } else {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(
+            content: Text('Reconciliation failed. Please try again.')),
+      );
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text('Reconcile Transactions'),
+        actions: [
+          Center(
+            child: Padding(
+              padding: const EdgeInsets.only(right: 8.0),
+              child: Text(
+                'Total: ${_formatCurrency(_selectedTotal)}',
+                style: const TextStyle(fontSize: 18),
+              ),
+            ),
+          ),
+          IconButton(
+            icon: const Icon(Icons.check),
+            onPressed: _selectedPaymentMethod == null ? null : _reconcile,
+            tooltip: 'Mark as Paid',
+          ),
+        ],
+      ),
+      body: Column(
+        children: [
+          _buildFilters(),
+          Expanded(
+            child: _isLoading
+                ? const Center(child: CircularProgressIndicator())
+                : _unpaidTransactions.isEmpty
+                    ? const Center(child: Text('No unpaid transactions found.'))
+                    : SingleChildScrollView(
+                        scrollDirection: Axis.vertical,
+                        child: DataTable(
+                          columns: const [
+                            DataColumn(label: Text('Select')),
+                            DataColumn(label: Text('Date')),
+                            DataColumn(label: Text('Subcategory')),
+                            DataColumn(label: Text('Method')),
+                            DataColumn(label: Text('Amount')),
+                          ],
+                          rows: _unpaidTransactions.map((transaction) {
+                            final transactionId = transaction['id'] as int;
+                            final amount = double.parse(transaction['amount'].toString());
+                            return DataRow(
+                              cells: [
+                                DataCell(Checkbox(
+                                  value: _selectedIds.contains(transactionId),
+                                  onChanged: _selectedPaymentMethod == null
+                                      ? null
+                                      : (bool? selected) {
+                                          _onTransactionSelected(
+                                              selected, transaction);
+                                        },
+                                )),
+                                DataCell(Text(DateFormat('yyyy-MM-dd').format(
+                                    DateTime.parse(transaction['date'])))),
+                                DataCell(Text(transaction['subcategory'] ??
+                                    'No subcategory')),
+                                DataCell(Text(
+                                    transaction['payment_method'] ?? 'N/A')),
+                                DataCell(Text(
+                                  '${_formatCurrency(amount)}',
+                                  style: TextStyle(
+                                    color: transaction['type'] == 'debit'
+                                        ? Colors.red
+                                        : Colors.green,
+                                    fontWeight: FontWeight.bold,
+                                  ),
+                                )),
+                              ],
+                            );
+                          }).toList(),
+                        ),
+                      ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _clearFilters() {
+    setState(() {
+      // Can't fully clear payment method if it was passed via widget
+      if (widget.paymentMethod.isEmpty) {
+        _selectedPaymentMethod = null;
+      }
+      _startDate = null;
+      _endDate = null;
+      _selectedIds.clear();
+      _recalculateTotal();
+    });
+    _fetchUnpaidTransactions();
+  }
+
+  Future<void> _selectDate(BuildContext context, bool isStartDate) async {
+    final DateTime? picked = await showDatePicker(
+      context: context,
+      initialDate: (isStartDate ? _startDate : _endDate) ?? DateTime.now(),
+      firstDate: DateTime(2000),
+      lastDate: DateTime(2101),
+    );
+    if (picked != null) {
+      setState(() {
+        if (isStartDate) {
+          _startDate = picked;
+        } else {
+          _endDate = picked;
+        }
+      });
+      _fetchUnpaidTransactions();
+    }
+  }
+
+  void _showPaymentMethodDialog(BuildContext context) async {
+    final selected = await showDialog<String>(
+      context: context,
+      builder: (context) => SimpleDialog(
+        title: const Text('Select Payment Method'),
+        children: _availablePaymentMethods.map((method) {
+          return SimpleDialogOption(
+            onPressed: () => Navigator.pop(context, method),
+            child: Text(method.toUpperCase()),
+          );
+        }).toList(),
+      ),
+    );
+    if (selected != null) {
+      setState(() {
+        _selectedPaymentMethod = selected;
+      });
+      _fetchUnpaidTransactions();
+    }
+  }
+
+  Widget _buildFilters() {
+    return AppFormCard(
+      title: 'Filters',
+      child: Column(
+        children: [
+          // Only show payment method filter if it wasn't passed via constructor
+          if (widget.paymentMethod.isEmpty) ...[
+            FilterButton(
+              label: 'Method:',
+              value: _selectedPaymentMethod?.toUpperCase() ?? 'None',
+              onPressed: () => _showPaymentMethodDialog(context),
+            ),
+            const SizedBox(height: 8),
+          ],
+          Row(
+            children: [
+              Expanded(
+                child: FilterButton(
+                  label: 'Start:',
+                  value: _startDate == null
+                      ? 'None'
+                      : DateFormat('yyyy-MM-dd').format(_startDate!),
+                  onPressed: () => _selectDate(context, true),
+                ),
+              ),
+              const SizedBox(width: 16),
+              Expanded(
+                child: FilterButton(
+                  label: 'End:',
+                  value: _endDate == null
+                      ? 'None'
+                      : DateFormat('yyyy-MM-dd').format(_endDate!),
+                  onPressed: () => _selectDate(context, false),
+                ),
+              ),
+            ],
+          ),
+          const SizedBox(height: 16),
+          Align(
+            alignment: Alignment.centerRight,
+            child: TextButton(
+              onPressed: _clearFilters,
+              child: const Text('Clear Filters'),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

package/lib/viewmodels/manage_transactions_viewmodel.dart

@@ -0,0 +1,291 @@
+import 'package:flutter/material.dart';
+import 'package:intl/intl.dart';
+import 'package:personal_finance_frontend_core_services/services/transaction_service.dart';
+import 'package:personal_finance_frontend_core_services/models/payment_method.dart';
+
+class Transaction {
+  final int id;
+  final String type;
+  final String category;
+  final String subcategory;
+  final double amount;
+  final String description;
+  final DateTime date;
+  final String paymentMethod;
+  final bool isPaid; // Added isPaid
+
+  Transaction({
+    required this.id,
+    required this.type,
+    required this.category,
+    required this.subcategory,
+    required this.amount,
+    required this.description,
+    required this.date,
+    required this.paymentMethod,
+    required this.isPaid, // Added isPaid
+  });
+
+  factory Transaction.fromJson(Map<String, dynamic> json) {
+    return Transaction(
+      id: json['id'],
+      type: json['type'],
+      category: json['category'],
+      subcategory: json['subcategory'] ?? '',
+      amount: double.parse(json['amount'].toString()),
+      description: json['description'] ?? '',
+      date: DateTime.parse(json['date']),
+      paymentMethod: json['payment_method'] ?? '',
+      isPaid: json['is_paid'] ?? false, // Added isPaid
+    );
+  }
+}
+
+class ManageTransactionsViewModel extends ChangeNotifier {
+  final TransactionService _transactionService = TransactionService();
+  final String? _token;
+
+  List<Transaction> _allTransactions = [];
+  List<Transaction> _transactions = [];
+  List<Transaction> get transactions => _transactions;
+
+  bool _isLoading = false;
+  bool get isLoading => _isLoading;
+
+  String _errorMessage = '';
+  String get errorMessage => _errorMessage;
+
+  Set<int> _selectedTransactionIds = {};
+  Set<int> get selectedTransactionIds => _selectedTransactionIds;
+
+  // Filter properties
+  int? _selectedYear;
+  int? _selectedMonth;
+  String? _selectedCategory;
+  String? _selectedSubcategory;
+  String? _selectedPaymentMethod;
+
+  int? get selectedYear => _selectedYear;
+  int? get selectedMonth => _selectedMonth;
+  String? get selectedCategory => _selectedCategory;
+  String? get selectedSubcategory => _selectedSubcategory;
+  String? get selectedPaymentMethod => _selectedPaymentMethod;
+
+  List<int> get availableYears {
+    if (_allTransactions.isEmpty) return [DateTime.now().year];
+    final years = _allTransactions.map((t) => t.date.year).toSet().toList();
+    years.sort((a, b) => b.compareTo(a));
+    return years;
+  }
+
+  List<int?> get availableMonths => [null, ...List.generate(12, (i) => i + 1)];
+
+  List<String> get availableCategories {
+    final categories =
+        _allTransactions.map((t) => t.category.toUpperCase()).toSet().toList();
+    categories.sort();
+    return ['All', ...categories];
+  }
+
+  List<String> get availableSubcategories {
+    if (_selectedCategory == null || _selectedCategory == 'All') {
+      return ['All'];
+    }
+    final subcategories = _allTransactions
+        .where((t) => t.category.toUpperCase() == _selectedCategory)
+        .map((t) => t.subcategory)
+        .toSet()
+        .toList();
+    subcategories.sort();
+    return ['All', ...subcategories];
+  }
+
+  List<String?> get availablePaymentMethods {
+    return [null, ...PaymentMethod.values.map((e) => e.name).toList()];
+  }
+
+  ManageTransactionsViewModel({String? token}) : _token = token {
+    print("[LOG] ManageTransactionsViewModel: Initializing...");
+    _selectedYear = DateTime.now().year;
+    fetchTransactions();
+  }
+
+  void setSelectedYear(int? year) {
+    print("[LOG] setSelectedYear: New year = $year");
+    _selectedYear = year;
+    applyFilters();
+  }
+
+  void setSelectedMonth(int? month) {
+    print("[LOG] setSelectedMonth: New month = $month");
+    _selectedMonth = month;
+    applyFilters();
+  }
+
+  void setSelectedCategory(String? category) {
+    print("[LOG] setSelectedCategory: New category = $category");
+    _selectedCategory = category;
+    _selectedSubcategory = null; // Reset subcategory when category changes
+    applyFilters();
+  }
+
+  void setSelectedSubcategory(String? subcategory) {
+    print("[LOG] setSelectedSubcategory: New subcategory = $subcategory");
+    _selectedSubcategory = subcategory;
+    applyFilters();
+  }
+
+  void setSelectedPaymentMethod(String? paymentMethod) {
+    print("[LOG] setSelectedPaymentMethod: New payment method = $paymentMethod");
+    _selectedPaymentMethod = paymentMethod;
+    applyFilters();
+  }
+
+  void clearFilters() {
+    print("[LOG] clearFilters: Clearing all filters.");
+    _selectedYear = DateTime.now().year;
+    _selectedMonth = null;
+    _selectedCategory = null;
+    _selectedSubcategory = null;
+    _selectedPaymentMethod = null;
+    applyFilters(); // apply default filters
+  }
+
+  void toggleTransactionSelection(int id) {
+    if (_selectedTransactionIds.contains(id)) {
+      _selectedTransactionIds.remove(id);
+      print("[LOG] toggleTransactionSelection: Deselected transaction ID = $id");
+    } else {
+      _selectedTransactionIds.add(id);
+      print("[LOG] toggleTransactionSelection: Selected transaction ID = $id");
+    }
+    notifyListeners();
+  }
+
+  Future<void> fetchTransactions() async {
+    print("[LOG] fetchTransactions: Starting...");
+    _isLoading = true;
+    _errorMessage = '';
+    notifyListeners();
+
+    try {
+      final data = await _transactionService.fetchTransactions(token: _token);
+      _allTransactions = data.map((json) => Transaction.fromJson(json)).toList();
+      print("[LOG] fetchTransactions: Success - Fetched ${_allTransactions.length} transactions.");
+      applyFilters();
+    } catch (e) {
+      _errorMessage = 'Error fetching transactions: $e';
+      print("[LOG] fetchTransactions: FAILED - $e");
+    } finally {
+      _isLoading = false;
+      notifyListeners();
+    }
+  }
+
+  void applyFilters() {
+    print("[LOG] applyFilters: Applying filters...");
+    print("[LOG] applyFilters: Year=$_selectedYear, Month=$_selectedMonth, Category=$_selectedCategory, Subcategory=$_selectedSubcategory, Method=$_selectedPaymentMethod");
+    
+    List<Transaction> filtered = _allTransactions;
+
+    if (_selectedYear != null) {
+      filtered = filtered.where((t) => t.date.year == _selectedYear).toList();
+    }
+    if (_selectedMonth != null) {
+      filtered = filtered.where((t) => t.date.month == _selectedMonth).toList();
+    }
+    if (_selectedCategory != null && _selectedCategory != 'All') {
+      filtered = filtered
+          .where((t) => t.category.toUpperCase() == _selectedCategory)
+          .toList();
+    }
+    if (_selectedSubcategory != null && _selectedSubcategory != 'All') {
+      filtered = filtered
+          .where((t) => t.subcategory == _selectedSubcategory)
+          .toList();
+    }
+    if (_selectedPaymentMethod != null) {
+      filtered = filtered.where((t) => t.paymentMethod == _selectedPaymentMethod).toList();
+    }
+
+    _transactions = filtered;
+    print("[LOG] applyFilters: Found ${_transactions.length} transactions after filtering.");
+    notifyListeners();
+  }
+
+  Future<void> deleteSelectedTransactions() async {
+    if (_selectedTransactionIds.isEmpty) return;
+
+    print("[LOG] deleteSelectedTransactions: Starting deletion for IDs: $_selectedTransactionIds");
+    _isLoading = true;
+    notifyListeners();
+
+    try {
+      await _transactionService.deleteTransactions(_selectedTransactionIds.toList(), token: _token);
+      print("[LOG] deleteSelectedTransactions: Success.");
+      _selectedTransactionIds.clear();
+      await fetchTransactions(); // Refresh the list
+    } catch (e) {
+      _errorMessage = 'Error deleting transactions: $e';
+      print("[LOG] deleteSelectedTransactions: FAILED - $e");
+    } finally {
+      _isLoading = false;
+      notifyListeners();
+    }
+  }
+
+  Future<void> updateTransaction(int id, Map<String, dynamic> data) async {
+    print("[LOG] updateTransaction: Starting update for ID: $id with data: $data");
+    _isLoading = true;
+    notifyListeners();
+
+    try {
+      await _transactionService.updateTransaction(id, data, token: _token);
+      print("[LOG] updateTransaction: Success for ID: $id");
+      await fetchTransactions(); // Refresh the list
+    } catch (e) {
+      _errorMessage = 'Error updating transaction: $e';
+      print("[LOG] updateTransaction: FAILED for ID: $id - $e");
+    } finally {
+      _isLoading = false;
+      notifyListeners();
+    }
+  }
+
+  Future<void> updateTransactionPaidStatus(int id, bool isPaid) async {
+    print("[LOG] updateTransactionPaidStatus: Starting update for ID: $id with isPaid: $isPaid");
+    _isLoading = true;
+    notifyListeners();
+
+    try {
+      await _transactionService.updateTransaction(id, {'is_paid': isPaid}, token: _token);
+      print("[LOG] updateTransactionPaidStatus: Success for ID: $id");
+      
+      // Find the updated transaction in _allTransactions and update its isPaid status
+      int index = _allTransactions.indexWhere((t) => t.id == id);
+      if (index != -1) {
+        _allTransactions[index] = Transaction(
+          id: _allTransactions[index].id,
+          type: _allTransactions[index].type,
+          category: _allTransactions[index].category,
+          subcategory: _allTransactions[index].subcategory,
+          amount: _allTransactions[index].amount,
+          description: _allTransactions[index].description,
+          date: _allTransactions[index].date,
+          paymentMethod: _allTransactions[index].paymentMethod,
+          isPaid: isPaid, // Update isPaid status
+        );
+        print("[LOG] updateTransactionPaidStatus: Local state updated for ID: $id");
+      } else {
+        print("[LOG] updateTransactionPaidStatus: WARNING - Could not find transaction ID $id in local list to update status.");
+      }
+      applyFilters(); // Re-apply filters to update the displayed list
+    } catch (e) {
+      _errorMessage = 'Error updating transaction paid status: $e';
+      print("[LOG] updateTransactionPaidStatus: FAILED for ID: $id - $e");
+    } finally {
+      _isLoading = false;
+      notifyListeners();
+    }
+  }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@marcos_feitoza/personal-finance-frontend-feature-management",
+    "version": "1.0.0",
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "release": "semantic-release"
+    },
+    "devDependencies": {
+        "semantic-release": "^18.0.0",
+        "@semantic-release/changelog": "^6.0.0",
+        "@semantic-release/git": "^10.0.0",
+        "@semantic-release/github": "^8.0.0"
+    },
+    "release": {
+        "branches": [
+            "main"
+        ],
+        "plugins": [
+            "@semantic-release/commit-analyzer",
+            "@semantic-release/release-notes-generator",
+            "@semantic-release/changelog",
+            "@semantic-release/npm",
+            "@semantic-release/github",
+            "@semantic-release/git"
+        ]
+    }
+}

package/pubspec.yaml

@@ -0,0 +1,59 @@
+name: personal_finance_frontend_feature_management
+description: "A new Flutter package project."
+version: 0.0.1
+homepage:
+
+environment:
+  sdk: '>=2.19.0 <3.0.0'
+
+dependencies:
+  flutter:
+    sdk: flutter
+  intl: ^0.17.0
+  provider: ^6.0.0
+  personal_finance_frontend_core_services:
+    path: ../personal-finance-frontend-core-services
+  personal_finance_frontend_core_ui:
+    path: ../personal-finance-frontend-core-ui
+
+dev_dependencies:
+  flutter_test:
+    sdk: flutter
+  flutter_lints: ^5.0.0
+
+# For information on the generic Dart part of this file, see the
+# following page: https://dart.dev/tools/pub/pubspec
+
+# The following section is specific to Flutter packages.
+flutter:
+
+  # To add assets to your package, add an assets section, like this:
+  # assets:
+  #   - images/a_dot_burr.jpeg
+  #   - images/a_dot_ham.jpeg
+  #
+  # For details regarding assets in packages, see
+  # https://flutter.dev/to/asset-from-package
+  #
+  # An image asset can refer to one or more resolution-specific "variants", see
+  # https://flutter.dev/to/resolution-aware-images
+
+  # To add custom fonts to your package, add a fonts section here,
+  # in this "flutter" section. Each entry in this list should have a
+  # "family" key with the font family name, and a "fonts" key with a
+  # list giving the asset and other descriptors for the font. For
+  # example:
+  # fonts:
+  #   - family: Schyler
+  #     fonts:
+  #       - asset: fonts/Schyler-Regular.ttf
+  #       - asset: fonts/Schyler-Italic.ttf
+  #         style: italic
+  #   - family: Trajan Pro
+  #     fonts:
+  #       - asset: fonts/TrajanPro.ttf
+  #       - asset: fonts/TrajanPro_Bold.ttf
+  #         weight: 700
+  #
+  # For details regarding fonts in packages, see
+  # https://flutter.dev/to/font-from-package

package/test/personal_finance_frontend_feature_management_test.dart

@@ -0,0 +1,12 @@
+import 'package:flutter_test/flutter_test.dart';
+
+import 'package:personal_finance_frontend_feature_management/personal_finance_frontend_feature_management.dart';
+
+void main() {
+  test('adds one to input values', () {
+    final calculator = Calculator();
+    expect(calculator.addOne(2), 3);
+    expect(calculator.addOne(-7), -6);
+    expect(calculator.addOne(0), 1);
+  });
+}