mirror of https://github.com/aclindsa/moneygo.git
465 lines
13 KiB
Go
465 lines
13 KiB
Go
package db
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/aclindsa/moneygo/internal/models"
|
|
"github.com/aclindsa/moneygo/internal/store"
|
|
"math/big"
|
|
"time"
|
|
)
|
|
|
|
// Split is a mirror of models.Split with the Amount broken out into whole and
|
|
// fractional components
|
|
type Split struct {
|
|
SplitId int64
|
|
TransactionId int64
|
|
Status int64
|
|
ImportSplitType int64
|
|
|
|
// One of AccountId and SecurityId must be -1
|
|
// In normal splits, AccountId will be valid and SecurityId will be -1. The
|
|
// only case where this is reversed is for transactions that have been
|
|
// imported and not yet associated with an account.
|
|
AccountId int64
|
|
SecurityId int64
|
|
|
|
RemoteId string // unique ID from server, for detecting duplicates
|
|
Number string // Check or reference number
|
|
Memo string
|
|
|
|
// Amount.Whole and Amount.Fractional(MaxPrecision)
|
|
WholeAmount int64
|
|
FractionalAmount int64
|
|
}
|
|
|
|
func NewSplit(s *models.Split) (*Split, error) {
|
|
whole, err := s.Amount.Whole()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fractional, err := s.Amount.Fractional(MaxPrecision)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Split{
|
|
SplitId: s.SplitId,
|
|
TransactionId: s.TransactionId,
|
|
Status: s.Status,
|
|
ImportSplitType: s.ImportSplitType,
|
|
AccountId: s.AccountId,
|
|
SecurityId: s.SecurityId,
|
|
RemoteId: s.RemoteId,
|
|
Number: s.Number,
|
|
Memo: s.Memo,
|
|
WholeAmount: whole,
|
|
FractionalAmount: fractional,
|
|
}, nil
|
|
}
|
|
|
|
func (s Split) Split() *models.Split {
|
|
split := &models.Split{
|
|
SplitId: s.SplitId,
|
|
TransactionId: s.TransactionId,
|
|
Status: s.Status,
|
|
ImportSplitType: s.ImportSplitType,
|
|
AccountId: s.AccountId,
|
|
SecurityId: s.SecurityId,
|
|
RemoteId: s.RemoteId,
|
|
Number: s.Number,
|
|
Memo: s.Memo,
|
|
}
|
|
split.Amount.FromParts(s.WholeAmount, s.FractionalAmount, MaxPrecision)
|
|
|
|
return split
|
|
}
|
|
|
|
func (tx *Tx) incrementAccountVersions(user *models.User, accountids []int64) error {
|
|
for i := range accountids {
|
|
account, err := tx.GetAccount(accountids[i], user.UserId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
account.AccountVersion++
|
|
count, err := tx.Update(account)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count != 1 {
|
|
return errors.New("Updated more than one account")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (tx *Tx) InsertTransaction(t *models.Transaction, user *models.User) error {
|
|
// Map of any accounts with transaction splits being added
|
|
a_map := make(map[int64]bool)
|
|
for i := range t.Splits {
|
|
if t.Splits[i].AccountId != -1 {
|
|
existing, err := tx.SelectInt("SELECT count(*) from accounts where AccountId=?", t.Splits[i].AccountId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if existing != 1 {
|
|
return store.AccountMissingError{}
|
|
}
|
|
a_map[t.Splits[i].AccountId] = true
|
|
} else if t.Splits[i].SecurityId == -1 {
|
|
return store.AccountMissingError{}
|
|
}
|
|
}
|
|
|
|
//increment versions for all accounts
|
|
var a_ids []int64
|
|
for id := range a_map {
|
|
a_ids = append(a_ids, id)
|
|
}
|
|
// ensure at least one of the splits is associated with an actual account
|
|
if len(a_ids) < 1 {
|
|
return store.AccountMissingError{}
|
|
}
|
|
err := tx.incrementAccountVersions(user, a_ids)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
t.UserId = user.UserId
|
|
err = tx.Insert(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := range t.Splits {
|
|
t.Splits[i].TransactionId = t.TransactionId
|
|
t.Splits[i].SplitId = -1
|
|
s, err := NewSplit(t.Splits[i])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = tx.Insert(s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*t.Splits[i] = *s.Split()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (tx *Tx) SplitExists(s *models.Split) (bool, error) {
|
|
count, err := tx.SelectInt("SELECT COUNT(*) from splits where RemoteId=? and AccountId=?", s.RemoteId, s.AccountId)
|
|
return count == 1, err
|
|
}
|
|
|
|
func (tx *Tx) GetTransaction(transactionid int64, userid int64) (*models.Transaction, error) {
|
|
var t models.Transaction
|
|
var splits []*Split
|
|
|
|
err := tx.SelectOne(&t, "SELECT * from transactions where UserId=? AND TransactionId=?", userid, transactionid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
_, err = tx.Select(&splits, "SELECT * from splits where TransactionId=?", transactionid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, split := range splits {
|
|
t.Splits = append(t.Splits, split.Split())
|
|
}
|
|
|
|
return &t, nil
|
|
}
|
|
|
|
func (tx *Tx) GetTransactions(userid int64) (*[]*models.Transaction, error) {
|
|
var transactions []*models.Transaction
|
|
|
|
_, err := tx.Select(&transactions, "SELECT * from transactions where UserId=?", userid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for i := range transactions {
|
|
var splits []*Split
|
|
_, err := tx.Select(&splits, "SELECT * from splits where TransactionId=?", transactions[i].TransactionId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, split := range splits {
|
|
transactions[i].Splits = append(transactions[i].Splits, split.Split())
|
|
}
|
|
}
|
|
|
|
return &transactions, nil
|
|
}
|
|
|
|
func (tx *Tx) UpdateTransaction(t *models.Transaction, user *models.User) error {
|
|
var existing_splits []*Split
|
|
|
|
_, err := tx.Select(&existing_splits, "SELECT * from splits where TransactionId=?", t.TransactionId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Map of any accounts with transaction splits being added
|
|
a_map := make(map[int64]bool)
|
|
|
|
// Make a map with any existing splits for this transaction
|
|
s_map := make(map[int64]bool)
|
|
for i := range existing_splits {
|
|
s_map[existing_splits[i].SplitId] = true
|
|
}
|
|
|
|
// Insert splits, updating any pre-existing ones
|
|
for i := range t.Splits {
|
|
t.Splits[i].TransactionId = t.TransactionId
|
|
s, err := NewSplit(t.Splits[i])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, ok := s_map[s.SplitId]
|
|
if ok {
|
|
count, err := tx.Update(s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count > 1 {
|
|
return fmt.Errorf("Updated %d transaction splits while attempting to update only 1", count)
|
|
}
|
|
delete(s_map, s.SplitId)
|
|
} else {
|
|
s.SplitId = -1
|
|
err := tx.Insert(s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
*t.Splits[i] = *s.Split()
|
|
if t.Splits[i].AccountId != -1 {
|
|
a_map[s.AccountId] = true
|
|
}
|
|
}
|
|
|
|
// Delete any remaining pre-existing splits
|
|
for i := range existing_splits {
|
|
_, ok := s_map[existing_splits[i].SplitId]
|
|
if existing_splits[i].AccountId != -1 {
|
|
a_map[existing_splits[i].AccountId] = true
|
|
}
|
|
if ok {
|
|
_, err := tx.Delete(existing_splits[i])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
// Increment versions for all accounts with modified splits
|
|
var a_ids []int64
|
|
for id := range a_map {
|
|
a_ids = append(a_ids, id)
|
|
}
|
|
err = tx.incrementAccountVersions(user, a_ids)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
count, err := tx.Update(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count > 1 {
|
|
return fmt.Errorf("Updated %d transactions (expected 1)", count)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (tx *Tx) DeleteTransaction(t *models.Transaction, user *models.User) error {
|
|
var accountids []int64
|
|
_, err := tx.Select(&accountids, "SELECT DISTINCT AccountId FROM splits WHERE TransactionId=? AND AccountId != -1", t.TransactionId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = tx.Exec("DELETE FROM splits WHERE TransactionId=?", t.TransactionId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
count, err := tx.Delete(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count != 1 {
|
|
return errors.New("Deleted more than one transaction")
|
|
}
|
|
|
|
err = tx.incrementAccountVersions(user, accountids)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (tx *Tx) GetAccountSplits(user *models.User, accountid int64) (*[]*models.Split, error) {
|
|
var modelsplits []*models.Split
|
|
var splits []*Split
|
|
|
|
sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=?"
|
|
_, err := tx.Select(&splits, sql, accountid, user.UserId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, s := range splits {
|
|
modelsplits = append(modelsplits, s.Split())
|
|
}
|
|
return &modelsplits, nil
|
|
}
|
|
|
|
// Assumes accountid is valid and is owned by the current user
|
|
func (tx *Tx) GetAccountSplitsDate(user *models.User, accountid int64, date *time.Time) (*[]*models.Split, error) {
|
|
var modelsplits []*models.Split
|
|
var splits []*Split
|
|
|
|
sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=? AND transactions.Date < ?"
|
|
_, err := tx.Select(&splits, sql, accountid, user.UserId, date)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, s := range splits {
|
|
modelsplits = append(modelsplits, s.Split())
|
|
}
|
|
return &modelsplits, nil
|
|
}
|
|
|
|
func (tx *Tx) GetAccountSplitsDateRange(user *models.User, accountid int64, begin, end *time.Time) (*[]*models.Split, error) {
|
|
var modelsplits []*models.Split
|
|
var splits []*Split
|
|
|
|
sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=? AND transactions.Date >= ? AND transactions.Date < ?"
|
|
_, err := tx.Select(&splits, sql, accountid, user.UserId, begin, end)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, s := range splits {
|
|
modelsplits = append(modelsplits, s.Split())
|
|
}
|
|
return &modelsplits, nil
|
|
}
|
|
|
|
func (tx *Tx) transactionsBalanceDifference(accountid int64, transactions []*models.Transaction) (*big.Rat, error) {
|
|
var pageDifference big.Rat
|
|
for i := range transactions {
|
|
var splits []*Split
|
|
_, err := tx.Select(&splits, "SELECT * FROM splits where TransactionId=?", transactions[i].TransactionId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Sum up the amounts from the splits we're returning so we can return
|
|
// an ending balance
|
|
for j, s := range splits {
|
|
transactions[i].Splits = append(transactions[i].Splits, s.Split())
|
|
if transactions[i].Splits[j].AccountId == accountid {
|
|
pageDifference.Add(&pageDifference, &transactions[i].Splits[j].Amount.Rat)
|
|
}
|
|
}
|
|
}
|
|
return &pageDifference, nil
|
|
}
|
|
|
|
func (tx *Tx) GetAccountTransactions(user *models.User, accountid int64, sort string, page uint64, limit uint64) (*models.AccountTransactionsList, error) {
|
|
var transactions []*models.Transaction
|
|
var atl models.AccountTransactionsList
|
|
|
|
var sqlsort, balanceLimitOffset string
|
|
var balanceLimitOffsetArg uint64
|
|
if sort == "date-asc" {
|
|
sqlsort = " ORDER BY transactions.Date ASC, transactions.TransactionId ASC"
|
|
balanceLimitOffset = " LIMIT ?"
|
|
balanceLimitOffsetArg = page * limit
|
|
} else if sort == "date-desc" {
|
|
numSplits, err := tx.SelectInt("SELECT count(*) FROM splits")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sqlsort = " ORDER BY transactions.Date DESC, transactions.TransactionId DESC"
|
|
balanceLimitOffset = fmt.Sprintf(" LIMIT %d OFFSET ?", numSplits)
|
|
balanceLimitOffsetArg = (page + 1) * limit
|
|
}
|
|
|
|
var sqloffset string
|
|
if page > 0 {
|
|
sqloffset = fmt.Sprintf(" OFFSET %d", page*limit)
|
|
}
|
|
|
|
account, err := tx.GetAccount(accountid, user.UserId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
atl.Account = account
|
|
|
|
sql := "SELECT DISTINCT transactions.* FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?" + sqlsort + " LIMIT ?" + sqloffset
|
|
_, err = tx.Select(&transactions, sql, user.UserId, accountid, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
atl.Transactions = &transactions
|
|
|
|
pageDifference, err := tx.transactionsBalanceDifference(accountid, transactions)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
count, err := tx.SelectInt("SELECT count(DISTINCT transactions.TransactionId) FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?", user.UserId, accountid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
atl.TotalTransactions = count
|
|
|
|
security, err := tx.GetSecurity(atl.Account.SecurityId, user.UserId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if security == nil {
|
|
return nil, errors.New("Security not found")
|
|
}
|
|
|
|
// Sum all the splits for all transaction splits for this account that
|
|
// occurred before the page we're returning
|
|
sql = "FROM splits AS s INNER JOIN (SELECT DISTINCT transactions.Date, transactions.TransactionId FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?" + sqlsort + balanceLimitOffset + ") as t ON s.TransactionId = t.TransactionId WHERE s.AccountId=?"
|
|
count, err = tx.SelectInt("SELECT count(*) "+sql, user.UserId, accountid, balanceLimitOffsetArg, accountid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var balance models.Amount
|
|
|
|
// Don't attempt to 'sum()' the splits if none exist, because it is
|
|
// supposed to return null/nil in this case, which makes gorp angry since
|
|
// we're using SelectInt()
|
|
if count > 0 {
|
|
whole, err := tx.SelectInt("SELECT sum(s.WholeAmount) "+sql, user.UserId, accountid, balanceLimitOffsetArg, accountid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fractional, err := tx.SelectInt("SELECT sum(s.FractionalAmount) "+sql, user.UserId, accountid, balanceLimitOffsetArg, accountid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
balance.FromParts(whole, fractional, MaxPrecision)
|
|
}
|
|
|
|
atl.BeginningBalance = balance
|
|
atl.EndingBalance.Rat.Add(&balance.Rat, pageDifference)
|
|
|
|
return &atl, nil
|
|
}
|