mirror of
https://github.com/aclindsa/moneygo.git
synced 2024-12-26 23:42:29 -05:00
1003 lines
29 KiB
Go
1003 lines
29 KiB
Go
package handlers
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/aclindsa/ofxgo"
|
|
"io"
|
|
"math/big"
|
|
)
|
|
|
|
type OFXImport struct {
|
|
Securities []Security
|
|
Accounts []Account
|
|
Transactions []Transaction
|
|
// Balances map[int64]string // map AccountIDs to ending balances
|
|
}
|
|
|
|
func (i *OFXImport) GetSecurity(ofxsecurityid int64) (*Security, error) {
|
|
if ofxsecurityid < 0 || ofxsecurityid > int64(len(i.Securities)) {
|
|
return nil, errors.New("OFXImport.GetSecurity: SecurityID out of range")
|
|
}
|
|
return &i.Securities[ofxsecurityid], nil
|
|
}
|
|
|
|
func (i *OFXImport) GetSecurityAlternateId(alternateid string, securityType SecurityType) (*Security, error) {
|
|
for _, security := range i.Securities {
|
|
if alternateid == security.AlternateId && securityType == security.Type {
|
|
return &security, nil
|
|
}
|
|
}
|
|
|
|
return nil, errors.New("OFXImport.FindSecurity: Unable to find security")
|
|
}
|
|
|
|
func (i *OFXImport) GetAddCurrency(isoname string) (*Security, error) {
|
|
for _, security := range i.Securities {
|
|
if isoname == security.Name && Currency == security.Type {
|
|
return &security, nil
|
|
}
|
|
}
|
|
|
|
template := FindSecurityTemplate(isoname, Currency)
|
|
if template == nil {
|
|
return nil, fmt.Errorf("Failed to find Security for \"%s\"", isoname)
|
|
}
|
|
var security Security = *template
|
|
security.SecurityId = int64(len(i.Securities) + 1)
|
|
i.Securities = append(i.Securities, security)
|
|
|
|
return &security, nil
|
|
}
|
|
|
|
func (i *OFXImport) AddTransaction(tran *ofxgo.Transaction, account *Account) error {
|
|
var t Transaction
|
|
|
|
t.Date = tran.DtPosted.UTC()
|
|
|
|
// Construct the description from whichever of the descriptive OFX fields are present
|
|
if len(tran.Name) > 0 {
|
|
t.Description = string(tran.Name)
|
|
} else if tran.Payee != nil {
|
|
t.Description = string(tran.Payee.Name)
|
|
}
|
|
if len(tran.Memo) > 0 {
|
|
if len(t.Description) > 0 {
|
|
t.Description = t.Description + " - " + string(tran.Memo)
|
|
} else {
|
|
t.Description = string(tran.Memo)
|
|
}
|
|
}
|
|
|
|
var s1, s2 Split
|
|
if len(tran.ExtdName) > 0 {
|
|
s1.Memo = tran.ExtdName.String()
|
|
}
|
|
if len(tran.CheckNum) > 0 {
|
|
s1.Number = tran.CheckNum.String()
|
|
} else if len(tran.RefNum) > 0 {
|
|
s1.Number = tran.RefNum.String()
|
|
}
|
|
|
|
amt := big.NewRat(0, 1)
|
|
// Convert TrnAmt to account's currency if Currency is set
|
|
if ok, _ := tran.Currency.Valid(); ok {
|
|
amt.Mul(&tran.Currency.CurRate.Rat, &tran.TrnAmt.Rat)
|
|
} else {
|
|
amt.Set(&tran.TrnAmt.Rat)
|
|
}
|
|
if account.SecurityId < 1 || account.SecurityId > int64(len(i.Securities)) {
|
|
return errors.New("Internal error: security index not found in OFX import\n")
|
|
}
|
|
|
|
s1.RemoteId = "ofx:" + tran.FiTID.String()
|
|
// TODO CorrectFiTID/CorrectAction?
|
|
|
|
s1.ImportSplitType = ImportAccount
|
|
s2.ImportSplitType = ExternalAccount
|
|
|
|
security := i.Securities[account.SecurityId-1]
|
|
s1.Amount = amt.FloatString(security.Precision)
|
|
s2.Amount = amt.Neg(amt).FloatString(security.Precision)
|
|
|
|
s1.Status = Imported
|
|
s2.Status = Imported
|
|
|
|
s1.AccountId = account.AccountId
|
|
s2.AccountId = -1
|
|
s1.SecurityId = -1
|
|
s2.SecurityId = security.SecurityId
|
|
|
|
t.Splits = append(t.Splits, &s1)
|
|
t.Splits = append(t.Splits, &s2)
|
|
i.Transactions = append(i.Transactions, t)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (i *OFXImport) importOFXBank(stmt *ofxgo.StatementResponse) error {
|
|
security, err := i.GetAddCurrency(stmt.CurDef.String())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
account := Account{
|
|
AccountId: int64(len(i.Accounts) + 1),
|
|
ExternalAccountId: stmt.BankAcctFrom.AcctID.String(),
|
|
SecurityId: security.SecurityId,
|
|
ParentAccountId: -1,
|
|
Type: Bank,
|
|
}
|
|
|
|
if stmt.BankTranList != nil {
|
|
for _, tran := range stmt.BankTranList.Transactions {
|
|
if err := i.AddTransaction(&tran, &account); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
i.Accounts = append(i.Accounts, account)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (i *OFXImport) importOFXCC(stmt *ofxgo.CCStatementResponse) error {
|
|
security, err := i.GetAddCurrency(stmt.CurDef.String())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
account := Account{
|
|
AccountId: int64(len(i.Accounts) + 1),
|
|
ExternalAccountId: stmt.CCAcctFrom.AcctID.String(),
|
|
SecurityId: security.SecurityId,
|
|
ParentAccountId: -1,
|
|
Type: Liability,
|
|
}
|
|
i.Accounts = append(i.Accounts, account)
|
|
|
|
if stmt.BankTranList != nil {
|
|
for _, tran := range stmt.BankTranList.Transactions {
|
|
if err := i.AddTransaction(&tran, &account); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO balance(s)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (i *OFXImport) importSecurities(seclist *ofxgo.SecurityList) error {
|
|
for _, security := range seclist.Securities {
|
|
var si ofxgo.SecInfo
|
|
if sec, ok := (security).(ofxgo.DebtInfo); ok {
|
|
si = sec.SecInfo
|
|
} else if sec, ok := (security).(ofxgo.MFInfo); ok {
|
|
si = sec.SecInfo
|
|
} else if sec, ok := (security).(ofxgo.OptInfo); ok {
|
|
si = sec.SecInfo
|
|
} else if sec, ok := (security).(ofxgo.OtherInfo); ok {
|
|
si = sec.SecInfo
|
|
} else if sec, ok := (security).(ofxgo.StockInfo); ok {
|
|
si = sec.SecInfo
|
|
} else {
|
|
return errors.New("Can't import unrecognized type satisfying ofxgo.Security interface")
|
|
}
|
|
s := Security{
|
|
SecurityId: int64(len(i.Securities) + 1),
|
|
Name: string(si.SecName),
|
|
Description: string(si.Memo),
|
|
Symbol: string(si.Ticker),
|
|
Precision: 5, // TODO How to actually determine this?
|
|
Type: Stock,
|
|
AlternateId: string(si.SecID.UniqueID),
|
|
}
|
|
if len(s.Description) == 0 {
|
|
s.Description = s.Name
|
|
}
|
|
if len(s.Symbol) == 0 {
|
|
s.Symbol = s.Name
|
|
}
|
|
|
|
i.Securities = append(i.Securities, s)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (i *OFXImport) GetInvTran(invtran *ofxgo.InvTran) Transaction {
|
|
var t Transaction
|
|
t.Description = string(invtran.Memo)
|
|
t.Date = invtran.DtTrade.UTC()
|
|
return t
|
|
}
|
|
|
|
func (i *OFXImport) GetInvBuyTran(buy *ofxgo.InvBuy, curdef *Security, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&buy.InvTran)
|
|
|
|
security, err := i.GetSecurityAlternateId(string(buy.SecID.UniqueID), Stock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
memo := string(buy.InvTran.Memo)
|
|
if len(memo) > 0 {
|
|
memo += " "
|
|
}
|
|
|
|
var commission, taxes, fees, load, total, tradingTotal big.Rat
|
|
commission.Set(&buy.Commission.Rat)
|
|
taxes.Set(&buy.Taxes.Rat)
|
|
fees.Set(&buy.Fees.Rat)
|
|
load.Set(&buy.Load.Rat)
|
|
total.Set(&buy.Total.Rat)
|
|
|
|
tradingTotal.Neg(&total)
|
|
tradingTotal.Sub(&tradingTotal, &commission)
|
|
tradingTotal.Sub(&tradingTotal, &taxes)
|
|
tradingTotal.Sub(&tradingTotal, &fees)
|
|
tradingTotal.Sub(&tradingTotal, &load)
|
|
|
|
// Convert amounts to account's currency if Currency is set
|
|
if ok, _ := buy.Currency.Valid(); ok {
|
|
commission.Mul(&commission, &buy.Currency.CurRate.Rat)
|
|
taxes.Mul(&taxes, &buy.Currency.CurRate.Rat)
|
|
fees.Mul(&fees, &buy.Currency.CurRate.Rat)
|
|
load.Mul(&load, &buy.Currency.CurRate.Rat)
|
|
total.Mul(&total, &buy.Currency.CurRate.Rat)
|
|
tradingTotal.Mul(&tradingTotal, &buy.Currency.CurRate.Rat)
|
|
}
|
|
|
|
if num := commission.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Commission,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo + "(commission)",
|
|
Amount: commission.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := taxes.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Taxes,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo + "(taxes)",
|
|
Amount: taxes.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := fees.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Fees,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo + "(fees)",
|
|
Amount: fees.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := load.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Load,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo + "(load)",
|
|
Amount: load.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: TradingAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: tradingTotal.FloatString(curdef.Precision),
|
|
})
|
|
|
|
units := big.NewRat(0, 1)
|
|
units.Set(&buy.Units.Rat)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: SubAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
units.Neg(units)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: TradingAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + buy.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) GetIncomeTran(income *ofxgo.Income, curdef *Security, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&income.InvTran)
|
|
|
|
security, err := i.GetSecurityAlternateId(string(income.SecID.UniqueID), Stock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
memo := string(income.InvTran.Memo)
|
|
if len(memo) > 0 {
|
|
memo += " "
|
|
} else {
|
|
memo = income.IncomeType.String() + " on " + security.Symbol
|
|
}
|
|
|
|
var total big.Rat
|
|
total.Set(&income.Total.Rat)
|
|
if ok, _ := income.Currency.Valid(); ok {
|
|
total.Mul(&total, &income.Currency.CurRate.Rat)
|
|
}
|
|
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + income.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
total.Neg(&total)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: IncomeAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + income.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) GetInvExpenseTran(expense *ofxgo.InvExpense, curdef *Security, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&expense.InvTran)
|
|
|
|
security, err := i.GetSecurityAlternateId(string(expense.SecID.UniqueID), Stock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
memo := string(expense.InvTran.Memo)
|
|
if len(memo) == 0 {
|
|
memo = "INVEXPENSE"
|
|
}
|
|
memo += " (" + security.Symbol + ")"
|
|
|
|
var total big.Rat
|
|
total.Set(&expense.Total.Rat)
|
|
if ok, _ := expense.Currency.Valid(); ok {
|
|
total.Mul(&total, &expense.Currency.CurRate.Rat)
|
|
}
|
|
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + expense.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
total.Neg(&total)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ExpenseAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + expense.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) GetMarginInterestTran(marginint *ofxgo.MarginInterest, curdef *Security, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&marginint.InvTran)
|
|
|
|
memo := string(marginint.InvTran.Memo)
|
|
if len(memo) == 0 {
|
|
memo = "MARGININTEREST"
|
|
}
|
|
|
|
var total big.Rat
|
|
total.Set(&marginint.Total.Rat)
|
|
if ok, _ := marginint.Currency.Valid(); ok {
|
|
total.Mul(&total, &marginint.Currency.CurRate.Rat)
|
|
}
|
|
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + marginint.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
total.Neg(&total)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: IncomeAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + marginint.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) GetReinvestTran(reinvest *ofxgo.Reinvest, curdef *Security, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&reinvest.InvTran)
|
|
|
|
security, err := i.GetSecurityAlternateId(string(reinvest.SecID.UniqueID), Stock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
memo := string(reinvest.InvTran.Memo)
|
|
if len(memo) > 0 {
|
|
memo += " "
|
|
}
|
|
|
|
var commission, taxes, fees, load, total, tradingTotal big.Rat
|
|
commission.Set(&reinvest.Commission.Rat)
|
|
taxes.Set(&reinvest.Taxes.Rat)
|
|
fees.Set(&reinvest.Fees.Rat)
|
|
load.Set(&reinvest.Load.Rat)
|
|
total.Set(&reinvest.Total.Rat)
|
|
|
|
tradingTotal.Neg(&total)
|
|
tradingTotal.Sub(&tradingTotal, &commission)
|
|
tradingTotal.Sub(&tradingTotal, &taxes)
|
|
tradingTotal.Sub(&tradingTotal, &fees)
|
|
tradingTotal.Sub(&tradingTotal, &load)
|
|
|
|
// Convert amounts to account's currency if Currency is set
|
|
if ok, _ := reinvest.Currency.Valid(); ok {
|
|
commission.Mul(&commission, &reinvest.Currency.CurRate.Rat)
|
|
taxes.Mul(&taxes, &reinvest.Currency.CurRate.Rat)
|
|
fees.Mul(&fees, &reinvest.Currency.CurRate.Rat)
|
|
load.Mul(&load, &reinvest.Currency.CurRate.Rat)
|
|
total.Mul(&total, &reinvest.Currency.CurRate.Rat)
|
|
tradingTotal.Mul(&tradingTotal, &reinvest.Currency.CurRate.Rat)
|
|
}
|
|
|
|
if num := commission.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Commission,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo + "(commission)",
|
|
Amount: commission.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := taxes.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Taxes,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo + "(taxes)",
|
|
Amount: taxes.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := fees.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Fees,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo + "(fees)",
|
|
Amount: fees.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := load.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Load,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo + "(load)",
|
|
Amount: load.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: IncomeAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
total.Neg(&total)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: TradingAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: tradingTotal.FloatString(curdef.Precision),
|
|
})
|
|
|
|
var units big.Rat
|
|
units.Set(&reinvest.Units.Rat)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: SubAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
units.Neg(&units)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: TradingAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + reinvest.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) GetRetOfCapTran(retofcap *ofxgo.RetOfCap, curdef *Security, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&retofcap.InvTran)
|
|
|
|
security, err := i.GetSecurityAlternateId(string(retofcap.SecID.UniqueID), Stock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
memo := string(retofcap.InvTran.Memo)
|
|
if len(memo) == 0 {
|
|
memo = "RETOFCAP"
|
|
}
|
|
memo += " (" + security.Symbol + ")"
|
|
|
|
var total big.Rat
|
|
total.Set(&retofcap.Total.Rat)
|
|
if ok, _ := retofcap.Currency.Valid(); ok {
|
|
total.Mul(&total, &retofcap.Currency.CurRate.Rat)
|
|
}
|
|
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + retofcap.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
total.Neg(&total)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: IncomeAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + retofcap.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) GetInvSellTran(sell *ofxgo.InvSell, curdef *Security, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&sell.InvTran)
|
|
|
|
security, err := i.GetSecurityAlternateId(string(sell.SecID.UniqueID), Stock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
memo := string(sell.InvTran.Memo)
|
|
if len(memo) > 0 {
|
|
memo += " "
|
|
}
|
|
|
|
var commission, taxes, fees, load, total, tradingTotal big.Rat
|
|
commission.Set(&sell.Commission.Rat)
|
|
taxes.Set(&sell.Taxes.Rat)
|
|
fees.Set(&sell.Fees.Rat)
|
|
load.Set(&sell.Load.Rat)
|
|
total.Set(&sell.Total.Rat)
|
|
|
|
tradingTotal.Neg(&total)
|
|
tradingTotal.Sub(&tradingTotal, &commission)
|
|
tradingTotal.Sub(&tradingTotal, &taxes)
|
|
tradingTotal.Sub(&tradingTotal, &fees)
|
|
tradingTotal.Sub(&tradingTotal, &load)
|
|
|
|
// Convert amounts to account's currency if Currency is set
|
|
if ok, _ := sell.Currency.Valid(); ok {
|
|
commission.Mul(&commission, &sell.Currency.CurRate.Rat)
|
|
taxes.Mul(&taxes, &sell.Currency.CurRate.Rat)
|
|
fees.Mul(&fees, &sell.Currency.CurRate.Rat)
|
|
load.Mul(&load, &sell.Currency.CurRate.Rat)
|
|
total.Mul(&total, &sell.Currency.CurRate.Rat)
|
|
tradingTotal.Mul(&tradingTotal, &sell.Currency.CurRate.Rat)
|
|
}
|
|
|
|
if num := commission.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Commission,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo + "(commission)",
|
|
Amount: commission.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := taxes.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Taxes,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo + "(taxes)",
|
|
Amount: taxes.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := fees.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Fees,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo + "(fees)",
|
|
Amount: fees.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
if num := load.Num(); !num.IsInt64() || num.Int64() != 0 {
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: Load,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo + "(load)",
|
|
Amount: load.FloatString(curdef.Precision),
|
|
})
|
|
}
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ImportAccount,
|
|
AccountId: account.AccountId,
|
|
SecurityId: -1,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: total.FloatString(curdef.Precision),
|
|
})
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: TradingAccount,
|
|
AccountId: -1,
|
|
SecurityId: curdef.SecurityId,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: tradingTotal.FloatString(curdef.Precision),
|
|
})
|
|
|
|
var units big.Rat
|
|
units.Set(&sell.Units.Rat)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: SubAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
units.Neg(&units)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: TradingAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + sell.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) GetTransferTran(transfer *ofxgo.Transfer, account *Account) (*Transaction, error) {
|
|
t := i.GetInvTran(&transfer.InvTran)
|
|
|
|
security, err := i.GetSecurityAlternateId(string(transfer.SecID.UniqueID), Stock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
memo := string(transfer.InvTran.Memo)
|
|
|
|
var units big.Rat
|
|
if transfer.TferAction == ofxgo.TferActionIn {
|
|
units.Set(&transfer.Units.Rat)
|
|
} else {
|
|
units.Neg(&transfer.Units.Rat)
|
|
}
|
|
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: SubAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + transfer.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
units.Neg(&units)
|
|
t.Splits = append(t.Splits, &Split{
|
|
// TODO ReversalFiTID?
|
|
Status: Imported,
|
|
ImportSplitType: ExternalAccount,
|
|
AccountId: -1,
|
|
SecurityId: security.SecurityId,
|
|
RemoteId: "ofx:" + transfer.InvTran.FiTID.String(),
|
|
Memo: memo,
|
|
Amount: units.FloatString(security.Precision),
|
|
})
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (i *OFXImport) AddInvTransaction(invtran *ofxgo.InvTransaction, account *Account, curdef *Security) error {
|
|
if curdef.SecurityId < 1 || curdef.SecurityId > int64(len(i.Securities)) {
|
|
return errors.New("Internal error: security index not found in OFX import\n")
|
|
}
|
|
|
|
var t *Transaction
|
|
var err error
|
|
if tran, ok := (*invtran).(ofxgo.BuyDebt); ok {
|
|
t, err = i.GetInvBuyTran(&tran.InvBuy, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.BuyMF); ok {
|
|
t, err = i.GetInvBuyTran(&tran.InvBuy, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.BuyOpt); ok {
|
|
t, err = i.GetInvBuyTran(&tran.InvBuy, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.BuyOther); ok {
|
|
t, err = i.GetInvBuyTran(&tran.InvBuy, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.BuyStock); ok {
|
|
t, err = i.GetInvBuyTran(&tran.InvBuy, curdef, account)
|
|
// } else if tran, ok := (*invtran).(ofxgo.ClosureOpt); ok {
|
|
// TODO implementme
|
|
} else if tran, ok := (*invtran).(ofxgo.Income); ok {
|
|
t, err = i.GetIncomeTran(&tran, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.InvExpense); ok {
|
|
t, err = i.GetInvExpenseTran(&tran, curdef, account)
|
|
// } else if tran, ok := (*invtran).(ofxgo.JrnlFund); ok {
|
|
// TODO implementme
|
|
// } else if tran, ok := (*invtran).(ofxgo.JrnlSec); ok {
|
|
// TODO implementme
|
|
} else if tran, ok := (*invtran).(ofxgo.MarginInterest); ok {
|
|
t, err = i.GetMarginInterestTran(&tran, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.Reinvest); ok {
|
|
t, err = i.GetReinvestTran(&tran, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.RetOfCap); ok {
|
|
t, err = i.GetRetOfCapTran(&tran, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.SellDebt); ok {
|
|
t, err = i.GetInvSellTran(&tran.InvSell, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.SellMF); ok {
|
|
t, err = i.GetInvSellTran(&tran.InvSell, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.SellOpt); ok {
|
|
t, err = i.GetInvSellTran(&tran.InvSell, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.SellOther); ok {
|
|
t, err = i.GetInvSellTran(&tran.InvSell, curdef, account)
|
|
} else if tran, ok := (*invtran).(ofxgo.SellStock); ok {
|
|
t, err = i.GetInvSellTran(&tran.InvSell, curdef, account)
|
|
// } else if tran, ok := (*invtran).(ofxgo.Split); ok {
|
|
// TODO implementme
|
|
} else if tran, ok := (*invtran).(ofxgo.Transfer); ok {
|
|
t, err = i.GetTransferTran(&tran, account)
|
|
} else {
|
|
return errors.New("Unrecognized type satisfying ofxgo.InvTransaction interface: " + (*invtran).TransactionType())
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
i.Transactions = append(i.Transactions, *t)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (i *OFXImport) importOFXInv(stmt *ofxgo.InvStatementResponse) error {
|
|
security, err := i.GetAddCurrency(stmt.CurDef.String())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
account := Account{
|
|
AccountId: int64(len(i.Accounts) + 1),
|
|
ExternalAccountId: stmt.InvAcctFrom.AcctID.String(),
|
|
SecurityId: security.SecurityId,
|
|
ParentAccountId: -1,
|
|
Type: Investment,
|
|
}
|
|
i.Accounts = append(i.Accounts, account)
|
|
|
|
if stmt.InvTranList != nil {
|
|
for _, invtran := range stmt.InvTranList.InvTransactions {
|
|
if err := i.AddInvTransaction(&invtran, &account, security); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, bt := range stmt.InvTranList.BankTransactions {
|
|
// TODO Should we do something different for the value of
|
|
// bt.SubAcctFund?
|
|
for _, tran := range bt.Transactions {
|
|
if err := i.AddTransaction(&tran, &account); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO InvPosList
|
|
// TODO InvBal
|
|
// TODO Inv401K and INV401kBal???
|
|
|
|
return nil
|
|
}
|
|
|
|
func ImportOFX(r io.Reader) (*OFXImport, error) {
|
|
var i OFXImport
|
|
|
|
response, err := ofxgo.ParseResponse(r)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Unexpected error parsing OFX response: %s\n", err)
|
|
}
|
|
|
|
if response.Signon.Status.Code != 0 {
|
|
meaning, _ := response.Signon.Status.CodeMeaning()
|
|
return nil, fmt.Errorf("Nonzero signon status (%d: %s) with message: %s\n", response.Signon.Status.Code, meaning, response.Signon.Status.Message)
|
|
}
|
|
|
|
for _, bank := range response.Bank {
|
|
if stmt, ok := bank.(*ofxgo.StatementResponse); ok {
|
|
err = i.importOFXBank(stmt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &i, nil
|
|
}
|
|
}
|
|
for _, cc := range response.CreditCard {
|
|
if stmt, ok := cc.(*ofxgo.CCStatementResponse); ok {
|
|
err = i.importOFXCC(stmt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &i, nil
|
|
}
|
|
}
|
|
for _, seclist := range response.SecList {
|
|
if securitylist, ok := seclist.(*ofxgo.SecurityList); ok {
|
|
err = i.importSecurities(securitylist)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
for _, inv := range response.InvStmt {
|
|
if stmt, ok := inv.(*ofxgo.InvStatementResponse); ok {
|
|
err = i.importOFXInv(stmt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &i, nil
|
|
}
|
|
}
|
|
|
|
return nil, errors.New("No OFX statement found")
|
|
}
|