741 lines
32 KiB
Zig
741 lines
32 KiB
Zig
//! Wells Fargo Advisors positions export.
|
|
//!
|
|
//! The WF portal's spreadsheet download, with "Download Type" set to
|
|
//! **Portfolio-Expanded Detail**, "Portfolio View" set to **Positions**,
|
|
//! for all brokerage accounts. It is a legacy binary `.xls` (BIFF8),
|
|
//! decoded with the `biff8` package, holding one sheet, `WFA_Positions`,
|
|
//! for the whole household:
|
|
//!
|
|
//! ```
|
|
//! Priced as of Close on MM/DD/YYYY
|
|
//! Account Number: HOUSEHOLD
|
|
//! Cash/Cash Alternatives & Margin <- cash section
|
|
//! Description | Account Number | Market Value
|
|
//! Cash Balance | *1234 | ...
|
|
//! Bank Deposit Sweep | *1234 | ...
|
|
//! Accrued Money Market & Sweep Interest | Detail | ... (household subtotal)
|
|
//! Accrued Money Market & Sweep Interest | *1234 | ...
|
|
//! Total Cash/Cash Alternatives & Margin
|
|
//! Stocks / Common Stock <- section titles
|
|
//! Description | Symbol | Account Number | ... (34 columns)
|
|
//! <rows>
|
|
//! Total ...
|
|
//! ETFs, Mutual Funds <- same shape, own headers
|
|
//! Total Portfolio
|
|
//! <footnotes>
|
|
//! ```
|
|
//!
|
|
//! Security rows nest three levels deep, distinguished by two cells:
|
|
//!
|
|
//! | Account Number | Trade Date | Row is |
|
|
//! |----------------|-----------------|----------------------------------------|
|
|
//! | `Detail` | (any) | household total for a symbol held in several accounts |
|
|
//! | `*1234` | `Detail...` | one account's total for a multi-lot symbol |
|
|
//! | `*1234` | a date, ... | one tax lot (the only rows that count) |
|
|
//!
|
|
//! A symbol held as a single lot in an account has only the lot row.
|
|
//! Every per-account total is checked against the lots under it, so a
|
|
//! layout change (or a "Collapsed Detail" download, which has totals but
|
|
//! no lots) fails loudly instead of importing the wrong shares.
|
|
//!
|
|
//! Lot trade dates are `MM/DD/YYYY`, suffixed `nc` for lots whose cost
|
|
//! WF does not report to the IRS. Funds with same-day activity show
|
|
//! `Intra-Day` instead, with no trade date or cost; those lots get
|
|
//! `Date.epoch` (import's "unknown" sentinel) and no cost basis, so
|
|
//! import falls back exactly as it does for an export without dates.
|
|
//!
|
|
//! Columns are located by header name, not position. WF suffixes some
|
|
//! headers with a footnote digit (`Trade Date1`); those are stripped
|
|
//! before matching.
|
|
//!
|
|
//! Account identity: each row carries the account as `*NNNN`, the last
|
|
//! four digits. `accounts.srf` entries with `institution::wells_fargo`
|
|
//! map them through `account_number::NNNN`.
|
|
|
|
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
const biff8 = @import("biff8");
|
|
const Date = @import("../Date.zig");
|
|
const Lot = @import("../models/portfolio.zig").Lot;
|
|
const LotType = @import("../models/portfolio.zig").LotType;
|
|
const isMoneyMarketSymbol = @import("../models/portfolio.zig").isMoneyMarketSymbol;
|
|
const types = @import("types.zig");
|
|
const analysis = @import("../analytics/analysis.zig");
|
|
|
|
const BrokeragePosition = types.BrokeragePosition;
|
|
const Cell = biff8.Cell;
|
|
const Sheet = biff8.Sheet;
|
|
const log = std.log.scoped(.wells_fargo);
|
|
|
|
/// Institution name used for `accounts.srf` lookups
|
|
/// (`institution::wells_fargo`).
|
|
pub const institution = "wells_fargo";
|
|
|
|
/// The one sheet in a positions export.
|
|
pub const sheet_name = "WFA_Positions";
|
|
|
|
pub const Error = error{
|
|
/// No `WFA_Positions` sheet: some other spreadsheet, or a WF
|
|
/// download other than the positions view.
|
|
NotPositionsExport,
|
|
/// A section header is missing a column the parser reads.
|
|
UnexpectedHeader,
|
|
/// An account cell is not `*` followed by digits.
|
|
UnexpectedAccountNumber,
|
|
/// A lot's trade-date cell is neither a date nor a placeholder WF is
|
|
/// known to print (`Intra-Day`, `N/A`).
|
|
UnexpectedTradeDate,
|
|
/// A lot or cash row lacks its share count or market value.
|
|
MissingValue,
|
|
/// A per-account total disagrees with the lots listed under it.
|
|
InconsistentExport,
|
|
OutOfMemory,
|
|
};
|
|
|
|
/// The positions sheet of a parsed workbook.
|
|
pub fn positionsSheet(wb: *const biff8.Workbook) Error!*const Sheet {
|
|
return wb.sheet(sheet_name) orelse error.NotPositionsExport;
|
|
}
|
|
|
|
/// The date the export's values are priced at: the close named in its
|
|
/// "Priced as of Close on MM/DD/YYYY" banner. A download made over a
|
|
/// weekend is still priced at Friday's close, so this, not the
|
|
/// download date, is the date to price anything against. Null when the
|
|
/// banner is missing or unreadable.
|
|
pub fn pricedAsOf(sheet: *const Sheet) ?Date {
|
|
// The banner sits in the first few rows, above every section.
|
|
const scan_rows = @min(sheet.rows.len, 10);
|
|
for (0..scan_rows) |r| {
|
|
const text = trimmedText(sheet.cell(r, 0));
|
|
if (!std.mem.startsWith(u8, text, "Priced as of")) continue;
|
|
if (text.len < "MM/DD/YYYY".len) return null;
|
|
return Date.parseMdy(text[text.len - "MM/DD/YYYY".len ..]) catch null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// Anything reading an export file can fail with: the spreadsheet
|
|
/// decode, then the sheet layout.
|
|
pub const ExportError = biff8.ParseError || Error;
|
|
|
|
/// What to tell the user about a failed export, beyond the error's
|
|
/// name. Most failures mean a different choice on WF's download page,
|
|
/// so name the right one. Lines are indented to sit under an
|
|
/// `Error: ...` line; empty when there is nothing useful to add.
|
|
pub fn exportHint(err: ExportError) []const u8 {
|
|
return switch (err) {
|
|
error.NotCompoundFile,
|
|
error.NoWorkbookStream,
|
|
error.UnsupportedBiffVersion,
|
|
error.NotPositionsExport,
|
|
=> " Expected the WF positions spreadsheet: Download Type \"Portfolio-Expanded Detail\",\n" ++
|
|
" Portfolio View \"Positions\", all brokerage accounts.\n",
|
|
error.InconsistentExport,
|
|
error.UnexpectedTradeDate,
|
|
=> " Download Type must be \"Portfolio-Expanded Detail\" (per-lot rows), not \"Collapsed\".\n",
|
|
error.Truncated => " The file ends early; download it again.\n",
|
|
else => "",
|
|
};
|
|
}
|
|
|
|
/// One `BrokeragePosition` per tax lot, plus one per cash row (cash
|
|
/// balance, sweep, accrued interest: `symbol` empty, `is_cash`). Rows
|
|
/// for the same account and symbol are left separate; the reconciler
|
|
/// consolidates them.
|
|
///
|
|
/// `account_number` is the digits (`1234`); `account_name` is WF's own
|
|
/// `*1234`, which is all the export says about the account. Strings
|
|
/// borrow from `sheet`. Caller frees the returned slice.
|
|
pub fn parsePositions(allocator: std.mem.Allocator, sheet: *const Sheet) Error![]BrokeragePosition {
|
|
var positions: std.ArrayList(BrokeragePosition) = .empty;
|
|
errdefer positions.deinit(allocator);
|
|
try walk(allocator, sheet, &positions, null);
|
|
return positions.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// The export as portfolio lots: one per WF tax lot, with its real
|
|
/// trade date and cost, and one cash lot per account summing every
|
|
/// cash row. Built with `types.lotFromPosition`, so the cash and
|
|
/// cost conventions match every other import source. Lots with no
|
|
/// trade date keep `Date.epoch`.
|
|
///
|
|
/// `note` is left null for the caller. Every string is allocated
|
|
/// against `allocator`; free each lot's `symbol` and `account`, then
|
|
/// the slice.
|
|
pub fn parseLots(
|
|
allocator: std.mem.Allocator,
|
|
sheet: *const Sheet,
|
|
account_map: analysis.AccountMap,
|
|
) (Error || error{UnmappedAccount})![]Lot {
|
|
var positions: std.ArrayList(BrokeragePosition) = .empty;
|
|
defer positions.deinit(allocator);
|
|
var open_dates: std.ArrayList(?Date) = .empty;
|
|
defer open_dates.deinit(allocator);
|
|
try walk(allocator, sheet, &positions, &open_dates);
|
|
|
|
var lots: std.ArrayList(Lot) = .empty;
|
|
errdefer {
|
|
for (lots.items) |lot| {
|
|
allocator.free(lot.symbol);
|
|
if (lot.account) |a| allocator.free(a);
|
|
}
|
|
lots.deinit(allocator);
|
|
}
|
|
|
|
for (positions.items, open_dates.items) |pos, open_date| {
|
|
const account = account_map.findByInstitutionAccount(institution, pos.account_number) orelse
|
|
return error.UnmappedAccount;
|
|
|
|
// Cash-section rows fold into one cash lot per account, kept
|
|
// where that account's first cash row appeared.
|
|
if (pos.is_cash and pos.symbol.len == 0) {
|
|
const value = pos.current_value orelse 0;
|
|
for (lots.items) |*lot| {
|
|
if (lot.security_type == .cash and lot.symbol.len == 0 and std.mem.eql(u8, lot.account.?, account)) {
|
|
lot.shares += value;
|
|
break;
|
|
}
|
|
} else try appendOwned(allocator, &lots, types.lotFromPosition(pos, account));
|
|
continue;
|
|
}
|
|
|
|
var lot = types.lotFromPosition(pos, account);
|
|
if (open_date) |d| lot.open_date = d;
|
|
try appendOwned(allocator, &lots, lot);
|
|
}
|
|
return lots.toOwnedSlice(allocator);
|
|
}
|
|
|
|
fn appendOwned(allocator: std.mem.Allocator, lots: *std.ArrayList(Lot), lot: Lot) !void {
|
|
var owned = lot;
|
|
owned.symbol = try allocator.dupe(u8, lot.symbol);
|
|
errdefer allocator.free(owned.symbol);
|
|
owned.account = try allocator.dupe(u8, lot.account.?);
|
|
errdefer allocator.free(owned.account.?);
|
|
try lots.append(allocator, owned);
|
|
}
|
|
|
|
// ---- Sheet walk ----
|
|
|
|
/// Column indices of a securities section, from its header row.
|
|
const Columns = struct {
|
|
description: usize,
|
|
symbol: usize,
|
|
account: usize,
|
|
shares: usize,
|
|
market_value: usize,
|
|
total_cost: usize,
|
|
trade_date: usize,
|
|
};
|
|
|
|
/// A per-account total row, held until the lots under it are summed.
|
|
const OpenTotal = struct {
|
|
row: usize,
|
|
account: []const u8,
|
|
symbol: []const u8,
|
|
shares: f64,
|
|
lot_shares: f64 = 0,
|
|
};
|
|
|
|
const Section = union(enum) {
|
|
none,
|
|
cash: struct { account: usize, market_value: usize },
|
|
securities: Columns,
|
|
};
|
|
|
|
/// Visit every lot and cash row in sheet order, appending a position
|
|
/// for each (and its trade date, when `open_dates` is given).
|
|
fn walk(
|
|
allocator: std.mem.Allocator,
|
|
sheet: *const Sheet,
|
|
positions: *std.ArrayList(BrokeragePosition),
|
|
open_dates: ?*std.ArrayList(?Date),
|
|
) Error!void {
|
|
var section: Section = .none;
|
|
var open_total: ?OpenTotal = null;
|
|
|
|
for (0..sheet.rows.len) |r| {
|
|
const first = trimmedText(sheet.cell(r, 0));
|
|
|
|
if (std.mem.eql(u8, first, "Description")) {
|
|
try closeTotal(&open_total);
|
|
section = try parseHeader(sheet, r);
|
|
continue;
|
|
}
|
|
if (std.mem.startsWith(u8, first, "Total")) {
|
|
try closeTotal(&open_total);
|
|
section = .none;
|
|
continue;
|
|
}
|
|
|
|
switch (section) {
|
|
.none => {},
|
|
.cash => |c| {
|
|
const account = trimmedText(sheet.cell(r, c.account));
|
|
// Blank lines, and "Detail": the household subtotal
|
|
// of a cash line that appears in several accounts.
|
|
if (account.len == 0 or std.mem.eql(u8, account, "Detail")) continue;
|
|
try positions.append(allocator, .{
|
|
.account_number = try accountDigits(account, r),
|
|
.account_name = account,
|
|
.symbol = "",
|
|
.description = first,
|
|
.quantity = null,
|
|
.current_value = try requireNumber(sheet.cell(r, c.market_value), r, "Market Value"),
|
|
.cost_basis = null,
|
|
.is_cash = true,
|
|
});
|
|
if (open_dates) |d| try d.append(allocator, null);
|
|
},
|
|
.securities => |cols| {
|
|
const symbol = trimmedText(sheet.cell(r, cols.symbol));
|
|
const account = trimmedText(sheet.cell(r, cols.account));
|
|
// Section titles ("Common Stock", "Open End") and blank
|
|
// lines have no symbol.
|
|
if (symbol.len == 0 or account.len == 0) continue;
|
|
|
|
// Household total: the per-account rows that follow
|
|
// carry everything it sums.
|
|
if (std.mem.eql(u8, account, "Detail")) {
|
|
try closeTotal(&open_total);
|
|
continue;
|
|
}
|
|
|
|
const trade = sheet.cell(r, cols.trade_date);
|
|
const shares = try requireNumber(sheet.cell(r, cols.shares), r, "Shares");
|
|
|
|
if (std.mem.startsWith(u8, trimmedText(trade), "Detail")) {
|
|
try closeTotal(&open_total);
|
|
open_total = .{ .row = r, .account = account, .symbol = symbol, .shares = shares };
|
|
continue;
|
|
}
|
|
|
|
// A lot. It belongs to the open total only if it is the
|
|
// same account and symbol; anything else ends that total.
|
|
if (open_total) |*t| {
|
|
if (std.mem.eql(u8, t.account, account) and std.mem.eql(u8, t.symbol, symbol)) {
|
|
t.lot_shares += shares;
|
|
} else try closeTotal(&open_total);
|
|
}
|
|
|
|
const is_cash = isMoneyMarketSymbol(symbol);
|
|
try positions.append(allocator, .{
|
|
.account_number = try accountDigits(account, r),
|
|
.account_name = account,
|
|
.symbol = symbol,
|
|
.description = trimmedText(sheet.cell(r, cols.description)),
|
|
// Money-market rows follow the cash convention every
|
|
// other parser uses: dollars, not shares.
|
|
.quantity = if (is_cash) null else shares,
|
|
.current_value = try requireNumber(sheet.cell(r, cols.market_value), r, "Market Value"),
|
|
.cost_basis = if (is_cash) null else sheet.cell(r, cols.total_cost).asNumber(),
|
|
.is_cash = is_cash,
|
|
});
|
|
if (open_dates) |d| try d.append(allocator, try parseTradeDate(trade, r));
|
|
},
|
|
}
|
|
}
|
|
try closeTotal(&open_total);
|
|
}
|
|
|
|
/// Classify a header row: securities sections have a `Symbol` column,
|
|
/// the cash section does not.
|
|
fn parseHeader(sheet: *const Sheet, r: usize) Error!Section {
|
|
const has_symbol = findColumn(sheet, r, "Symbol") != null;
|
|
if (!has_symbol) {
|
|
return .{ .cash = .{
|
|
.account = try requireColumn(sheet, r, "Account Number"),
|
|
.market_value = try requireColumn(sheet, r, "Market Value"),
|
|
} };
|
|
}
|
|
return .{ .securities = .{
|
|
.description = try requireColumn(sheet, r, "Description"),
|
|
.symbol = try requireColumn(sheet, r, "Symbol"),
|
|
.account = try requireColumn(sheet, r, "Account Number"),
|
|
.shares = try requireColumn(sheet, r, "Shares"),
|
|
.market_value = try requireColumn(sheet, r, "Market Value"),
|
|
.total_cost = try requireColumn(sheet, r, "Total Cost"),
|
|
.trade_date = try requireColumn(sheet, r, "Trade Date"),
|
|
} };
|
|
}
|
|
|
|
fn findColumn(sheet: *const Sheet, r: usize, name: []const u8) ?usize {
|
|
for (sheet.rows[r], 0..) |cell, c| {
|
|
// Footnote markers are digits glued onto the header text.
|
|
const header = std.mem.trimEnd(u8, trimmedText(cell), "0123456789");
|
|
if (std.mem.eql(u8, header, name)) return c;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
fn requireColumn(sheet: *const Sheet, r: usize, name: []const u8) Error!usize {
|
|
return findColumn(sheet, r, name) orelse {
|
|
if (!builtin.is_test) log.warn("header on row {d} has no '{s}' column", .{ r + 1, name });
|
|
return error.UnexpectedHeader;
|
|
};
|
|
}
|
|
|
|
fn requireNumber(cell: Cell, r: usize, column: []const u8) Error!f64 {
|
|
return cell.asNumber() orelse {
|
|
if (!builtin.is_test) log.warn("row {d} has no number in '{s}'", .{ r + 1, column });
|
|
return error.MissingValue;
|
|
};
|
|
}
|
|
|
|
/// `*1234` -> `1234`.
|
|
fn accountDigits(account: []const u8, r: usize) Error![]const u8 {
|
|
if (account.len > 1 and account[0] == '*') {
|
|
const digits = account[1..];
|
|
for (digits) |c| {
|
|
if (!std.ascii.isDigit(c)) break;
|
|
} else return digits;
|
|
}
|
|
if (!builtin.is_test) log.warn("row {d}: account '{s}' is not '*' followed by digits", .{ r + 1, account });
|
|
return error.UnexpectedAccountNumber;
|
|
}
|
|
|
|
/// A lot's trade date: `MM/DD/YYYY`, optionally suffixed `nc`
|
|
/// (noncovered). `Intra-Day` and `N/A` mean WF is not showing one.
|
|
fn parseTradeDate(cell: Cell, r: usize) Error!?Date {
|
|
const raw = trimmedText(cell);
|
|
if (std.mem.eql(u8, raw, "Intra-Day") or std.mem.eql(u8, raw, "N/A")) return null;
|
|
const date_text = if (std.mem.endsWith(u8, raw, "nc")) raw[0 .. raw.len - 2] else raw;
|
|
return Date.parseMdy(date_text) catch {
|
|
if (!builtin.is_test) log.warn("row {d}: unrecognized trade date '{s}'", .{ r + 1, raw });
|
|
return error.UnexpectedTradeDate;
|
|
};
|
|
}
|
|
|
|
/// Check a per-account total against the lots summed under it.
|
|
fn closeTotal(open_total: *?OpenTotal) Error!void {
|
|
const t = open_total.* orelse return;
|
|
open_total.* = null;
|
|
if (@abs(t.lot_shares - t.shares) <= 1e-6 * @max(1.0, @abs(t.shares))) return;
|
|
if (!builtin.is_test) {
|
|
log.warn("row {d}: {s} {s} totals {d} shares but its lots sum to {d}", .{ t.row + 1, t.account, t.symbol, t.shares, t.lot_shares });
|
|
if (t.lot_shares == 0) log.warn("no lots follow it: zfin needs the 'Portfolio-Expanded Detail' download, not 'Collapsed'", .{});
|
|
}
|
|
return error.InconsistentExport;
|
|
}
|
|
|
|
fn trimmedText(cell: Cell) []const u8 {
|
|
return std.mem.trim(u8, cell.asText() orelse "", " ");
|
|
}
|
|
|
|
// ---- Tests ----
|
|
|
|
const testing = std.testing;
|
|
|
|
fn txt(s: []const u8) Cell {
|
|
return .{ .text = s };
|
|
}
|
|
|
|
fn num(v: f64) Cell {
|
|
return .{ .number = v };
|
|
}
|
|
|
|
/// Header with the real export's names, a footnote-suffixed one among
|
|
/// them, in a different order from the real file (columns are found
|
|
/// by name).
|
|
const header_row = [_]Cell{ txt("Description"), txt("Symbol"), txt("Account Number"), txt("Cash/Margin"), txt("Market Value"), txt("Shares"), txt("Tax Term"), txt("Total Cost1"), txt("Trade Date1") };
|
|
|
|
/// Placeholder household: accounts *1234 and *5678.
|
|
///
|
|
/// - cash: *1234 balance + sweep + accrued (with a household subtotal
|
|
/// row), *5678 sweep only
|
|
/// - stocks: a two-lot AAPL in *1234 (total + lots) and a single-lot
|
|
/// MSFT in *5678
|
|
/// - ETFs: VTI in both accounts (household total, then *1234's two-lot
|
|
/// total, then *5678's single lot), and a money-market fund
|
|
/// - mutual funds: an Intra-Day lot and a noncovered lot
|
|
const fixture_rows = [_][]const Cell{
|
|
&.{txt("Priced as of Close on 10/02/2026")},
|
|
&.{txt("Account Number: HOUSEHOLD")},
|
|
&.{},
|
|
&.{txt("Cash/Cash Alternatives & Margin")},
|
|
&.{ txt("Description"), txt("Account Number"), txt("Market Value") },
|
|
&.{ txt("Cash Balance"), txt("*1234"), num(10) },
|
|
&.{ txt("Bank Deposit Sweep "), txt("*1234"), num(500) },
|
|
&.{ txt("Bank Deposit Sweep "), txt("*5678"), num(250) },
|
|
&.{ txt("Accrued Money Market & Sweep Interest"), txt("Detail"), num(0.75) },
|
|
&.{ txt("Accrued Money Market & Sweep Interest"), txt("*1234"), num(0.5) },
|
|
&.{ txt("Accrued Money Market & Sweep Interest"), txt("*5678"), num(0.25) },
|
|
&.{ txt("Total Cash/Cash Alternatives & Margin"), .empty, num(761.0) },
|
|
&.{},
|
|
&.{txt("Stocks")},
|
|
&header_row,
|
|
&.{txt("Common Stock")},
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(3000), num(15), txt("Detail"), num(2000), txt("Detail") },
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(2000), num(10), txt("LONG"), num(1200), txt("03/15/2021") },
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(1000), num(5), txt("SHORT"), num(800), txt("01/10/2026") },
|
|
&.{ txt("MICROSOFT CORP"), txt("MSFT"), txt("*5678"), txt("Cash"), num(4000), num(10), txt("LONG"), num(3000), txt("06/01/2020") },
|
|
&.{ txt("Total Stocks"), .empty, .empty, .empty, num(7000) },
|
|
&.{},
|
|
&.{txt("ETFs")},
|
|
&header_row,
|
|
&.{ txt("VANGUARD TOTAL STOCK MKT"), txt("VTI"), txt("Detail"), txt("Cash"), num(9000), num(30), txt("Detail"), num(7000), txt("Detail") },
|
|
&.{ txt("VANGUARD TOTAL STOCK MKT"), txt("VTI"), txt("*1234"), txt("Cash"), num(6000), num(20), txt("Detail"), num(4500), txt("Detail") },
|
|
&.{ txt("VANGUARD TOTAL STOCK MKT"), txt("VTI"), txt("*1234"), txt("Cash"), num(3600), num(12), txt("LONG"), num(2400), txt("02/03/2022") },
|
|
&.{ txt("VANGUARD TOTAL STOCK MKT"), txt("VTI"), txt("*1234"), txt("Cash"), num(2400), num(8), txt("SHORT"), num(2100), txt("09/09/2026") },
|
|
&.{ txt("VANGUARD TOTAL STOCK MKT"), txt("VTI"), txt("*5678"), txt("Cash"), num(3000), num(10), txt("LONG"), num(2500), txt("04/04/2023") },
|
|
&.{ txt("SAMPLE MONEY MARKET"), txt("WMPXX"), txt("*5678"), txt("Cash"), num(100), num(100), txt("SHORT"), num(100), txt("05/05/2026") },
|
|
&.{ txt("Total ETFs"), .empty, .empty, .empty, num(9100) },
|
|
&.{},
|
|
&.{txt("Mutual Funds")},
|
|
&header_row,
|
|
&.{txt("Open End")},
|
|
&.{ txt("SAMPLE GROWTH FUND"), txt("SMPLX"), txt("*1234"), txt("Network Fund"), num(5000), num(250), txt("N/A"), txt("N/A"), txt("Intra-Day") },
|
|
&.{ txt("SAMPLE INCOME FUND"), txt("SMPIX"), txt("*5678"), txt("Special Product"), num(1100), num(100), txt("N/A"), num(1000), txt("07/07/2015nc") },
|
|
&.{ txt("Total Mutual Funds"), .empty, .empty, .empty, num(6100) },
|
|
&.{},
|
|
&.{txt("Total Portfolio")},
|
|
&.{ .empty, txt("Market Value") },
|
|
&.{ txt("Total"), num(23961) },
|
|
&.{txt("1 Securities with intra-day activity will not display information in the following data fields: Trade Date, ...")},
|
|
};
|
|
|
|
const fixture: Sheet = .{ .name = sheet_name, .rows = &fixture_rows };
|
|
|
|
fn sheetWith(rows: []const []const Cell) Sheet {
|
|
return .{ .name = sheet_name, .rows = rows };
|
|
}
|
|
|
|
/// accounts.srf entries for the fixture's two accounts.
|
|
fn fixtureAccounts() [2]analysis.AccountTaxEntry {
|
|
return .{
|
|
.{ .account = "Sample IRA *1234", .tax_type = .traditional, .institution = "wells_fargo", .account_number = "1234" },
|
|
.{ .account = "Sample Brokerage *5678", .tax_type = .taxable, .institution = "wells_fargo", .account_number = "5678" },
|
|
};
|
|
}
|
|
|
|
fn freeLotsForTest(allocator: std.mem.Allocator, lots: []const Lot) void {
|
|
for (lots) |lot| {
|
|
allocator.free(lot.symbol);
|
|
allocator.free(lot.account.?);
|
|
}
|
|
allocator.free(lots);
|
|
}
|
|
|
|
test "parsePositions: every lot and cash row, nothing else" {
|
|
const positions = try parsePositions(testing.allocator, &fixture);
|
|
defer testing.allocator.free(positions);
|
|
|
|
// 5 cash rows (subtotal skipped), 3 stock lots, 4 ETF lots (both
|
|
// totals skipped), 2 fund lots.
|
|
try testing.expectEqual(@as(usize, 14), positions.len);
|
|
|
|
const cash = positions[0];
|
|
try testing.expectEqualStrings("1234", cash.account_number);
|
|
try testing.expectEqualStrings("*1234", cash.account_name);
|
|
try testing.expectEqualStrings("", cash.symbol);
|
|
try testing.expectEqualStrings("Cash Balance", cash.description);
|
|
try testing.expect(cash.is_cash);
|
|
try testing.expect(cash.quantity == null);
|
|
try testing.expectEqual(@as(f64, 10), cash.current_value.?);
|
|
// Trailing padding is trimmed.
|
|
try testing.expectEqualStrings("Bank Deposit Sweep", positions[1].description);
|
|
|
|
const lot = positions[5];
|
|
try testing.expectEqualStrings("AAPL", lot.symbol);
|
|
try testing.expectEqualStrings("APPLE INC", lot.description);
|
|
try testing.expectEqual(@as(f64, 10), lot.quantity.?);
|
|
try testing.expectEqual(@as(f64, 2000), lot.current_value.?);
|
|
try testing.expectEqual(@as(f64, 1200), lot.cost_basis.?);
|
|
try testing.expect(!lot.is_cash);
|
|
|
|
// Per-symbol sums equal what WF's own totals say.
|
|
var vti: f64 = 0;
|
|
for (positions) |p| {
|
|
if (std.mem.eql(u8, p.symbol, "VTI")) vti += p.quantity.?;
|
|
}
|
|
try testing.expectEqual(@as(f64, 30), vti);
|
|
|
|
// A money-market holding is cash, valued in dollars.
|
|
const mm = positions[11];
|
|
try testing.expectEqualStrings("WMPXX", mm.symbol);
|
|
try testing.expect(mm.is_cash);
|
|
try testing.expect(mm.quantity == null);
|
|
try testing.expect(mm.cost_basis == null);
|
|
|
|
// A fund with no reported cost.
|
|
try testing.expectEqualStrings("SMPLX", positions[12].symbol);
|
|
try testing.expect(positions[12].cost_basis == null);
|
|
}
|
|
|
|
test "parseLots: real trade dates and costs; one cash lot per account" {
|
|
const allocator = testing.allocator;
|
|
var entries = fixtureAccounts();
|
|
const account_map: analysis.AccountMap = .{ .entries = &entries, .allocator = allocator };
|
|
|
|
const lots = try parseLots(allocator, &fixture, account_map);
|
|
defer freeLotsForTest(allocator, lots);
|
|
|
|
// 2 cash lots (one per account) + 3 + 4 + 2.
|
|
try testing.expectEqual(@as(usize, 11), lots.len);
|
|
|
|
// Cash: balance + sweep + accrued for *1234; the household
|
|
// subtotal row is not double counted.
|
|
try testing.expectEqual(LotType.cash, lots[0].security_type);
|
|
try testing.expectEqualStrings("Sample IRA *1234", lots[0].account.?);
|
|
try testing.expectApproxEqAbs(@as(f64, 510.5), lots[0].shares, 1e-9);
|
|
try testing.expectEqual(@as(f64, 1.0), lots[0].open_price);
|
|
try testing.expectEqualStrings("Sample Brokerage *5678", lots[1].account.?);
|
|
try testing.expectApproxEqAbs(@as(f64, 250.25), lots[1].shares, 1e-9);
|
|
|
|
// A dated lot: real trade date, cost per share.
|
|
const aapl = lots[2];
|
|
try testing.expectEqualStrings("AAPL", aapl.symbol);
|
|
try testing.expectEqual(@as(f64, 10), aapl.shares);
|
|
try testing.expect(Date.fromYmd(2021, 3, 15).eql(aapl.open_date));
|
|
try testing.expectEqual(@as(f64, 120), aapl.open_price);
|
|
try testing.expect(aapl.note == null);
|
|
|
|
// Money market: a cash lot keeping its symbol.
|
|
const mm = lots[8];
|
|
try testing.expectEqualStrings("WMPXX", mm.symbol);
|
|
try testing.expectEqual(LotType.cash, mm.security_type);
|
|
try testing.expectEqual(@as(f64, 100), mm.shares);
|
|
|
|
// Intra-Day fund: unknown date, priced from market value.
|
|
const intraday = lots[9];
|
|
try testing.expectEqualStrings("SMPLX", intraday.symbol);
|
|
try testing.expect(Date.epoch.eql(intraday.open_date));
|
|
try testing.expectEqual(@as(f64, 20), intraday.open_price); // 5000 / 250
|
|
|
|
// Noncovered lot: the `nc` suffix does not hide the date.
|
|
try testing.expect(Date.fromYmd(2015, 7, 7).eql(lots[10].open_date));
|
|
try testing.expectEqual(@as(f64, 10), lots[10].open_price);
|
|
}
|
|
|
|
test "parseLots: an account missing from accounts.srf is UnmappedAccount" {
|
|
const account_map: analysis.AccountMap = .{ .entries = &.{}, .allocator = testing.allocator };
|
|
try testing.expectError(error.UnmappedAccount, parseLots(testing.allocator, &fixture, account_map));
|
|
}
|
|
|
|
test "parseLots: every allocation failure is clean" {
|
|
const S = struct {
|
|
fn run(allocator: std.mem.Allocator, map: analysis.AccountMap) !void {
|
|
freeLotsForTest(allocator, try parseLots(allocator, &fixture, map));
|
|
}
|
|
};
|
|
var entries = fixtureAccounts();
|
|
const map: analysis.AccountMap = .{ .entries = &entries, .allocator = testing.allocator };
|
|
try testing.checkAllAllocationFailures(testing.allocator, S.run, .{map});
|
|
}
|
|
|
|
test "positionsSheet: finds the sheet by name" {
|
|
var wb: biff8.Workbook = .{ .arena = std.heap.ArenaAllocator.init(testing.allocator), .sheets = &.{fixture} };
|
|
defer wb.deinit();
|
|
try testing.expectEqualStrings(sheet_name, (try positionsSheet(&wb)).name);
|
|
|
|
var other: biff8.Workbook = .{ .arena = std.heap.ArenaAllocator.init(testing.allocator), .sheets = &.{.{ .name = "Sheet1", .rows = &.{} }} };
|
|
defer other.deinit();
|
|
try testing.expectError(error.NotPositionsExport, positionsSheet(&other));
|
|
}
|
|
|
|
test "a header missing a needed column is UnexpectedHeader" {
|
|
const no_trade_date = sheetWith(&.{
|
|
&.{ txt("Description"), txt("Symbol"), txt("Account Number"), txt("Market Value"), txt("Shares"), txt("Total Cost") },
|
|
});
|
|
try testing.expectError(error.UnexpectedHeader, parsePositions(testing.allocator, &no_trade_date));
|
|
|
|
const cash_no_value = sheetWith(&.{&.{ txt("Description"), txt("Account Number") }});
|
|
try testing.expectError(error.UnexpectedHeader, parsePositions(testing.allocator, &cash_no_value));
|
|
}
|
|
|
|
test "malformed rows are reported, not skipped" {
|
|
const bad_account = sheetWith(&.{
|
|
&header_row,
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("1234"), txt("Cash"), num(10), num(1), txt("LONG"), num(5), txt("03/15/2021") },
|
|
});
|
|
try testing.expectError(error.UnexpectedAccountNumber, parsePositions(testing.allocator, &bad_account));
|
|
|
|
const bad_cash_account = sheetWith(&.{
|
|
&.{ txt("Description"), txt("Account Number"), txt("Market Value") },
|
|
&.{ txt("Cash Balance"), txt("*12a4"), num(10) },
|
|
});
|
|
try testing.expectError(error.UnexpectedAccountNumber, parsePositions(testing.allocator, &bad_cash_account));
|
|
|
|
const no_shares = sheetWith(&.{
|
|
&header_row,
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(10), txt("N/A"), txt("LONG"), num(5), txt("03/15/2021") },
|
|
});
|
|
try testing.expectError(error.MissingValue, parsePositions(testing.allocator, &no_shares));
|
|
|
|
const no_value = sheetWith(&.{
|
|
&.{ txt("Description"), txt("Account Number"), txt("Market Value") },
|
|
&.{ txt("Cash Balance"), txt("*1234"), txt("N/A") },
|
|
});
|
|
try testing.expectError(error.MissingValue, parsePositions(testing.allocator, &no_value));
|
|
}
|
|
|
|
test "an unknown trade date fails parseLots but not parsePositions" {
|
|
// "Multiple" is the kind of thing a different download type might
|
|
// print in place of per-lot dates.
|
|
const sheet = sheetWith(&.{
|
|
&header_row,
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(10), num(1), txt("LONG"), num(5), txt("Multiple") },
|
|
});
|
|
const positions = try parsePositions(testing.allocator, &sheet);
|
|
testing.allocator.free(positions);
|
|
|
|
var entries = fixtureAccounts();
|
|
const account_map: analysis.AccountMap = .{ .entries = &entries, .allocator = testing.allocator };
|
|
try testing.expectError(error.UnexpectedTradeDate, parseLots(testing.allocator, &sheet, account_map));
|
|
}
|
|
|
|
test "an account total that disagrees with its lots is InconsistentExport" {
|
|
const short = sheetWith(&.{
|
|
&header_row,
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(30), num(15), txt("Detail"), num(20), txt("Detail") },
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(20), num(10), txt("LONG"), num(12), txt("03/15/2021") },
|
|
&.{ txt("MICROSOFT CORP"), txt("MSFT"), txt("*1234"), txt("Cash"), num(40), num(1), txt("LONG"), num(30), txt("06/01/2020") },
|
|
});
|
|
try testing.expectError(error.InconsistentExport, parsePositions(testing.allocator, &short));
|
|
|
|
// Totals with no lots under them: a Collapsed Detail download.
|
|
const collapsed = sheetWith(&.{
|
|
&header_row,
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(30), num(15), txt("Detail"), num(20), txt("Detail") },
|
|
&.{ txt("Total Stocks"), .empty, .empty, .empty, num(30) },
|
|
});
|
|
try testing.expectError(error.InconsistentExport, parsePositions(testing.allocator, &collapsed));
|
|
|
|
// An open total is still checked when the sheet just ends.
|
|
const unterminated = sheetWith(&.{
|
|
&header_row,
|
|
&.{ txt("APPLE INC"), txt("AAPL"), txt("*1234"), txt("Cash"), num(30), num(15), txt("Detail"), num(20), txt("Detail") },
|
|
});
|
|
try testing.expectError(error.InconsistentExport, parsePositions(testing.allocator, &unterminated));
|
|
}
|
|
|
|
test "rows outside any section are ignored" {
|
|
const sheet = sheetWith(&.{
|
|
&.{ txt("Stray"), txt("AAPL"), txt("*1234"), num(1) },
|
|
&.{txt("Total Portfolio")},
|
|
});
|
|
const positions = try parsePositions(testing.allocator, &sheet);
|
|
defer testing.allocator.free(positions);
|
|
try testing.expectEqual(@as(usize, 0), positions.len);
|
|
}
|
|
|
|
test "exportHint: names the right download for each failure" {
|
|
try testing.expect(std.mem.indexOf(u8, exportHint(error.NotCompoundFile), "Portfolio-Expanded Detail") != null);
|
|
try testing.expect(std.mem.indexOf(u8, exportHint(error.NotPositionsExport), "Positions") != null);
|
|
try testing.expect(std.mem.indexOf(u8, exportHint(error.InconsistentExport), "Collapsed") != null);
|
|
try testing.expect(std.mem.indexOf(u8, exportHint(error.Truncated), "again") != null);
|
|
try testing.expectEqualStrings("", exportHint(error.MissingValue));
|
|
}
|
|
|
|
test "pricedAsOf: reads the banner date" {
|
|
try testing.expect(Date.fromYmd(2026, 10, 2).eql(pricedAsOf(&fixture).?));
|
|
}
|
|
|
|
test "pricedAsOf: null without a readable banner" {
|
|
const no_banner = sheetWith(&.{&.{txt("Account Number: HOUSEHOLD")}});
|
|
try testing.expect(pricedAsOf(&no_banner) == null);
|
|
const bad_date = sheetWith(&.{&.{txt("Priced as of Close on 13/45/2026")}});
|
|
try testing.expect(pricedAsOf(&bad_date) == null);
|
|
const too_short = sheetWith(&.{&.{txt("Priced as of")}});
|
|
try testing.expect(pricedAsOf(&too_short) == null);
|
|
}
|