aclindsa/moneygo
1
0
Fork 0
mirror of https://github.com/aclindsa/moneygo.git synced 2025-06-30 19:48:38 -04:00
Code Issues Releases Wiki Activity

Use SQL transactions for the entirety of every request

Browse Source
This commit is contained in:
Aaron Lindsay
2017-10-14 14:20:50 -04:00
parent 6726d9cb2f
commit 4e53a5e59c
14 changed files with 496 additions and 989 deletions
Download Patch File Download Diff File Expand all files Collapse all files

369
internal/handlers/transactions.go
View File

@ -178,72 +178,48 @@ func (t *Transaction) Balanced(transaction *gorp.Transaction) (bool, error) {
return true, nil
}
func GetTransaction(db *DB, transactionid int64, userid int64) (*Transaction, error) {
func GetTransaction(tx *Tx, transactionid int64, userid int64) (*Transaction, error) {
var t Transaction
transaction, err := db.Begin()
err := tx.SelectOne(&t, "SELECT * from transactions where UserId=? AND TransactionId=?", userid, transactionid)
if err != nil {
return nil, err
}
err = transaction.SelectOne(&t, "SELECT * from transactions where UserId=? AND TransactionId=?", userid, transactionid)
_, err = tx.Select(&t.Splits, "SELECT * from splits where TransactionId=?", transactionid)
if err != nil {
transaction.Rollback()
return nil, err
}
_, err = transaction.Select(&t.Splits, "SELECT * from splits where TransactionId=?", transactionid)
if err != nil {
transaction.Rollback()
return nil, err
}
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return nil, err
}
return &t, nil
}
func GetTransactions(db *DB, userid int64) (*[]Transaction, error) {
func GetTransactions(tx *Tx, userid int64) (*[]Transaction, error) {
var transactions []Transaction
transaction, err := db.Begin()
if err != nil {
return nil, err
}
_, err = transaction.Select(&transactions, "SELECT * from transactions where UserId=?", userid)
_, err := tx.Select(&transactions, "SELECT * from transactions where UserId=?", userid)
if err != nil {
return nil, err
}
for i := range transactions {
_, err := transaction.Select(&transactions[i].Splits, "SELECT * from splits where TransactionId=?", transactions[i].TransactionId)
_, err := tx.Select(&transactions[i].Splits, "SELECT * from splits where TransactionId=?", transactions[i].TransactionId)
if err != nil {
return nil, err
}
}
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return nil, err
}
return &transactions, nil
}
func incrementAccountVersions(transaction *gorp.Transaction, user *User, accountids []int64) error {
func incrementAccountVersions(tx *Tx, user *User, accountids []int64) error {
for i := range accountids {
account, err := GetAccountTx(transaction, accountids[i], user.UserId)
account, err := GetAccountTx(tx, accountids[i], user.UserId)
if err != nil {
return err
}
account.AccountVersion++
count, err := transaction.Update(account)
count, err := tx.Update(account)
if err != nil {
return err
}
@ -260,12 +236,12 @@ func (ame AccountMissingError) Error() string {
return "Account missing"
}
func InsertTransactionTx(transaction *gorp.Transaction, t *Transaction, user *User) error {
func InsertTransactionTx(tx *Tx, t *Transaction, user *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 := transaction.SelectInt("SELECT count(*) from accounts where AccountId=?", t.Splits[i].AccountId)
existing, err := tx.SelectInt("SELECT count(*) from accounts where AccountId=?", t.Splits[i].AccountId)
if err != nil {
return err
}
@ -287,13 +263,13 @@ func InsertTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
if len(a_ids) < 1 {
return AccountMissingError{}
}
err := incrementAccountVersions(transaction, user, a_ids)
err := incrementAccountVersions(tx, user, a_ids)
if err != nil {
return err
}
t.UserId = user.UserId
err = transaction.Insert(t)
err = tx.Insert(t)
if err != nil {
return err
}
@ -301,7 +277,7 @@ func InsertTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
for i := range t.Splits {
t.Splits[i].TransactionId = t.TransactionId
t.Splits[i].SplitId = -1
err = transaction.Insert(t.Splits[i])
err = tx.Insert(t.Splits[i])
if err != nil {
return err
}
@ -310,31 +286,19 @@ func InsertTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
return nil
}
func InsertTransaction(db *DB, t *Transaction, user *User) error {
transaction, err := db.Begin()
func InsertTransaction(tx *Tx, t *Transaction, user *User) error {
err := InsertTransactionTx(tx, t, user)
if err != nil {
return err
}
err = InsertTransactionTx(transaction, t, user)
if err != nil {
transaction.Rollback()
return err
}
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return err
}
return nil
}
func UpdateTransactionTx(transaction *gorp.Transaction, t *Transaction, user *User) error {
func UpdateTransactionTx(tx *Tx, t *Transaction, user *User) error {
var existing_splits []*Split
_, err := transaction.Select(&existing_splits, "SELECT * from splits where TransactionId=?", t.TransactionId)
_, err := tx.Select(&existing_splits, "SELECT * from splits where TransactionId=?", t.TransactionId)
if err != nil {
return err
}
@ -353,7 +317,7 @@ func UpdateTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
t.Splits[i].TransactionId = t.TransactionId
_, ok := s_map[t.Splits[i].SplitId]
if ok {
count, err := transaction.Update(t.Splits[i])
count, err := tx.Update(t.Splits[i])
if err != nil {
return err
}
@ -363,7 +327,7 @@ func UpdateTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
delete(s_map, t.Splits[i].SplitId)
} else {
t.Splits[i].SplitId = -1
err := transaction.Insert(t.Splits[i])
err := tx.Insert(t.Splits[i])
if err != nil {
return err
}
@ -380,7 +344,7 @@ func UpdateTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
a_map[existing_splits[i].AccountId] = true
}
if ok {
_, err := transaction.Delete(existing_splits[i])
_, err := tx.Delete(existing_splits[i])
if err != nil {
return err
}
@ -392,12 +356,12 @@ func UpdateTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
for id := range a_map {
a_ids = append(a_ids, id)
}
err = incrementAccountVersions(transaction, user, a_ids)
err = incrementAccountVersions(tx, user, a_ids)
if err != nil {
return err
}
count, err := transaction.Update(t)
count, err := tx.Update(t)
if err != nil {
return err
}
@ -408,257 +372,165 @@ func UpdateTransactionTx(transaction *gorp.Transaction, t *Transaction, user *Us
return nil
}
func DeleteTransaction(db *DB, t *Transaction, user *User) error {
transaction, err := db.Begin()
if err != nil {
return err
}
func DeleteTransaction(tx *Tx, t *Transaction, user *User) error {
var accountids []int64
_, err = transaction.Select(&accountids, "SELECT DISTINCT AccountId FROM splits WHERE TransactionId=? AND AccountId != -1", t.TransactionId)
_, err := tx.Select(&accountids, "SELECT DISTINCT AccountId FROM splits WHERE TransactionId=? AND AccountId != -1", t.TransactionId)
if err != nil {
transaction.Rollback()
return err
}
_, err = transaction.Exec("DELETE FROM splits WHERE TransactionId=?", t.TransactionId)
_, err = tx.Exec("DELETE FROM splits WHERE TransactionId=?", t.TransactionId)
if err != nil {
transaction.Rollback()
return err
}
count, err := transaction.Delete(t)
count, err := tx.Delete(t)
if err != nil {
transaction.Rollback()
return err
}
if count != 1 {
transaction.Rollback()
return errors.New("Deleted more than one transaction")
}
err = incrementAccountVersions(transaction, user, accountids)
err = incrementAccountVersions(tx, user, accountids)
if err != nil {
transaction.Rollback()
return err
}
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return err
}
return nil
}
func TransactionHandler(w http.ResponseWriter, r *http.Request, db *DB) {
user, err := GetUserFromSession(db, r)
func TransactionHandler(r *http.Request, tx *Tx) ResponseWriterWriter {
user, err := GetUserFromSession(tx, r)
if err != nil {
WriteError(w, 1 /*Not Signed In*/)
return
return NewError(1 /*Not Signed In*/)
}
if r.Method == "POST" {
transaction_json := r.PostFormValue("transaction")
if transaction_json == "" {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
var transaction Transaction
err := transaction.Read(transaction_json)
if err != nil {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
transaction.TransactionId = -1
transaction.UserId = user.UserId
sqltx, err := db.Begin()
balanced, err := transaction.Balanced(tx)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
return NewError(999 /*Internal Error*/)
log.Print(err)
return
}
balanced, err := transaction.Balanced(sqltx)
if err != nil {
sqltx.Rollback()
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
if !transaction.Valid() || !balanced {
sqltx.Rollback()
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
for i := range transaction.Splits {
transaction.Splits[i].SplitId = -1
_, err := GetAccountTx(sqltx, transaction.Splits[i].AccountId, user.UserId)
_, err := GetAccountTx(tx, transaction.Splits[i].AccountId, user.UserId)
if err != nil {
sqltx.Rollback()
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
}
err = InsertTransactionTx(sqltx, &transaction, user)
err = InsertTransactionTx(tx, &transaction, user)
if err != nil {
if _, ok := err.(AccountMissingError); ok {
WriteError(w, 3 /*Invalid Request*/)
return NewError(3 /*Invalid Request*/)
} else {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return NewError(999 /*Internal Error*/)
}
sqltx.Rollback()
return
}
err = sqltx.Commit()
if err != nil {
sqltx.Rollback()
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
err = transaction.Write(w)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
return &transaction
} else if r.Method == "GET" {
transactionid, err := GetURLID(r.URL.Path)
if err != nil {
//Return all Transactions
var al TransactionList
transactions, err := GetTransactions(db, user.UserId)
transactions, err := GetTransactions(tx, user.UserId)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
return NewError(999 /*Internal Error*/)
}
al.Transactions = transactions
err = (&al).Write(w)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
return &al
} else {
//Return Transaction with this Id
transaction, err := GetTransaction(db, transactionid, user.UserId)
transaction, err := GetTransaction(tx, transactionid, user.UserId)
if err != nil {
WriteError(w, 3 /*Invalid Request*/)
return
}
err = transaction.Write(w)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
return NewError(3 /*Invalid Request*/)
}
return transaction
}
} else {
transactionid, err := GetURLID(r.URL.Path)
if err != nil {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
if r.Method == "PUT" {
transaction_json := r.PostFormValue("transaction")
if transaction_json == "" {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
var transaction Transaction
err := transaction.Read(transaction_json)
if err != nil || transaction.TransactionId != transactionid {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
transaction.UserId = user.UserId
sqltx, err := db.Begin()
balanced, err := transaction.Balanced(tx)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
balanced, err := transaction.Balanced(sqltx)
if err != nil {
sqltx.Rollback()
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
return NewError(999 /*Internal Error*/)
}
if !transaction.Valid() || !balanced {
sqltx.Rollback()
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
for i := range transaction.Splits {
_, err := GetAccountTx(sqltx, transaction.Splits[i].AccountId, user.UserId)
_, err := GetAccountTx(tx, transaction.Splits[i].AccountId, user.UserId)
if err != nil {
sqltx.Rollback()
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
}
err = UpdateTransactionTx(sqltx, &transaction, user)
err = UpdateTransactionTx(tx, &transaction, user)
if err != nil {
sqltx.Rollback()
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
return NewError(999 /*Internal Error*/)
}
err = sqltx.Commit()
if err != nil {
sqltx.Rollback()
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
err = transaction.Write(w)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
return &transaction
} else if r.Method == "DELETE" {
transactionid, err := GetURLID(r.URL.Path)
if err != nil {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
transaction, err := GetTransaction(db, transactionid, user.UserId)
transaction, err := GetTransaction(tx, transactionid, user.UserId)
if err != nil {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
err = DeleteTransaction(db, transaction, user)
err = DeleteTransaction(tx, transaction, user)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
return NewError(999 /*Internal Error*/)
}
WriteSuccess(w)
return SuccessWriter{}
}
}
return NewError(3 /*Invalid Request*/)
}
func TransactionsBalanceDifference(transaction *gorp.Transaction, accountid int64, transactions []Transaction) (*big.Rat, error) {
@ -685,17 +557,12 @@ func TransactionsBalanceDifference(transaction *gorp.Transaction, accountid int6
return &pageDifference, nil
}
func GetAccountBalance(db *DB, user *User, accountid int64) (*big.Rat, error) {
func GetAccountBalance(tx *Tx, user *User, accountid int64) (*big.Rat, error) {
var splits []Split
transaction, err := db.Begin()
if err != nil {
return nil, err
}
sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=?"
_, err = transaction.Select(&splits, sql, accountid, user.UserId)
_, err := tx.Select(&splits, sql, accountid, user.UserId)
if err != nil {
transaction.Rollback()
return nil, err
}
@ -703,34 +570,22 @@ func GetAccountBalance(db *DB, user *User, accountid int64) (*big.Rat, error) {
for _, s := range splits {
rat_amount, err := GetBigAmount(s.Amount)
if err != nil {
transaction.Rollback()
return nil, err
}
tmp.Add(&balance, rat_amount)
balance.Set(&tmp)
}
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return nil, err
}
return &balance, nil
}
// Assumes accountid is valid and is owned by the current user
func GetAccountBalanceDate(db *DB, user *User, accountid int64, date *time.Time) (*big.Rat, error) {
func GetAccountBalanceDate(tx *Tx, user *User, accountid int64, date *time.Time) (*big.Rat, error) {
var splits []Split
transaction, err := db.Begin()
if err != nil {
return nil, err
}
sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=? AND transactions.Date < ?"
_, err = transaction.Select(&splits, sql, accountid, user.UserId, date)
_, err := tx.Select(&splits, sql, accountid, user.UserId, date)
if err != nil {
transaction.Rollback()
return nil, err
}
@ -738,33 +593,21 @@ func GetAccountBalanceDate(db *DB, user *User, accountid int64, date *time.Time)
for _, s := range splits {
rat_amount, err := GetBigAmount(s.Amount)
if err != nil {
transaction.Rollback()
return nil, err
}
tmp.Add(&balance, rat_amount)
balance.Set(&tmp)
}
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return nil, err
}
return &balance, nil
}
func GetAccountBalanceDateRange(db *DB, user *User, accountid int64, begin, end *time.Time) (*big.Rat, error) {
func GetAccountBalanceDateRange(tx *Tx, user *User, accountid int64, begin, end *time.Time) (*big.Rat, error) {
var splits []Split
transaction, err := db.Begin()
if err != nil {
return nil, err
}
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 = transaction.Select(&splits, sql, accountid, user.UserId, begin, end)
_, err := tx.Select(&splits, sql, accountid, user.UserId, begin, end)
if err != nil {
transaction.Rollback()
return nil, err
}
@ -772,31 +615,19 @@ func GetAccountBalanceDateRange(db *DB, user *User, accountid int64, begin, end
for _, s := range splits {
rat_amount, err := GetBigAmount(s.Amount)
if err != nil {
transaction.Rollback()
return nil, err
}
tmp.Add(&balance, rat_amount)
balance.Set(&tmp)
}
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return nil, err
}
return &balance, nil
}
func GetAccountTransactions(db *DB, user *User, accountid int64, sort string, page uint64, limit uint64) (*AccountTransactionsList, error) {
func GetAccountTransactions(tx *Tx, user *User, accountid int64, sort string, page uint64, limit uint64) (*AccountTransactionsList, error) {
var transactions []Transaction
var atl AccountTransactionsList
transaction, err := db.Begin()
if err != nil {
return nil, err
}
var sqlsort, balanceLimitOffset string
var balanceLimitOffsetArg uint64
if sort == "date-asc" {
@ -804,9 +635,8 @@ func GetAccountTransactions(db *DB, user *User, accountid int64, sort string, pa
balanceLimitOffset = " LIMIT ?"
balanceLimitOffsetArg = page * limit
} else if sort == "date-desc" {
numSplits, err := transaction.SelectInt("SELECT count(*) FROM splits")
numSplits, err := tx.SelectInt("SELECT count(*) FROM splits")
if err != nil {
transaction.Rollback()
return nil, err
}
sqlsort = " ORDER BY transactions.Date DESC"
@ -819,41 +649,35 @@ func GetAccountTransactions(db *DB, user *User, accountid int64, sort string, pa
sqloffset = fmt.Sprintf(" OFFSET %d", page*limit)
}
account, err := GetAccountTx(transaction, accountid, user.UserId)
account, err := GetAccountTx(tx, accountid, user.UserId)
if err != nil {
transaction.Rollback()
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 = transaction.Select(&transactions, sql, user.UserId, accountid, limit)
_, err = tx.Select(&transactions, sql, user.UserId, accountid, limit)
if err != nil {
transaction.Rollback()
return nil, err
}
atl.Transactions = &transactions
pageDifference, err := TransactionsBalanceDifference(transaction, accountid, transactions)
pageDifference, err := TransactionsBalanceDifference(tx, accountid, transactions)
if err != nil {
transaction.Rollback()
return nil, err
}
count, err := transaction.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)
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 {
transaction.Rollback()
return nil, err
}
atl.TotalTransactions = count
security, err := GetSecurityTx(transaction, atl.Account.SecurityId, user.UserId)
security, err := GetSecurityTx(tx, atl.Account.SecurityId, user.UserId)
if err != nil {
transaction.Rollback()
return nil, err
}
if security == nil {
transaction.Rollback()
return nil, errors.New("Security not found")
}
@ -861,9 +685,8 @@ func GetAccountTransactions(db *DB, user *User, accountid int64, sort string, pa
// occurred before the page we're returning
var amounts []string
sql = "SELECT splits.Amount FROM splits WHERE splits.AccountId=? AND splits.TransactionId IN (SELECT DISTINCT transactions.TransactionId FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?" + sqlsort + balanceLimitOffset + ")"
_, err = transaction.Select(&amounts, sql, accountid, user.UserId, accountid, balanceLimitOffsetArg)
_, err = tx.Select(&amounts, sql, accountid, user.UserId, accountid, balanceLimitOffsetArg)
if err != nil {
transaction.Rollback()
return nil, err
}
@ -871,7 +694,6 @@ func GetAccountTransactions(db *DB, user *User, accountid int64, sort string, pa
for _, amount := range amounts {
rat_amount, err := GetBigAmount(amount)
if err != nil {
transaction.Rollback()
return nil, err
}
tmp.Add(&balance, rat_amount)
@ -880,20 +702,12 @@ func GetAccountTransactions(db *DB, user *User, accountid int64, sort string, pa
atl.BeginningBalance = balance.FloatString(security.Precision)
atl.EndingBalance = tmp.Add(&balance, pageDifference).FloatString(security.Precision)
err = transaction.Commit()
if err != nil {
transaction.Rollback()
return nil, err
}
return &atl, nil
}
// Return only those transactions which have at least one split pertaining to
// an account
func AccountTransactionsHandler(db *DB, w http.ResponseWriter, r *http.Request,
user *User, accountid int64) {
func AccountTransactionsHandler(tx *Tx, r *http.Request, user *User, accountid int64) ResponseWriterWriter {
var page uint64 = 0
var limit uint64 = 50
var sort string = "date-desc"
@ -904,8 +718,7 @@ func AccountTransactionsHandler(db *DB, w http.ResponseWriter, r *http.Request,
if pagestring != "" {
p, err := strconv.ParseUint(pagestring, 10, 0)
if err != nil {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
page = p
}
@ -914,8 +727,7 @@ func AccountTransactionsHandler(db *DB, w http.ResponseWriter, r *http.Request,
if limitstring != "" {
l, err := strconv.ParseUint(limitstring, 10, 0)
if err != nil || l > 100 {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
limit = l
}
@ -923,23 +735,16 @@ func AccountTransactionsHandler(db *DB, w http.ResponseWriter, r *http.Request,
sortstring := query.Get("sort")
if sortstring != "" {
if sortstring != "date-asc" && sortstring != "date-desc" {
WriteError(w, 3 /*Invalid Request*/)
return
return NewError(3 /*Invalid Request*/)
}
sort = sortstring
}
accountTransactions, err := GetAccountTransactions(db, user, accountid, sort, page, limit)
accountTransactions, err := GetAccountTransactions(tx, user, accountid, sort, page, limit)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
return NewError(999 /*Internal Error*/)
}
err = accountTransactions.Write(w)
if err != nil {
WriteError(w, 999 /*Internal Error*/)
log.Print(err)
return
}
return accountTransactions
}