Objectbox

Storage

The storage architecture of the application is designed to efficiently handle and persist transaction data locally using ObjectBox

Dependencies used in Storage

Objectbox

ObjectBox is an ACID compliant high-performance NoSQL database designed for mobile and IoT devices. It provides an object-oriented approach to data storage, allowing developers to interact with data using native objects rather than complex SQL queries. It has inbuilt support for relations, and has Queries to filter data as needed, even across relations! It has life easing schema migration which works like magic only on one command.

Path Provider:

Path Provider is a Flutter package that provides a platform-agnostic way to access commonly used locations on the file system, such as the documents directory and the temporary directory.

Overview of how it works

As previously mentioned, ObjectBox utilises an object-oriented approach to handle data

The following image summarises the architecture of ObjectBox

As previously mentioned, ObjectBox utilises an object-oriented approach to handle data

The following image summarises the architecture of ObjectBox

First define the model(s) as per your discreation. A model is defined as a class anoted with @Entity such as

@Entity
class Model{
    // Your model
}

This will contain info about the fields of the data, with their types, relationships to other models, if any. You can also define fucntions to return data as per your convenience (as we have done in our implementation).

Next run

$ flutter pub run build_runner build

This will search the entire repo and look for classes annoted with @Entity and create a file named objectbox.g.dart that you do not need to fiddle with, in any way. This file contains info how objectbox will interact with real data.

Now we just have to initialise object box store with all the required boxes.

import 'package:path/path.dart' as p;
// import path provider, objectbox.g.dart

class ObjectBox {

  late final Store store;

  late final Box<Model> box1;

  ObjectBox._create(this.store) {
    box1 = Box<Model>(store);
  }

  static Future<ObjectBox> create() async {
    final docsDir = await getApplicationDocumentsDirectory();

    final store = await openStore(directory: p.join(docsDir.path, "<specify name>"));
    return ObjectBox._create(store);
  }
}



and then ensure this is present in your `main.dart` file 

 javascript
late ObjectBox objectbox;
objectbox = await ObjectBox.create() ;

Above code samples the initialisation of the objectbox and makes it available to use app wide.

Now we can perform CRUD operations or complex queries!

Implementation

Initialisation

We have defined the Transaction model as follows

import 'package:objectbox/objectbox.dart';

@Entity()
class Transaction {
  @Id(assignable: true)
  int id;

  String title;
  String merchantName;
  double amount;
  DateTime date;
  String invoiceId;
  bool isExpense;
  String? notes;

  Transaction(
      {this.id = 0,
      required this.title,
      required this.merchantName,
      required this.amount,
      required this.date,
      required this.invoiceId,
      required this.isExpense,
      this.notes});
  // Method to convert Transaction to Map<String, dynamic>
  Map<String, dynamic> toMap() {
    return {
      'title': title,
      'vendors_name': merchantName,
      'total_amount': amount,
      'date': date.toIso8601String(),
      'invoice_id': invoiceId,
      'is_expense': isExpense,
      'buyer_name': notes,
    };
  }
}

We have string fields for title, name of the merchant, invoiceId, notes, date field of transaction, and whether it is income or expense.

It also defines a function toMap that gives that data as key-value paired maps

queries

• get_amount:

    Map<String, double> getAmount() {
  double income = 0;
  double expenses = 0;
  double balance = 0;
  Box<Transaction> transactionBox;
  transactionBox = objectbox.transactionBox;
  // Query all transactions and sum income and expenses
  for (var transaction in transactionBox.getAll()) {
    if (!transaction.isExpense) {
      income += transaction.amount;
    } else {
      expenses += transaction.amount;
    }
  }
  balance = income - expenses;
  
  return {
    'income': income,
    'expenses': expenses,
    'balance': balance,
  };
    }
  

  In this function we have used ObjectBox database in flutter. It calculates the total income, total expenses, and the balance based on transactions stored in the ObjectBox database. It retrieves all transactions, distinguishes between income and expenses, and computes the total amounts and the balance.
  Income Calculation: Aggregates amounts from transactions where isExpense is false.
  Expenses Calculation: Aggregates amounts from transactions where isExpense is true.
  Balance Calculation: Subtracts total expenses from total income.

• get_filtered_transaction:
  Filters transactions from the ObjectBox database based on various criteria including text search, expense/income status, amount range, and date range. Returns a list of transactions that match the specified filters.

  Text Search: Filters transactions where the title, merchantName, or invoiceId contains searchText.
  Expense/Income Filtering: Includes transactions based on the expense and income flags.
  Amount Range: Filters transactions based on the min_amount and max_amount parameters.
  Date Range: Filters transactions between dateFrom and dateTo. dateTo is adjusted to include the end of the day.

  • getFilteredTransactions: Filters and retrieves Transaction records from the ObjectBox database based on various criteria such as search text, expense/income status, amount range, and date range. Returns a list of transactions that match the specified filters.

  • getAnalysisFilteredTransactions: Retrieves Transaction records from the ObjectBox database that fall within a specified date range. The results are returned in ascending order of their IDs.

• get_transaction_by_id:

    Future<Transaction?> getTransactionById(int id) async {
  return objectbox.transactionBox.get(id);
    }
  

  Asynchronously retrieves a Transaction from the ObjectBox database using its unique identifier (id).
  Uses ObjectBox’s get method to fetch the transaction by its ID from the transactionBox. The method is asynchronous to handle potential delays in database access.

• get_transactions:

    List<Transaction> getTransactions() {
    return objectbox.transactionBox.getAll().reversed.toList();
    }
  

  Retrieves all Transaction records from the ObjectBox database and returns them as a list. The transactions are ordered in reverse chronological order, meaning the most recent transactions appear first. This ordering is achieved by reversing the list of transactions after fetching them from the database.