package main import ( "encoding/json" "errors" "gopkg.in/gorp.v1" "log" "net/http" "regexp" "strings" ) const ( Bank int64 = 1 Cash = 2 Asset = 3 Liability = 4 Investment = 5 Income = 6 Expense = 7 Trading = 8 ) type Account struct { AccountId int64 ExternalAccountId string UserId int64 SecurityId int64 ParentAccountId int64 // -1 if this account is at the root Type int64 Name string // monotonically-increasing account transaction version number. Used for // allowing a client to ensure they have a consistent version when paging // through transactions. AccountVersion int64 `json:"Version"` } type AccountList struct { Accounts *[]Account `json:"accounts"` } var accountTransactionsRE *regexp.Regexp var accountImportRE *regexp.Regexp func init() { accountTransactionsRE = regexp.MustCompile(`^/account/[0-9]+/transactions/?$`) accountImportRE = regexp.MustCompile(`^/account/[0-9]+/import/?$`) } func (a *Account) Write(w http.ResponseWriter) error { enc := json.NewEncoder(w) return enc.Encode(a) } func (a *Account) Read(json_str string) error { dec := json.NewDecoder(strings.NewReader(json_str)) return dec.Decode(a) } func (al *AccountList) Write(w http.ResponseWriter) error { enc := json.NewEncoder(w) return enc.Encode(al) } func GetAccount(accountid int64, userid int64) (*Account, error) { var a Account err := DB.SelectOne(&a, "SELECT * from accounts where UserId=? AND AccountId=?", userid, accountid) if err != nil { return nil, err } return &a, nil } func GetAccountTx(transaction *gorp.Transaction, accountid int64, userid int64) (*Account, error) { var a Account err := transaction.SelectOne(&a, "SELECT * from accounts where UserId=? AND AccountId=?", userid, accountid) if err != nil { return nil, err } return &a, nil } func GetAccounts(userid int64) (*[]Account, error) { var accounts []Account _, err := DB.Select(&accounts, "SELECT * from accounts where UserId=?", userid) if err != nil { return nil, err } return &accounts, nil } // Get (and attempt to create if it doesn't exist) the security/currency // trading account for the supplied security/currency func GetTradingAccount(userid int64, securityid int64) (*Account, error) { var tradingAccounts []Account //top-level 'Trading' account(s) var tradingAccount Account var accounts []Account //second-level security-specific trading account(s) var account Account transaction, err := DB.Begin() if err != nil { return nil, err } // Try to find the top-level trading account _, err = transaction.Select(&tradingAccounts, "SELECT * from accounts where UserId=? AND Name='Trading' AND ParentAccountId=-1 AND Type=? ORDER BY AccountId ASC LIMIT 1", userid, Trading) if err != nil { transaction.Rollback() return nil, err } if len(tradingAccounts) == 1 { tradingAccount = tradingAccounts[0] } else { tradingAccount.UserId = userid tradingAccount.Name = "Trading" tradingAccount.ParentAccountId = -1 tradingAccount.SecurityId = 840 /*USD*/ //FIXME SecurityId shouldn't matter for top-level trading account, but maybe we should grab the user's default tradingAccount.Type = Trading err = transaction.Insert(&tradingAccount) if err != nil { transaction.Rollback() return nil, err } } // Now, try to find the security-specific trading account _, err = transaction.Select(&accounts, "SELECT * from accounts where UserId=? AND SecurityId=? AND ParentAccountId=? ORDER BY AccountId ASC LIMIT 1", userid, securityid, tradingAccount.AccountId) if err != nil { transaction.Rollback() return nil, err } if len(accounts) == 1 { account = accounts[0] } else { security := GetSecurity(securityid) account.UserId = userid account.Name = security.Name account.ParentAccountId = tradingAccount.AccountId account.SecurityId = securityid account.Type = Trading err = transaction.Insert(&account) if err != nil { transaction.Rollback() return nil, err } } err = transaction.Commit() if err != nil { transaction.Rollback() return nil, err } return &account, nil } // Get (and attempt to create if it doesn't exist) the security/currency // imbalance account for the supplied security/currency func GetImbalanceAccount(userid int64, securityid int64) (*Account, error) { var imbalanceAccounts []Account //top-level imbalance account(s) var imbalanceAccount Account var accounts []Account //second-level security-specific imbalance account(s) var account Account transaction, err := DB.Begin() if err != nil { return nil, err } // Try to find the top-level imbalance account _, err = transaction.Select(&imbalanceAccounts, "SELECT * from accounts where UserId=? AND Name='Imbalances' AND ParentAccountId=-1 AND Type=? ORDER BY AccountId ASC LIMIT 1", userid, Bank) if err != nil { transaction.Rollback() return nil, err } if len(imbalanceAccounts) == 1 { imbalanceAccount = imbalanceAccounts[0] } else { imbalanceAccount.UserId = userid imbalanceAccount.Name = "Imbalances" imbalanceAccount.ParentAccountId = -1 imbalanceAccount.SecurityId = 840 /*USD*/ //FIXME SecurityId shouldn't matter for top-level imbalance account, but maybe we should grab the user's default imbalanceAccount.Type = Bank err = transaction.Insert(&imbalanceAccount) if err != nil { transaction.Rollback() return nil, err } } // Now, try to find the security-specific imbalances account _, err = transaction.Select(&accounts, "SELECT * from accounts where UserId=? AND SecurityId=? AND ParentAccountId=? ORDER BY AccountId ASC LIMIT 1", userid, securityid, imbalanceAccount.AccountId) if err != nil { transaction.Rollback() return nil, err } if len(accounts) == 1 { account = accounts[0] } else { security := GetSecurity(securityid) account.UserId = userid account.Name = security.Name account.ParentAccountId = imbalanceAccount.AccountId account.SecurityId = securityid account.Type = Bank err = transaction.Insert(&account) if err != nil { transaction.Rollback() return nil, err } } err = transaction.Commit() if err != nil { transaction.Rollback() return nil, err } return &account, nil } type ParentAccountMissingError struct{} func (pame ParentAccountMissingError) Error() string { return "Parent account missing" } func insertUpdateAccount(a *Account, insert bool) error { transaction, err := DB.Begin() if err != nil { return err } if a.ParentAccountId != -1 { existing, err := transaction.SelectInt("SELECT count(*) from accounts where AccountId=?", a.ParentAccountId) if err != nil { transaction.Rollback() return err } if existing != 1 { transaction.Rollback() return ParentAccountMissingError{} } } if insert { err = transaction.Insert(a) if err != nil { transaction.Rollback() return err } } else { oldacct, err := GetAccountTx(transaction, a.AccountId, a.UserId) if err != nil { transaction.Rollback() return err } a.AccountVersion = oldacct.AccountVersion + 1 count, err := transaction.Update(a) if err != nil { transaction.Rollback() return err } if count != 1 { transaction.Rollback() return errors.New("Updated more than one account") } } err = transaction.Commit() if err != nil { transaction.Rollback() return err } return nil } func InsertAccount(a *Account) error { return insertUpdateAccount(a, true) } func UpdateAccount(a *Account) error { return insertUpdateAccount(a, false) } func DeleteAccount(a *Account) error { transaction, err := DB.Begin() if err != nil { return err } if a.ParentAccountId != -1 { // Re-parent splits to this account's parent account if this account isn't a root account _, err = transaction.Exec("UPDATE splits SET AccountId=? WHERE AccountId=?", a.ParentAccountId, a.AccountId) if err != nil { transaction.Rollback() return err } } else { // Delete splits if this account is a root account _, err = transaction.Exec("DELETE FROM splits WHERE AccountId=?", a.AccountId) if err != nil { transaction.Rollback() return err } } // Re-parent child accounts to this account's parent account _, err = transaction.Exec("UPDATE accounts SET ParentAccountId=? WHERE ParentAccountId=?", a.ParentAccountId, a.AccountId) if err != nil { transaction.Rollback() return err } count, err := transaction.Delete(a) if err != nil { transaction.Rollback() return err } if count != 1 { transaction.Rollback() return errors.New("Was going to delete more than one account") } err = transaction.Commit() if err != nil { transaction.Rollback() return err } return nil } func AccountHandler(w http.ResponseWriter, r *http.Request) { user, err := GetUserFromSession(r) if err != nil { WriteError(w, 1 /*Not Signed In*/) return } if r.Method == "POST" { // if URL looks like /account/[0-9]+/import, use the account // import handler if accountImportRE.MatchString(r.URL.Path) { var accountid int64 n, err := GetURLPieces(r.URL.Path, "/account/%d", &accountid) if err != nil || n != 1 { WriteError(w, 999 /*Internal Error*/) log.Print(err) return } AccountImportHandler(w, r, user, accountid) return } account_json := r.PostFormValue("account") if account_json == "" { WriteError(w, 3 /*Invalid Request*/) return } var account Account err := account.Read(account_json) if err != nil { WriteError(w, 3 /*Invalid Request*/) return } account.AccountId = -1 account.UserId = user.UserId account.AccountVersion = 0 if GetSecurity(account.SecurityId) == nil { WriteError(w, 3 /*Invalid Request*/) return } err = InsertAccount(&account) if err != nil { if _, ok := err.(ParentAccountMissingError); ok { WriteError(w, 3 /*Invalid Request*/) } else { WriteError(w, 999 /*Internal Error*/) log.Print(err) } return } WriteSuccess(w) } else if r.Method == "GET" { var accountid int64 n, err := GetURLPieces(r.URL.Path, "/account/%d", &accountid) if err != nil || n != 1 { //Return all Accounts var al AccountList accounts, err := GetAccounts(user.UserId) if err != nil { WriteError(w, 999 /*Internal Error*/) log.Print(err) return } al.Accounts = accounts err = (&al).Write(w) if err != nil { WriteError(w, 999 /*Internal Error*/) log.Print(err) return } } else { // if URL looks like /account/[0-9]+/transactions, use the account // transaction handler if accountTransactionsRE.MatchString(r.URL.Path) { AccountTransactionsHandler(w, r, user, accountid) return } // Return Account with this Id account, err := GetAccount(accountid, user.UserId) if err != nil { WriteError(w, 3 /*Invalid Request*/) return } err = account.Write(w) if err != nil { WriteError(w, 999 /*Internal Error*/) log.Print(err) return } } } else { accountid, err := GetURLID(r.URL.Path) if err != nil { WriteError(w, 3 /*Invalid Request*/) return } if r.Method == "PUT" { account_json := r.PostFormValue("account") if account_json == "" { WriteError(w, 3 /*Invalid Request*/) return } var account Account err := account.Read(account_json) if err != nil || account.AccountId != accountid { WriteError(w, 3 /*Invalid Request*/) return } account.UserId = user.UserId if GetSecurity(account.SecurityId) == nil { WriteError(w, 3 /*Invalid Request*/) return } err = UpdateAccount(&account) if err != nil { WriteError(w, 999 /*Internal Error*/) log.Print(err) return } WriteSuccess(w) } else if r.Method == "DELETE" { accountid, err := GetURLID(r.URL.Path) if err != nil { WriteError(w, 3 /*Invalid Request*/) return } account, err := GetAccount(accountid, user.UserId) if err != nil { WriteError(w, 3 /*Invalid Request*/) return } err = DeleteAccount(account) if err != nil { WriteError(w, 999 /*Internal Error*/) log.Print(err) return } WriteSuccess(w) } } }