Skip to content

A local-first personal finance app

3.2 KB
Raw Blame
import type {
  AccountEntity,
  AccountGroupEntity,
} from '@actual-app/core/types/models';

import { isAccountFailedSync } from '#accounts/syncStatus';
import { useAccountGroups } from '#hooks/useAccountGroups';
import { useClosedAccounts } from '#hooks/useClosedAccounts';
import { useOffBudgetAccounts } from '#hooks/useOffBudgetAccounts';
import { useOnBudgetAccounts } from '#hooks/useOnBudgetAccounts';

export type GroupBucket = {
  group: AccountGroupEntity | null;
  accounts: AccountEntity[];
  failedCount: number;
};

export type SidebarAccountSide = {
  buckets: GroupBucket[];
  accountCount: number;
  failedCount: number;
};

export type SidebarAccountTree = {
  onBudget: SidebarAccountSide;
  offBudget: SidebarAccountSide;
  closed: AccountEntity[];
};

export function getEffectiveGroupId(
  account: AccountEntity,
  liveGroupIds: ReadonlySet<AccountGroupEntity['id']>,
): AccountGroupEntity['id'] | null {
  return account.account_group_id != null &&
    liveGroupIds.has(account.account_group_id)
    ? account.account_group_id
    : null;
}

export function buildAccountSide(
  accounts: AccountEntity[],
  groups: AccountGroupEntity[],
): SidebarAccountSide {
  const liveGroupIds = new Set(groups.map(group => group.id));
  const buckets: GroupBucket[] = [];

  const ungrouped = accounts.filter(
    account => getEffectiveGroupId(account, liveGroupIds) == null,
  );
  if (ungrouped.length > 0) {
    buckets.push({
      group: null,
      accounts: ungrouped,
      failedCount: ungrouped.filter(isAccountFailedSync).length,
    });
  }

  for (const group of groups) {
    const members = accounts.filter(
      account => account.account_group_id === group.id,
    );
    if (members.length > 0) {
      buckets.push({
        group,
        accounts: members,
        failedCount: members.filter(isAccountFailedSync).length,
      });
    }
  }

  return {
    buckets,
    accountCount: accounts.length,
    failedCount: accounts.filter(isAccountFailedSync).length,
  };
}

function filterSide(side: SidebarAccountSide, query: string) {
  return {
    ...side,
    buckets: side.buckets
      .map(bucket => ({
        ...bucket,
        accounts: bucket.accounts.filter(account =>
          `${bucket.group?.name ?? ''} ${account.name}`
            .toLowerCase()
            .includes(query),
        ),
      }))
      .filter(bucket => bucket.accounts.length > 0),
  };
}

export function filterSidebarTree(
  tree: SidebarAccountTree,
  query: string,
): SidebarAccountTree {
  if (!query) {
    return tree;
  }
  return {
    onBudget: filterSide(tree.onBudget, query),
    offBudget: filterSide(tree.offBudget, query),
    closed: tree.closed.filter(account =>
      account.name.toLowerCase().includes(query),
    ),
  };
}

export function useSidebarAccountTree(): SidebarAccountTree {
  const { data: groups = [] } = useAccountGroups();
  const { data: onBudgetAccounts = [] } = useOnBudgetAccounts();
  const { data: offBudgetAccounts = [] } = useOffBudgetAccounts();
  const { data: closedAccounts = [] } = useClosedAccounts();

  return {
    onBudget: buildAccountSide(onBudgetAccounts, groups),
    offBudget: buildAccountSide(offBudgetAccounts, groups),
    closed: closedAccounts,
  };
}