;
114 | if (this.props.error.isError())
115 | errorAlert =
116 |
117 | Error!
118 | Error {this.props.error.ErrorId}: {this.props.error.ErrorString}
119 |
120 | ;
121 |
122 | return (
123 |
124 | {barContents}
125 | {errorAlert}
126 |
127 | );
128 | }
129 | }
130 |
131 | module.exports = TopBar;
132 |
--------------------------------------------------------------------------------
/internal/integration/balance_lua_test.go:
--------------------------------------------------------------------------------
1 | package integration_test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 | )
7 |
8 | func TestLuaBalances(t *testing.T) {
9 | RunWith(t, &data[0], func(t *testing.T, d *TestData) {
10 | accountid := d.accounts[3].AccountId
11 | symbol := d.securities[data[0].accounts[3].SecurityId].Symbol
12 |
13 | simpleLuaTest(t, d.clients[0], []LuaTest{
14 | {"Account:Balance()", fmt.Sprintf("return get_accounts()[%d]:Balance()", accountid), symbol + " 87.19"},
15 | {"Account:Balance(1)", fmt.Sprintf("return get_accounts()[%d]:Balance(date.new('2017-10-30')).Amount", accountid), "5.6"},
16 | {"Account:Balance(2)", fmt.Sprintf("return get_accounts()[%d]:Balance(date.new(2017, 10, 30), date.new('2017-11-01')).Amount", accountid), "81.59"},
17 | {"Security", fmt.Sprintf("return get_accounts()[%d]:Balance().Security.Symbol", accountid), symbol},
18 | {"__eq", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new(2017, 10, 30)) == (act:Balance(date.new('2017-10-29')) + 0.0)", accountid), "true"},
19 | {"not __eq", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new(2017, 10, 30)) == act:Balance(date.new('2017-11-01'))", accountid), "false"},
20 | {"__lt", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new(2017, 10, 14)) < act:Balance(date.new('2017-10-16'))", accountid), "true"},
21 | {"not __lt", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new(2017, 11, 01)) < act:Balance(date.new('2017-10-16'))", accountid), "false"},
22 | {"__le", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new(2017, 10, 14)) <= act:Balance(date.new('2017-10-16'))", accountid), "true"},
23 | {"__le (=)", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new(2017, 10, 16)) <= act:Balance(date.new('2017-10-17'))", accountid), "true"},
24 | {"not __le", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new(2017, 11, 01)) <= act:Balance(date.new('2017-10-16'))", accountid), "false"},
25 | {"__add", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) + act:Balance(date.new(2017, 10, 30), date.new('2017-11-01'))", accountid), symbol + " 87.19"},
26 | {"__add number", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) + 9", accountid), symbol + " 14.60"},
27 | {"__add to number", fmt.Sprintf("act = get_accounts()[%d]; return 5.489 + act:Balance(date.new(2017, 10, 30), date.new('2017-11-01'))", accountid), symbol + " 87.08"},
28 | {"__sub", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) - act:Balance(date.new(2017, 10, 30), date.new('2017-11-01'))", accountid), symbol + " -75.99"},
29 | {"__sub number", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) - 5", accountid), symbol + " 0.60"},
30 | {"__sub from number", fmt.Sprintf("act = get_accounts()[%d]; return 100 - act:Balance(date.new(2017, 10, 30), date.new('2017-11-01'))", accountid), symbol + " 18.41"},
31 | {"__mul", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) * act:Balance(date.new(2017, 10, 30), date.new('2017-11-01'))", accountid), symbol + " 456.90"},
32 | {"__mul number", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) * 5", accountid), symbol + " 28.00"},
33 | {"__mul with number", fmt.Sprintf("act = get_accounts()[%d]; return 11.1111 * act:Balance(date.new('2017-10-30')) * 5", accountid), symbol + " 311.11"},
34 | {"__div", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) / act:Balance(date.new(2017, 10, 30), date.new('2017-11-01'))", accountid), symbol + " 0.07"},
35 | {"__div number", fmt.Sprintf("act = get_accounts()[%d]; return act:Balance(date.new('2017-10-30')) / 5", accountid), symbol + " 1.12"},
36 | {"__div with number", fmt.Sprintf("act = get_accounts()[%d]; return 11.1111 / act:Balance(date.new('2017-10-30'))", accountid), symbol + " 1.98"},
37 | {"__unm", fmt.Sprintf("act = get_accounts()[%d]; return -act:Balance(date.new('2017-10-30'))", accountid), symbol + " -5.60"},
38 | })
39 | })
40 | }
41 |
--------------------------------------------------------------------------------
/internal/handlers/users.go:
--------------------------------------------------------------------------------
1 | package handlers
2 |
3 | import (
4 | "errors"
5 | "github.com/aclindsa/moneygo/internal/models"
6 | "github.com/aclindsa/moneygo/internal/store"
7 | "log"
8 | "net/http"
9 | )
10 |
11 | type UserExistsError struct{}
12 |
13 | func (ueu UserExistsError) Error() string {
14 | return "User exists"
15 | }
16 |
17 | func InsertUser(tx store.Tx, u *models.User) error {
18 | security_template := FindCurrencyTemplate(u.DefaultCurrency)
19 | if security_template == nil {
20 | return errors.New("Invalid ISO4217 Default Currency")
21 | }
22 |
23 | exists, err := tx.UsernameExists(u.Username)
24 | if err != nil {
25 | return err
26 | }
27 | if exists {
28 | return UserExistsError{}
29 | }
30 |
31 | err = tx.InsertUser(u)
32 | if err != nil {
33 | return err
34 | }
35 |
36 | // Copy the security template and give it our new UserId
37 | var security models.Security
38 | security = *security_template
39 | security.UserId = u.UserId
40 |
41 | err = tx.InsertSecurity(&security)
42 | if err != nil {
43 | return err
44 | }
45 |
46 | // Update the user's DefaultCurrency to our new SecurityId
47 | u.DefaultCurrency = security.SecurityId
48 | err = tx.UpdateUser(u)
49 | if err != nil {
50 | return err
51 | }
52 |
53 | return nil
54 | }
55 |
56 | func GetUserFromSession(tx store.Tx, r *http.Request) (*models.User, error) {
57 | s, err := GetSession(tx, r)
58 | if err != nil {
59 | return nil, err
60 | }
61 | return tx.GetUser(s.UserId)
62 | }
63 |
64 | func UpdateUser(tx store.Tx, u *models.User) error {
65 | security, err := tx.GetSecurity(u.DefaultCurrency, u.UserId)
66 | if err != nil {
67 | return err
68 | } else if security.UserId != u.UserId || security.SecurityId != u.DefaultCurrency {
69 | return errors.New("UserId and DefaultCurrency don't match the fetched security")
70 | } else if security.Type != models.Currency {
71 | return errors.New("New DefaultCurrency security is not a currency")
72 | }
73 |
74 | err = tx.UpdateUser(u)
75 | if err != nil {
76 | return err
77 | }
78 |
79 | return nil
80 | }
81 |
82 | func UserHandler(r *http.Request, context *Context) ResponseWriterWriter {
83 | if r.Method == "POST" {
84 | var user models.User
85 | if err := ReadJSON(r, &user); err != nil {
86 | return NewError(3 /*Invalid Request*/)
87 | }
88 | user.UserId = -1
89 | user.HashPassword()
90 |
91 | err := InsertUser(context.Tx, &user)
92 | if err != nil {
93 | if _, ok := err.(UserExistsError); ok {
94 | return NewError(4 /*User Exists*/)
95 | } else {
96 | log.Print(err)
97 | return NewError(999 /*Internal Error*/)
98 | }
99 | }
100 |
101 | return ResponseWrapper{201, &user}
102 | } else {
103 | user, err := GetUserFromSession(context.Tx, r)
104 | if err != nil {
105 | return NewError(1 /*Not Signed In*/)
106 | }
107 |
108 | userid, err := context.NextID()
109 | if err != nil {
110 | return NewError(3 /*Invalid Request*/)
111 | }
112 |
113 | if userid != user.UserId {
114 | return NewError(2 /*Unauthorized Access*/)
115 | }
116 |
117 | if r.Method == "GET" {
118 | return user
119 | } else if r.Method == "PUT" {
120 | // Save old PWHash in case the new password is bogus
121 | old_pwhash := user.PasswordHash
122 |
123 | if err := ReadJSON(r, &user); err != nil || user.UserId != userid {
124 | return NewError(3 /*Invalid Request*/)
125 | }
126 |
127 | // If the user didn't create a new password, keep their old one
128 | if user.Password != models.BogusPassword {
129 | user.HashPassword()
130 | } else {
131 | user.Password = ""
132 | user.PasswordHash = old_pwhash
133 | }
134 |
135 | err = UpdateUser(context.Tx, user)
136 | if err != nil {
137 | log.Print(err)
138 | return NewError(999 /*Internal Error*/)
139 | }
140 |
141 | return user
142 | } else if r.Method == "DELETE" {
143 | err := context.Tx.DeleteUser(user)
144 | if err != nil {
145 | log.Print(err)
146 | return NewError(999 /*Internal Error*/)
147 | }
148 | return SuccessWriter{}
149 | }
150 | }
151 | return NewError(3 /*Invalid Request*/)
152 | }
153 |
--------------------------------------------------------------------------------
/Gopkg.lock:
--------------------------------------------------------------------------------
1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
2 |
3 |
4 | [[projects]]
5 | branch = "master"
6 | digest = "1:476444199a2ed0626eab92a39d6379bb72c67b84758191f7be7d07dd44708fd7"
7 | name = "github.com/aclindsa/gorp"
8 | packages = ["."]
9 | pruneopts = ""
10 | revision = "4735379e1f46302b58b985d8172a53988aad93b4"
11 |
12 | [[projects]]
13 | branch = "master"
14 | digest = "1:a4aefb0596f8f241f0b6a633e3a73ef0a969017c3e714b7878609dd724ddf962"
15 | name = "github.com/aclindsa/ofxgo"
16 | packages = ["."]
17 | pruneopts = ""
18 | revision = "0f6ceccd861bb58a107aef5bb9a5cab54c479e5e"
19 |
20 | [[projects]]
21 | branch = "master"
22 | digest = "1:7c685fa85b4486ecf622995905408afed6330c493b0f8f81b54c9535343c23c1"
23 | name = "github.com/aclindsa/xml"
24 | packages = ["."]
25 | pruneopts = ""
26 | revision = "207ec7fb74201d07016cbd7064cb6331dde91eba"
27 |
28 | [[projects]]
29 | digest = "1:c07de423ca37dc2765396d6971599ab652a339538084b9b58c9f7fc533b28525"
30 | name = "github.com/go-sql-driver/mysql"
31 | packages = ["."]
32 | pruneopts = ""
33 | revision = "d523deb1b23d913de5bdada721a6071e71283618"
34 | version = "v1.4.0"
35 |
36 | [[projects]]
37 | branch = "master"
38 | digest = "1:048f85adb4eeed8feedaec030983d629e9903950b237345d579f920bdeaabf00"
39 | name = "github.com/kabukky/httpscerts"
40 | packages = ["."]
41 | pruneopts = ""
42 | revision = "617593d7dcb39c9ed617bb62c5e2056244d02184"
43 |
44 | [[projects]]
45 | branch = "master"
46 | digest = "1:bc36cd980d0069137800b505af4937c6109f4dc7cefe39d7c2efc7c8d51528d6"
47 | name = "github.com/lib/pq"
48 | packages = [
49 | ".",
50 | "oid",
51 | ]
52 | pruneopts = ""
53 | revision = "9eb73efc1fcc404148b56765b0d3f61d9a5ef8ee"
54 |
55 | [[projects]]
56 | digest = "1:c8b59c9235e65231db9f6fe5b05306ccf1108c8fd00cb017f0529fe242e68dd4"
57 | name = "github.com/mattn/go-sqlite3"
58 | packages = ["."]
59 | pruneopts = ""
60 | revision = "1fc3fd346d3cc4c610f432d8bc938bb952733873"
61 |
62 | [[projects]]
63 | branch = "master"
64 | digest = "1:e5e7d7742a5607737fd6a564ca941aecbd4e70c56ff443b11e3ce107608b5299"
65 | name = "github.com/yuin/gopher-lua"
66 | packages = [
67 | ".",
68 | "ast",
69 | "parse",
70 | "pm",
71 | ]
72 | pruneopts = ""
73 | revision = "12c4817b42c5e5b1f9e2690e42bfeaac8727924f"
74 |
75 | [[projects]]
76 | digest = "1:5acd3512b047305d49e8763eef7ba423901e85d5dd2fd1e71778a0ea8de10bd4"
77 | name = "golang.org/x/text"
78 | packages = [
79 | "currency",
80 | "internal",
81 | "internal/format",
82 | "internal/gen",
83 | "internal/tag",
84 | "language",
85 | "unicode/cldr",
86 | ]
87 | pruneopts = ""
88 | revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
89 | version = "v0.3.0"
90 |
91 | [[projects]]
92 | digest = "1:77d3cff3a451d50be4b52db9c7766c0d8570ba47593f0c9dc72173adb208e788"
93 | name = "google.golang.org/appengine"
94 | packages = ["cloudsql"]
95 | pruneopts = ""
96 | revision = "4a4468ece617fc8205e99368fa2200e9d1fad421"
97 | version = "v1.3.0"
98 |
99 | [[projects]]
100 | digest = "1:bb864e9881b2c241fc6348ba5ed57e6ccf8a675903f1f5c3d81c1b3d7cc4b8f8"
101 | name = "gopkg.in/gcfg.v1"
102 | packages = [
103 | ".",
104 | "scanner",
105 | "token",
106 | "types",
107 | ]
108 | pruneopts = ""
109 | revision = "61b2c08bc8f6068f7c5ca684372f9a6cb1c45ebe"
110 | version = "v1.2.3"
111 |
112 | [[projects]]
113 | digest = "1:ceec7e96590fb8168f36df4795fefe17051d4b0c2acc7ec4e260d8138c4dafac"
114 | name = "gopkg.in/warnings.v0"
115 | packages = ["."]
116 | pruneopts = ""
117 | revision = "ec4a0fea49c7b46c2aeb0b51aac55779c607e52b"
118 | version = "v0.1.2"
119 |
120 | [solve-meta]
121 | analyzer-name = "dep"
122 | analyzer-version = 1
123 | input-imports = [
124 | "github.com/aclindsa/gorp",
125 | "github.com/aclindsa/ofxgo",
126 | "github.com/go-sql-driver/mysql",
127 | "github.com/kabukky/httpscerts",
128 | "github.com/lib/pq",
129 | "github.com/mattn/go-sqlite3",
130 | "github.com/yuin/gopher-lua",
131 | "gopkg.in/gcfg.v1",
132 | ]
133 | solver-name = "gps-cdcl"
134 | solver-version = 1
135 |
--------------------------------------------------------------------------------
/internal/handlers/scripts/gen_security_list.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import csv
4 | from xml.dom import minidom
5 | import sys
6 |
7 | if sys.version_info[0] < 3:
8 | from urllib2 import urlopen
9 |
10 | # Allow writing utf-8 to stdout
11 | import codecs
12 | UTF8Writer = codecs.getwriter('utf8')
13 | sys.stdout = UTF8Writer(sys.stdout)
14 | else:
15 | from urllib.request import urlopen
16 |
17 | # This is absent, but also unneeded in python3, so just return the string
18 | def unicode(s, encoding):
19 | return s
20 |
21 | class Security(object):
22 | def __init__(self, name, description, number, _type, precision):
23 | self.name = name
24 | self.description = description
25 | self.number = number
26 | self.type = _type
27 | self.precision = precision
28 | def unicode(self):
29 | s = """\t{
30 | \t\tName: \"%s\",
31 | \t\tDescription: \"%s\",
32 | \t\tSymbol: \"%s\",
33 | \t\tPrecision: %d,
34 | \t\tType: %s,
35 | \t\tAlternateId: \"%s\"},\n""" % (self.name, self.description, self.name, self.precision, self.type, str(self.number))
36 | try:
37 | return unicode(s, 'utf_8')
38 | except TypeError:
39 | return s
40 |
41 | class SecurityList(object):
42 | def __init__(self, comment):
43 | self.comment = comment
44 | self.currencies = {}
45 | def add(self, currency):
46 | self.currencies[currency.number] = currency
47 | def unicode(self):
48 | string = "\t// "+self.comment+"\n"
49 | for key in sorted(self.currencies.keys()):
50 | string += self.currencies[key].unicode()
51 | return string
52 |
53 | def process_ccyntry(currency_list, node):
54 | name = ""
55 | nameSet = False
56 | number = 0
57 | numberSet = False
58 | description = ""
59 | precision = 0
60 | for n in node.childNodes:
61 | if n.nodeName == "Ccy":
62 | name = n.firstChild.nodeValue
63 | nameSet = True
64 | elif n.nodeName == "CcyNm":
65 | description = n.firstChild.nodeValue
66 | elif n.nodeName == "CcyNbr":
67 | number = int(n.firstChild.nodeValue)
68 | numberSet = True
69 | elif n.nodeName == "CcyMnrUnts":
70 | if n.firstChild.nodeValue == "N.A.":
71 | precision = 0
72 | else:
73 | precision = int(n.firstChild.nodeValue)
74 | if nameSet and numberSet:
75 | currency_list.add(Security(name, description, number, "models.Currency", precision))
76 |
77 | def get_currency_list():
78 | currency_list = SecurityList("ISO 4217, from http://www.currency-iso.org/en/home/tables/table-a1.html")
79 |
80 | f = urlopen('http://www.currency-iso.org/dam/downloads/lists/list_one.xml')
81 | xmldoc = minidom.parse(f)
82 | for isonode in xmldoc.childNodes:
83 | if isonode.nodeName == "ISO_4217":
84 | for ccytblnode in isonode.childNodes:
85 | if ccytblnode.nodeName == "CcyTbl":
86 | for ccyntrynode in ccytblnode.childNodes:
87 | if ccyntrynode.nodeName == "CcyNtry":
88 | process_ccyntry(currency_list, ccyntrynode)
89 | f.close()
90 | return currency_list
91 |
92 | def get_cusip_list(filename):
93 | cusip_list = SecurityList("")
94 | with open(filename) as csvfile:
95 | csvreader = csv.reader(csvfile, delimiter=',')
96 | for row in csvreader:
97 | cusip = row[0]
98 | name = row[1]
99 | description = ",".join(row[2:])
100 | cusip_list.add(Security(name, description, cusip, "models.Stock", 5))
101 | return cusip_list
102 |
103 | def main():
104 | currency_list = get_currency_list()
105 | cusip_list = get_cusip_list('cusip_list.csv')
106 |
107 | print("package handlers\n")
108 | print("import (")
109 | print("\t\"github.com/aclindsa/moneygo/internal/models\"")
110 | print(")\n")
111 | print("var SecurityTemplates = []models.Security{")
112 | print(currency_list.unicode())
113 | print(cusip_list.unicode())
114 | print("}")
115 |
116 | if __name__ == "__main__":
117 | main()
118 |
--------------------------------------------------------------------------------
/internal/integration/testdata/401k_mutualfunds.ofx:
--------------------------------------------------------------------------------
1 | 0INFOSUCCESS20171128203521.622[-5:EST]ENGofx.bank.com9199 d87db96a-c872-7f73-7637-7e9e2816c25a 0INFOSUCCESS20171128193521.926[-5:EST]USDofx.bank.com12321 20170829213521.814[-4:EDT]20171127203521.814[-5:EST]20170901OAEL01120170901070000.000[-4:EDT]CONTRIBUTION;VANGUARD TARGET 2045 OAEL;as of 09/01/2017OAELCUSIP1.75656.97100.05OTHEROTHERBUY 20170915OAEL01120170915070000.000[-4:EDT]CONTRIBUTION;VANGUARD TARGET 2045 OAEL;as of 09/15/2017OAELCUSIP1.73757.59100.05OTHEROTHERBUY 20170901OAEL13120170901070000.000[-4:EDT]FEES;VANGUARD TARGET 2045 OAEL;as of 09/01/2017OAELCUSIP0.0756.974.0OTHEROTHERSELL 20171002OAEL13120171002070000.000[-4:EDT]FEES;VANGUARD TARGET 2045 OAEL;as of 10/02/2017OAELCUSIP0.06958.14.0OTHEROTHERSELL OAELCUSIPOTHERLONG2792.37359.64200.03 20171127160000.000[-5:EST] Market close as of 11/27/2017;VANGUARD TARGET 2045 000MarketValueMarketValueDOLLAR200.0320171128193521.926[-5:EST]VestedValueVestedValueDOLLAR200.0320171128193521.926[-5:EST]TotalAssetsValueTotalAssetsValueDOLLAR200.0320171128193521.926[-5:EST]QC 401(K) PLAN200.03MarketValueMarketValueDOLLAR200.0320171128193521.926[-5:EST]VestedValueVestedValueDOLLAR200.0320171128193521.926[-5:EST]TotalAssetsValueTotalAssetsValueDOLLAR200.0320171128193521.926[-5:EST] OAELCUSIPVANGUARD TARGET 2045OAEL59.6420171127160000.000[-5:EST]Market close as of 11/27/2017;VANGUARD TARGET 2045OTHER
2 |
--------------------------------------------------------------------------------
/internal/store/store.go:
--------------------------------------------------------------------------------
1 | package store
2 |
3 | import (
4 | "github.com/aclindsa/moneygo/internal/models"
5 | "time"
6 | )
7 |
8 | type UserStore interface {
9 | UsernameExists(username string) (bool, error)
10 | InsertUser(user *models.User) error
11 | GetUser(userid int64) (*models.User, error)
12 | GetUserByUsername(username string) (*models.User, error)
13 | UpdateUser(user *models.User) error
14 | DeleteUser(user *models.User) error
15 | }
16 |
17 | type SessionStore interface {
18 | SessionExists(secret string) (bool, error)
19 | InsertSession(session *models.Session) error
20 | GetSession(secret string) (*models.Session, error)
21 | DeleteSession(session *models.Session) error
22 | }
23 |
24 | type SecurityInUseError struct {
25 | Message string
26 | }
27 |
28 | func (e SecurityInUseError) Error() string {
29 | return e.Message
30 | }
31 |
32 | type SecurityStore interface {
33 | InsertSecurity(security *models.Security) error
34 | GetSecurity(securityid int64, userid int64) (*models.Security, error)
35 | GetSecurities(userid int64) (*[]*models.Security, error)
36 | FindMatchingSecurities(security *models.Security) (*[]*models.Security, error)
37 | UpdateSecurity(security *models.Security) error
38 | DeleteSecurity(security *models.Security) error
39 | }
40 |
41 | type PriceStore interface {
42 | PriceExists(price *models.Price) (bool, error)
43 | InsertPrice(price *models.Price) error
44 | GetPrice(priceid, securityid int64) (*models.Price, error)
45 | GetPrices(securityid int64) (*[]*models.Price, error)
46 | GetLatestPrice(security, currency *models.Security, date *time.Time) (*models.Price, error)
47 | GetEarliestPrice(security, currency *models.Security, date *time.Time) (*models.Price, error)
48 | UpdatePrice(price *models.Price) error
49 | DeletePrice(price *models.Price) error
50 | }
51 |
52 | type ParentAccountMissingError struct{}
53 |
54 | func (pame ParentAccountMissingError) Error() string {
55 | return "Parent account missing"
56 | }
57 |
58 | type TooMuchNestingError struct{}
59 |
60 | func (tmne TooMuchNestingError) Error() string {
61 | return "Too much account nesting"
62 | }
63 |
64 | type CircularAccountsError struct{}
65 |
66 | func (cae CircularAccountsError) Error() string {
67 | return "Would result in circular account relationship"
68 | }
69 |
70 | type AccountStore interface {
71 | InsertAccount(account *models.Account) error
72 | GetAccount(accountid int64, userid int64) (*models.Account, error)
73 | GetAccounts(userid int64) (*[]*models.Account, error)
74 | FindMatchingAccounts(account *models.Account) (*[]*models.Account, error)
75 | UpdateAccount(account *models.Account) error
76 | DeleteAccount(account *models.Account) error
77 | }
78 |
79 | type AccountMissingError struct{}
80 |
81 | func (ame AccountMissingError) Error() string {
82 | return "Account missing"
83 | }
84 |
85 | type TransactionStore interface {
86 | SplitExists(s *models.Split) (bool, error)
87 | InsertTransaction(t *models.Transaction, user *models.User) error
88 | GetTransaction(transactionid int64, userid int64) (*models.Transaction, error)
89 | GetTransactions(userid int64) (*[]*models.Transaction, error)
90 | UpdateTransaction(t *models.Transaction, user *models.User) error
91 | DeleteTransaction(t *models.Transaction, user *models.User) error
92 | GetAccountBalance(user *models.User, accountid int64) (*models.Amount, error)
93 | GetAccountBalanceDate(user *models.User, accountid int64, date *time.Time) (*models.Amount, error)
94 | GetAccountBalanceDateRange(user *models.User, accountid int64, begin, end *time.Time) (*models.Amount, error)
95 | GetAccountTransactions(user *models.User, accountid int64, sort string, page uint64, limit uint64) (*models.AccountTransactionsList, error)
96 | }
97 |
98 | type ReportStore interface {
99 | InsertReport(report *models.Report) error
100 | GetReport(reportid int64, userid int64) (*models.Report, error)
101 | GetReports(userid int64) (*[]*models.Report, error)
102 | UpdateReport(report *models.Report) error
103 | DeleteReport(report *models.Report) error
104 | }
105 |
106 | type Tx interface {
107 | Commit() error
108 | Rollback() error
109 |
110 | UserStore
111 | SessionStore
112 | SecurityStore
113 | PriceStore
114 | AccountStore
115 | TransactionStore
116 | ReportStore
117 | }
118 |
119 | type Store interface {
120 | Empty() error
121 | Begin() (Tx, error)
122 | Close() error
123 | }
124 |
--------------------------------------------------------------------------------
/js/actions/AccountActions.js:
--------------------------------------------------------------------------------
1 | var AccountConstants = require('../constants/AccountConstants');
2 |
3 | var ErrorActions = require('./ErrorActions');
4 |
5 | var models = require('../models.js');
6 | var Account = models.Account;
7 | var Error = models.Error;
8 |
9 | function fetchAccounts() {
10 | return {
11 | type: AccountConstants.FETCH_ACCOUNTS
12 | }
13 | }
14 |
15 | function accountsFetched(accounts) {
16 | return {
17 | type: AccountConstants.ACCOUNTS_FETCHED,
18 | accounts: accounts
19 | }
20 | }
21 |
22 | function createAccount() {
23 | return {
24 | type: AccountConstants.CREATE_ACCOUNT
25 | }
26 | }
27 |
28 | function accountCreated(account) {
29 | return {
30 | type: AccountConstants.ACCOUNT_CREATED,
31 | account: account
32 | }
33 | }
34 |
35 | function updateAccount() {
36 | return {
37 | type: AccountConstants.UPDATE_ACCOUNT
38 | }
39 | }
40 |
41 | function accountUpdated(account) {
42 | return {
43 | type: AccountConstants.ACCOUNT_UPDATED,
44 | account: account
45 | }
46 | }
47 |
48 | function removeAccount() {
49 | return {
50 | type: AccountConstants.REMOVE_ACCOUNT
51 | }
52 | }
53 |
54 | function accountRemoved(accountId) {
55 | return {
56 | type: AccountConstants.ACCOUNT_REMOVED,
57 | accountId: accountId
58 | }
59 | }
60 |
61 | function accountSelected(accountId) {
62 | return {
63 | type: AccountConstants.ACCOUNT_SELECTED,
64 | accountId: accountId
65 | }
66 | }
67 |
68 | function fetchAll() {
69 | return function (dispatch) {
70 | dispatch(fetchAccounts());
71 |
72 | $.ajax({
73 | type: "GET",
74 | dataType: "json",
75 | url: "v1/accounts/",
76 | success: function(data, status, jqXHR) {
77 | var e = new Error();
78 | e.fromJSON(data);
79 | if (e.isError()) {
80 | dispatch(ErrorActions.serverError(e));
81 | } else {
82 | dispatch(accountsFetched(data.accounts.map(function(json) {
83 | var a = new Account();
84 | a.fromJSON(json);
85 | return a;
86 | })));
87 | }
88 | },
89 | error: function(jqXHR, status, error) {
90 | dispatch(ErrorActions.ajaxError(error));
91 | }
92 | });
93 | };
94 | }
95 |
96 | function create(account) {
97 | return function (dispatch) {
98 | dispatch(createAccount());
99 |
100 | $.ajax({
101 | type: "POST",
102 | contentType: "application/json",
103 | dataType: "json",
104 | url: "v1/accounts/",
105 | data: account.toJSON(),
106 | success: function(data, status, jqXHR) {
107 | var e = new Error();
108 | e.fromJSON(data);
109 | if (e.isError()) {
110 | dispatch(ErrorActions.serverError(e));
111 | } else {
112 | var a = new Account();
113 | a.fromJSON(data);
114 | dispatch(accountCreated(a));
115 | }
116 | },
117 | error: function(jqXHR, status, error) {
118 | dispatch(ErrorActions.ajaxError(error));
119 | }
120 | });
121 | };
122 | }
123 |
124 | function update(account) {
125 | return function (dispatch) {
126 | dispatch(updateAccount());
127 |
128 | $.ajax({
129 | type: "PUT",
130 | contentType: "application/json",
131 | dataType: "json",
132 | url: "v1/accounts/"+account.AccountId+"/",
133 | data: account.toJSON(),
134 | success: function(data, status, jqXHR) {
135 | var e = new Error();
136 | e.fromJSON(data);
137 | if (e.isError()) {
138 | dispatch(ErrorActions.serverError(e));
139 | } else {
140 | var a = new Account();
141 | a.fromJSON(data);
142 | dispatch(accountUpdated(a));
143 | }
144 | },
145 | error: function(jqXHR, status, error) {
146 | dispatch(ErrorActions.ajaxError(error));
147 | }
148 | });
149 | };
150 | }
151 |
152 | function remove(account) {
153 | return function(dispatch) {
154 | dispatch(removeAccount());
155 |
156 | $.ajax({
157 | type: "DELETE",
158 | dataType: "json",
159 | url: "v1/accounts/"+account.AccountId+"/",
160 | success: function(data, status, jqXHR) {
161 | var e = new Error();
162 | e.fromJSON(data);
163 | if (e.isError()) {
164 | dispatch(ErrorActions.serverError(e));
165 | } else {
166 | dispatch(accountRemoved(account.AccountId));
167 | }
168 | },
169 | error: function(jqXHR, status, error) {
170 | dispatch(ErrorActions.ajaxError(error));
171 | }
172 | });
173 | };
174 | }
175 |
176 | module.exports = {
177 | fetchAll: fetchAll,
178 | create: create,
179 | update: update,
180 | remove: remove,
181 | select: accountSelected
182 | };
183 |
--------------------------------------------------------------------------------
/internal/integration/testdata/checking_20171129.ofx:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | 0
7 | INFO
8 |
9 | 20171129025346.132[0:GMT]
10 | ENG
11 |
12 | YCKVJ
13 | 0351
14 |
15 |
16 |
17 |
18 | 0549c828-f02c-43c7-81a3-de0b3f23c393
19 |
20 | 0
21 | INFO
22 |
23 |
24 | USD
25 |
26 | 115483849
27 | 14839128817
28 | CHECKING
29 |
30 |
31 | 20170831174401.637[0:GMT]
32 | 20171129184401.637[0:GMT]
33 |
34 | DEBIT
35 | 20171107120000.000[0:GMT]
36 | -282.68
37 | 29c74a94-f226-4980-b54c-da6fa2721d7e
38 | DAYCARE o SIGONFILE
39 | ACH Debit 11818191919191
40 |
41 |
42 | CREDIT
43 | 20171109120000.000[0:GMT]
44 | 1300.98
45 | 32e40e98-61c3-421c-acaa-55ae67a5f8fe
46 | DIRECT DEPOSIT
47 | ACH Deposit 8282828282828
48 |
49 |
50 | DEBIT
51 | 20171109120000.000[0:GMT]
52 | -98.20
53 | 4b73dbbf-aa27-4f62-b54a-ee0a9a3486d8
54 | DUKEENGYPROGRESS DUKEENGYPR
55 | ACH Debit 017313004099621
56 |
57 |
58 | CREDIT
59 | 20171115120000.000[0:GMT]
60 | 1.01
61 | 51c47252-4cf0-442c-b619-8a31b17ac489
62 | Dividend Earned
63 |
64 |
65 | DEBIT
66 | 20171116120000.000[0:GMT]
67 | -51.75
68 | 51cb12bb-cdd9-4333-8d8d-c423f9e8f833
69 | TARGET DEBIT CRD ACH TRAN
70 | ACH Debit
71 |
72 |
73 | DEBIT
74 | 20171120120000.000[0:GMT]
75 | -25.18
76 | 366a5b23-2f2e-4cf0-a714-6a306bd4e909
77 | TARGET DEBIT CRD ACH TRAN
78 | ACH Debit
79 |
80 |
81 | DEBIT
82 | 20171121120000.000[0:GMT]
83 | -10.71
84 | 9a463f21-c6e1-4fe0-b37b-f9a8cc942cf0
85 | NETFLIX COM NETFLIX COM
86 | Point of Sale Debit L999 DATE 11-20
87 |
88 |
89 | CREDIT
90 | 20171122120000.000[0:GMT]
91 | 1300.98
92 | 31f165e5-569f-4530-8438-a6ceb2301335
93 | DIRECT DEPOSIT
94 | ACH Deposit 838383838383838
95 |
96 |
97 | CREDIT
98 | 20171122120000.000[0:GMT]
99 | 12.50
100 | 215a10dd-f3a2-4336-ab8c-f22276cad552
101 | CIRCLE INTERNET CIRCLE
102 | ACH Deposit 017326000283477
103 |
104 |
105 | CREDIT
106 | 20171129120000.000[0:GMT]
107 | 2843.08
108 | 9a52df4b-3a8d-41bb-9141-96e1e3f294cf
109 | SALARY
110 | ACH Deposit 18181818199
111 |
112 |
113 |
114 | 5463.45
115 | 20171129025346.132[0:GMT]
116 |
117 |
118 | 6463.45
119 | 20171129025346.132[0:GMT]
120 |
121 |
122 |
123 |
124 |
--------------------------------------------------------------------------------
/js/actions/SecurityActions.js:
--------------------------------------------------------------------------------
1 | var SecurityConstants = require('../constants/SecurityConstants');
2 |
3 | var ErrorActions = require('./ErrorActions');
4 |
5 | var models = require('../models.js');
6 | var Security = models.Security;
7 | var Error = models.Error;
8 |
9 | function fetchSecurities() {
10 | return {
11 | type: SecurityConstants.FETCH_SECURITIES
12 | }
13 | }
14 |
15 | function securitiesFetched(securities) {
16 | return {
17 | type: SecurityConstants.SECURITIES_FETCHED,
18 | securities: securities
19 | }
20 | }
21 |
22 | function createSecurity() {
23 | return {
24 | type: SecurityConstants.CREATE_SECURITY
25 | }
26 | }
27 |
28 | function securityCreated(security) {
29 | return {
30 | type: SecurityConstants.SECURITY_CREATED,
31 | security: security
32 | }
33 | }
34 |
35 | function updateSecurity() {
36 | return {
37 | type: SecurityConstants.UPDATE_SECURITY
38 | }
39 | }
40 |
41 | function securityUpdated(security) {
42 | return {
43 | type: SecurityConstants.SECURITY_UPDATED,
44 | security: security
45 | }
46 | }
47 |
48 | function removeSecurity() {
49 | return {
50 | type: SecurityConstants.REMOVE_SECURITY
51 | }
52 | }
53 |
54 | function securityRemoved(securityId) {
55 | return {
56 | type: SecurityConstants.SECURITY_REMOVED,
57 | securityId: securityId
58 | }
59 | }
60 |
61 | function securitySelected(securityId) {
62 | return {
63 | type: SecurityConstants.SECURITY_SELECTED,
64 | securityId: securityId
65 | }
66 | }
67 |
68 | function fetchAll() {
69 | return function (dispatch) {
70 | dispatch(fetchSecurities());
71 |
72 | $.ajax({
73 | type: "GET",
74 | dataType: "json",
75 | url: "v1/securities/",
76 | success: function(data, status, jqXHR) {
77 | var e = new Error();
78 | e.fromJSON(data);
79 | if (e.isError()) {
80 | dispatch(ErrorActions.serverError(e));
81 | } else {
82 | dispatch(securitiesFetched(data.securities.map(function(json) {
83 | var s = new Security();
84 | s.fromJSON(json);
85 | return s;
86 | })));
87 | }
88 | },
89 | error: function(jqXHR, status, error) {
90 | dispatch(ErrorActions.ajaxError(error));
91 | }
92 | });
93 | };
94 | }
95 |
96 | function create(security) {
97 | return function (dispatch) {
98 | dispatch(createSecurity());
99 |
100 | $.ajax({
101 | type: "POST",
102 | contentType: "application/json",
103 | dataType: "json",
104 | url: "v1/securities/",
105 | data: security.toJSON(),
106 | success: function(data, status, jqXHR) {
107 | var e = new Error();
108 | e.fromJSON(data);
109 | if (e.isError()) {
110 | dispatch(ErrorActions.serverError(e));
111 | } else {
112 | var s = new Security();
113 | s.fromJSON(data);
114 | dispatch(securityCreated(s));
115 | }
116 | },
117 | error: function(jqXHR, status, error) {
118 | dispatch(ErrorActions.ajaxError(error));
119 | }
120 | });
121 | };
122 | }
123 |
124 | function update(security) {
125 | return function (dispatch) {
126 | dispatch(updateSecurity());
127 |
128 | $.ajax({
129 | type: "PUT",
130 | contentType: "application/json",
131 | dataType: "json",
132 | url: "v1/securities/"+security.SecurityId+"/",
133 | data: security.toJSON(),
134 | success: function(data, status, jqXHR) {
135 | var e = new Error();
136 | e.fromJSON(data);
137 | if (e.isError()) {
138 | dispatch(ErrorActions.serverError(e));
139 | } else {
140 | var s = new Security();
141 | s.fromJSON(data);
142 | dispatch(securityUpdated(s));
143 | }
144 | },
145 | error: function(jqXHR, status, error) {
146 | dispatch(ErrorActions.ajaxError(error));
147 | }
148 | });
149 | };
150 | }
151 |
152 | function remove(security) {
153 | return function(dispatch) {
154 | dispatch(removeSecurity());
155 |
156 | $.ajax({
157 | type: "DELETE",
158 | dataType: "json",
159 | url: "v1/securities/"+security.SecurityId+"/",
160 | success: function(data, status, jqXHR) {
161 | var e = new Error();
162 | e.fromJSON(data);
163 | if (e.isError()) {
164 | dispatch(ErrorActions.serverError(e));
165 | } else {
166 | dispatch(securityRemoved(security.SecurityId));
167 | }
168 | },
169 | error: function(jqXHR, status, error) {
170 | dispatch(ErrorActions.ajaxError(error));
171 | }
172 | });
173 | };
174 | }
175 |
176 | module.exports = {
177 | fetchAll: fetchAll,
178 | create: create,
179 | update: update,
180 | remove: remove,
181 | select: securitySelected
182 | };
183 |
--------------------------------------------------------------------------------
/internal/store/db/prices.go:
--------------------------------------------------------------------------------
1 | package db
2 |
3 | import (
4 | "fmt"
5 | "github.com/aclindsa/moneygo/internal/models"
6 | "time"
7 | )
8 |
9 | // Price is a mirror of models.Price with the Value broken out into whole and
10 | // fractional components
11 | type Price struct {
12 | PriceId int64
13 | SecurityId int64
14 | CurrencyId int64
15 | Date time.Time
16 | WholeValue int64
17 | FractionalValue int64
18 | RemoteId string // unique ID from source, for detecting duplicates
19 | }
20 |
21 | func NewPrice(p *models.Price) (*Price, error) {
22 | whole, err := p.Value.Whole()
23 | if err != nil {
24 | return nil, err
25 | }
26 | fractional, err := p.Value.Fractional(MaxPrecision)
27 | if err != nil {
28 | return nil, err
29 | }
30 | return &Price{
31 | PriceId: p.PriceId,
32 | SecurityId: p.SecurityId,
33 | CurrencyId: p.CurrencyId,
34 | Date: p.Date,
35 | WholeValue: whole,
36 | FractionalValue: fractional,
37 | RemoteId: p.RemoteId,
38 | }, nil
39 | }
40 |
41 | func (p Price) Price() *models.Price {
42 | price := &models.Price{
43 | PriceId: p.PriceId,
44 | SecurityId: p.SecurityId,
45 | CurrencyId: p.CurrencyId,
46 | Date: p.Date,
47 | RemoteId: p.RemoteId,
48 | }
49 | price.Value.FromParts(p.WholeValue, p.FractionalValue, MaxPrecision)
50 |
51 | return price
52 | }
53 |
54 | func (tx *Tx) PriceExists(price *models.Price) (bool, error) {
55 | p, err := NewPrice(price)
56 | if err != nil {
57 | return false, err
58 | }
59 |
60 | var prices []*Price
61 | _, err = tx.Select(&prices, "SELECT * from prices where SecurityId=? AND CurrencyId=? AND Date=? AND WholeValue=? AND FractionalValue=?", p.SecurityId, p.CurrencyId, p.Date, p.WholeValue, p.FractionalValue)
62 | return len(prices) > 0, err
63 | }
64 |
65 | func (tx *Tx) InsertPrice(price *models.Price) error {
66 | p, err := NewPrice(price)
67 | if err != nil {
68 | return err
69 | }
70 | err = tx.Insert(p)
71 | if err != nil {
72 | return err
73 | }
74 | *price = *p.Price()
75 | return nil
76 | }
77 |
78 | func (tx *Tx) GetPrice(priceid, securityid int64) (*models.Price, error) {
79 | var price Price
80 | err := tx.SelectOne(&price, "SELECT * from prices where PriceId=? AND SecurityId=?", priceid, securityid)
81 | if err != nil {
82 | return nil, err
83 | }
84 | return price.Price(), nil
85 | }
86 |
87 | func (tx *Tx) GetPrices(securityid int64) (*[]*models.Price, error) {
88 | var prices []*Price
89 | var modelprices []*models.Price
90 |
91 | _, err := tx.Select(&prices, "SELECT * from prices where SecurityId=?", securityid)
92 | if err != nil {
93 | return nil, err
94 | }
95 |
96 | for _, p := range prices {
97 | modelprices = append(modelprices, p.Price())
98 | }
99 |
100 | return &modelprices, nil
101 | }
102 |
103 | // Return the latest price for security in currency units before date
104 | func (tx *Tx) GetLatestPrice(security, currency *models.Security, date *time.Time) (*models.Price, error) {
105 | var price Price
106 | err := tx.SelectOne(&price, "SELECT * from prices where SecurityId=? AND CurrencyId=? AND Date <= ? ORDER BY Date DESC LIMIT 1", security.SecurityId, currency.SecurityId, date)
107 | if err != nil {
108 | return nil, err
109 | }
110 | return price.Price(), nil
111 | }
112 |
113 | // Return the earliest price for security in currency units after date
114 | func (tx *Tx) GetEarliestPrice(security, currency *models.Security, date *time.Time) (*models.Price, error) {
115 | var price Price
116 | err := tx.SelectOne(&price, "SELECT * from prices where SecurityId=? AND CurrencyId=? AND Date >= ? ORDER BY Date ASC LIMIT 1", security.SecurityId, currency.SecurityId, date)
117 | if err != nil {
118 | return nil, err
119 | }
120 | return price.Price(), nil
121 | }
122 |
123 | func (tx *Tx) UpdatePrice(price *models.Price) error {
124 | p, err := NewPrice(price)
125 | if err != nil {
126 | return err
127 | }
128 |
129 | count, err := tx.Update(p)
130 | if err != nil {
131 | return err
132 | }
133 | if count != 1 {
134 | return fmt.Errorf("Expected to update 1 price, was going to update %d", count)
135 | }
136 | *price = *p.Price()
137 | return nil
138 | }
139 |
140 | func (tx *Tx) DeletePrice(price *models.Price) error {
141 | p, err := NewPrice(price)
142 | if err != nil {
143 | return err
144 | }
145 |
146 | count, err := tx.Delete(p)
147 | if err != nil {
148 | return err
149 | }
150 | if count != 1 {
151 | return fmt.Errorf("Expected to delete 1 price, was going to delete %d", count)
152 | }
153 | *price = *p.Price()
154 | return nil
155 | }
156 |
--------------------------------------------------------------------------------
/internal/models/amounts.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "math"
7 | "math/big"
8 | "strings"
9 | )
10 |
11 | type Amount struct {
12 | big.Rat
13 | }
14 |
15 | type PrecisionError struct {
16 | message string
17 | }
18 |
19 | func (p PrecisionError) Error() string {
20 | return p.message
21 | }
22 |
23 | // Whole returns the integral portion of the Amount
24 | func (amount Amount) Whole() (int64, error) {
25 | var whole big.Int
26 | whole.Quo(amount.Num(), amount.Denom())
27 | if whole.IsInt64() {
28 | return whole.Int64(), nil
29 | }
30 | return 0, PrecisionError{"integral portion of Amount cannot be represented as an int64"}
31 | }
32 |
33 | // Fractional returns the fractional portion of the Amount, multiplied by
34 | // 10^precision
35 | func (amount Amount) Fractional(precision uint64) (int64, error) {
36 | if precision < amount.Precision() {
37 | return 0, PrecisionError{"Fractional portion of Amount cannot be represented with the given precision"}
38 | }
39 |
40 | // Reduce the fraction to its simplest form
41 | var r, gcd, d, n big.Int
42 | r.Rem(amount.Num(), amount.Denom())
43 | gcd.GCD(nil, nil, &r, amount.Denom())
44 | if gcd.Sign() != 0 {
45 | n.Quo(&r, &gcd)
46 | d.Quo(amount.Denom(), &gcd)
47 | } else {
48 | n.Set(&r)
49 | d.Set(amount.Denom())
50 | }
51 |
52 | // Figure out what we need to multiply the numerator by to get the
53 | // denominator to be 10^precision
54 | var prec, multiplier big.Int
55 | prec.SetUint64(precision)
56 | multiplier.SetInt64(10)
57 | multiplier.Exp(&multiplier, &prec, nil)
58 | multiplier.Quo(&multiplier, &d)
59 |
60 | n.Mul(&n, &multiplier)
61 | if n.IsInt64() {
62 | return n.Int64(), nil
63 | }
64 | return 0, fmt.Errorf("Fractional portion of Amount does not fit in int64 with given precision")
65 | }
66 |
67 | // FromParts re-assembles an Amount from the results from previous calls to
68 | // Whole and Fractional
69 | func (amount *Amount) FromParts(whole, fractional int64, precision uint64) {
70 | var fracnum, fracdenom, power big.Int
71 | fracnum.SetInt64(fractional)
72 | fracdenom.SetInt64(10)
73 | power.SetUint64(precision)
74 | fracdenom.Exp(&fracdenom, &power, nil)
75 |
76 | var fracrat big.Rat
77 | fracrat.SetFrac(&fracnum, &fracdenom)
78 | amount.Rat.SetInt64(whole)
79 | amount.Rat.Add(&amount.Rat, &fracrat)
80 | }
81 |
82 | // Round rounds the given Amount to the given precision
83 | func (amount *Amount) Round(precision uint64) {
84 | // This probably isn't exactly the most efficient way to do this...
85 | amount.SetString(amount.FloatString(int(precision)))
86 | }
87 |
88 | func (amount Amount) String() string {
89 | return amount.FloatString(int(amount.Precision()))
90 | }
91 |
92 | func (amount *Amount) UnmarshalJSON(bytes []byte) error {
93 | var value string
94 | if err := json.Unmarshal(bytes, &value); err != nil {
95 | return err
96 | }
97 | value = strings.TrimSpace(value)
98 |
99 | if _, ok := amount.SetString(value); !ok {
100 | return fmt.Errorf("Failed to parse '%s' into Amount", value)
101 | }
102 | return nil
103 | }
104 |
105 | func (amount Amount) MarshalJSON() ([]byte, error) {
106 | return json.Marshal(amount.String())
107 | }
108 |
109 | // Precision returns the minimum positive integer p such that if you multiplied
110 | // this Amount by 10^p, it would become an integer
111 | func (amount Amount) Precision() uint64 {
112 | if amount.IsInt() || amount.Sign() == 0 {
113 | return 0
114 | }
115 |
116 | // Find d, the denominator of the reduced fractional portion of 'amount'
117 | var r, gcd, d big.Int
118 | r.Rem(amount.Num(), amount.Denom())
119 | gcd.GCD(nil, nil, &r, amount.Denom())
120 | if gcd.Sign() != 0 {
121 | d.Quo(amount.Denom(), &gcd)
122 | } else {
123 | d.Set(amount.Denom())
124 | }
125 | d.Abs(&d)
126 |
127 | var power, result big.Int
128 | one := big.NewInt(1)
129 | ten := big.NewInt(10)
130 |
131 | // Estimate an initial power
132 | if d.IsUint64() {
133 | power.SetInt64(int64(math.Log10(float64(d.Uint64()))))
134 | } else {
135 |
136 | // If the simplified denominator wasn't a uint64, its > 10^19
137 | power.SetInt64(19)
138 | }
139 |
140 | // If the initial estimate was too high, bring it down
141 | result.Exp(ten, &power, nil)
142 | for result.Cmp(&d) > 0 {
143 | power.Sub(&power, one)
144 | result.Exp(ten, &power, nil)
145 | }
146 | // If it was too low, bring it up
147 | for result.Cmp(&d) < 0 {
148 | power.Add(&power, one)
149 | result.Exp(ten, &power, nil)
150 | }
151 |
152 | if !power.IsUint64() {
153 | panic("Unable to represent Amount's precision as a uint64")
154 | }
155 | return power.Uint64()
156 | }
157 |
--------------------------------------------------------------------------------
/js/actions/ImportActions.js:
--------------------------------------------------------------------------------
1 | var ImportConstants = require('../constants/ImportConstants');
2 |
3 | var models = require('../models.js');
4 | var OFXDownload = models.OFXDownload;
5 | var Error = models.Error;
6 |
7 | function beginImport() {
8 | return {
9 | type: ImportConstants.BEGIN_IMPORT
10 | }
11 | }
12 |
13 | function updateProgress(progress) {
14 | return {
15 | type: ImportConstants.UPDATE_IMPORT_PROGRESS,
16 | progress: progress
17 | }
18 | }
19 |
20 | function importFinished() {
21 | return {
22 | type: ImportConstants.IMPORT_FINISHED
23 | }
24 | }
25 |
26 | function importFailed(error) {
27 | return {
28 | type: ImportConstants.IMPORT_FAILED,
29 | error: error
30 | }
31 | }
32 |
33 | function openModal() {
34 | return function(dispatch) {
35 | dispatch({
36 | type: ImportConstants.OPEN_IMPORT_MODAL
37 | });
38 | };
39 | }
40 |
41 | function closeModal() {
42 | return function(dispatch) {
43 | dispatch({
44 | type: ImportConstants.CLOSE_IMPORT_MODAL
45 | });
46 | };
47 | }
48 |
49 | function importOFX(account, password, startDate, endDate) {
50 | return function(dispatch) {
51 | dispatch(beginImport());
52 | dispatch(updateProgress(50));
53 |
54 | var ofxdownload = new OFXDownload();
55 | ofxdownload.OFXPassword = password;
56 | ofxdownload.StartDate = startDate;
57 | ofxdownload.EndDate = endDate;
58 |
59 | $.ajax({
60 | type: "POST",
61 | contentType: "application/json",
62 | dataType: "json",
63 | url: "v1/accounts/"+account.AccountId+"/imports/ofx",
64 | data: ofxdownload.toJSON(),
65 | success: function(data, status, jqXHR) {
66 | var e = new Error();
67 | e.fromJSON(data);
68 | if (e.isError()) {
69 | var errString = e.ErrorString;
70 | if (e.ErrorId == 3 /* Invalid Request */) {
71 | errString = "Please check that your password and all other OFX login credentials are correct.";
72 | }
73 | dispatch(importFailed(errString));
74 | } else {
75 | dispatch(importFinished());
76 | }
77 | },
78 | error: function(jqXHR, status, error) {
79 | dispatch(importFailed(error));
80 | }
81 | });
82 | };
83 | }
84 |
85 | function importFile(url, inputElement) {
86 | return function(dispatch) {
87 | dispatch(beginImport());
88 |
89 | if (inputElement.files.length == 0) {
90 | dispatch(importFailed("No files specified to be imported"))
91 | return;
92 | }
93 | if (inputElement.files.length > 1) {
94 | dispatch(importFailed("More than one file specified for import, only one allowed at a time"))
95 | return;
96 | }
97 |
98 | var file = inputElement.files[0];
99 | var formData = new FormData();
100 | formData.append('importfile', file, file.name);
101 |
102 | var handleSetProgress = function(e) {
103 | if (e.lengthComputable) {
104 | var pct = Math.round(e.loaded/e.total*100);
105 | dispatch(updateProgress(pct));
106 | } else {
107 | dispatch(updateProgress(50));
108 | }
109 | }
110 |
111 | $.ajax({
112 | type: "POST",
113 | url: url,
114 | data: formData,
115 | xhr: function() {
116 | var xhrObject = $.ajaxSettings.xhr();
117 | if (xhrObject.upload) {
118 | xhrObject.upload.addEventListener('progress', handleSetProgress, false);
119 | } else {
120 | dispatch(importFailed("File upload failed because xhr.upload isn't supported by your browser."));
121 | }
122 | return xhrObject;
123 | },
124 | success: function(data, status, jqXHR) {
125 | var e = new Error();
126 | e.fromJSON(data);
127 | if (e.isError()) {
128 | var errString = e.ErrorString;
129 | if (e.ErrorId == 3 /* Invalid Request */) {
130 | errString = "Please check that the file you uploaded is valid and try again.";
131 | }
132 | dispatch(importFailed(errString));
133 | } else {
134 | dispatch(importFinished());
135 | }
136 | },
137 | error: function(jqXHR, status, error) {
138 | dispatch(importFailed(error));
139 | },
140 | // So jQuery doesn't try to process the data or content-type
141 | cache: false,
142 | contentType: false,
143 | processData: false
144 | });
145 | };
146 | }
147 |
148 | function importOFXFile(inputElement, account) {
149 | var url = "v1/accounts/"+account.AccountId+"/imports/ofxfile";
150 | return importFile(url, inputElement);
151 | }
152 |
153 | function importGnucash(inputElement) {
154 | var url = "v1/imports/gnucash";
155 | return importFile(url, inputElement);
156 | }
157 |
158 | module.exports = {
159 | openModal: openModal,
160 | closeModal: closeModal,
161 | importOFX: importOFX,
162 | importOFXFile: importOFXFile,
163 | importGnucash: importGnucash
164 | };
165 |
--------------------------------------------------------------------------------
/internal/models/amounts_test.go:
--------------------------------------------------------------------------------
1 | package models_test
2 |
3 | import (
4 | "github.com/aclindsa/moneygo/internal/models"
5 | "testing"
6 | )
7 |
8 | func expectedPrecision(t *testing.T, amount *models.Amount, precision uint64) {
9 | t.Helper()
10 | if amount.Precision() != precision {
11 | t.Errorf("Expected precision %d for %s, found %d", precision, amount.String(), amount.Precision())
12 | }
13 | }
14 |
15 | func TestAmountPrecision(t *testing.T) {
16 | var a models.Amount
17 | a.SetString("1.1928712")
18 | expectedPrecision(t, &a, 7)
19 | a.SetString("0")
20 | expectedPrecision(t, &a, 0)
21 | a.SetString("-0.7")
22 | expectedPrecision(t, &a, 1)
23 | a.SetString("-1.1837281037509137509173049173052130957210361309572047598275398265926351231426357130289523647634895285603247284245928712")
24 | expectedPrecision(t, &a, 118)
25 | a.SetInt64(1050)
26 | expectedPrecision(t, &a, 0)
27 | }
28 |
29 | func TestAmountRound(t *testing.T) {
30 | var a models.Amount
31 | tests := []struct {
32 | String string
33 | RoundTo uint64
34 | Expected string
35 | }{
36 | {"0", 5, "0"},
37 | {"929.92928", 2, "929.93"},
38 | {"-105.499999", 4, "-105.5"},
39 | {"0.5111111", 1, "0.5"},
40 | {"0.5111111", 0, "1"},
41 | {"9.876456", 3, "9.876"},
42 | }
43 |
44 | for _, test := range tests {
45 | a.SetString(test.String)
46 | a.Round(test.RoundTo)
47 | if a.String() != test.Expected {
48 | t.Errorf("Expected '%s' after Round(%d) to be %s intead of %s\n", test.String, test.RoundTo, test.Expected, a.String())
49 | }
50 | }
51 | }
52 |
53 | func TestAmountString(t *testing.T) {
54 | var a models.Amount
55 | for _, s := range []string{
56 | "1.1928712",
57 | "0",
58 | "-0.7",
59 | "-1.1837281037509137509173049173052130957210361309572047598275398265926351231426357130289523647634895285603247284245928712",
60 | "1050",
61 | } {
62 | a.SetString(s)
63 | if s != a.String() {
64 | t.Errorf("Expected '%s', found '%s'", s, a.String())
65 | }
66 | }
67 |
68 | a.SetString("+182.27")
69 | if "182.27" != a.String() {
70 | t.Errorf("Expected '182.27', found '%s'", a.String())
71 | }
72 | a.SetString("-0")
73 | if "0" != a.String() {
74 | t.Errorf("Expected '0', found '%s'", a.String())
75 | }
76 | }
77 |
78 | func TestWhole(t *testing.T) {
79 | var a models.Amount
80 | tests := []struct {
81 | String string
82 | Whole int64
83 | }{
84 | {"0", 0},
85 | {"-0", 0},
86 | {"181.1293871230", 181},
87 | {"-0.1821", 0},
88 | {"99992737.9", 99992737},
89 | {"-7380.000009", -7380},
90 | {"4108740192740912741", 4108740192740912741},
91 | }
92 |
93 | for _, test := range tests {
94 | a.SetString(test.String)
95 | val, err := a.Whole()
96 | if err != nil {
97 | t.Errorf("Unexpected error: %s\n", err)
98 | } else if val != test.Whole {
99 | t.Errorf("Expected '%s'.Whole() to return %d intead of %d\n", test.String, test.Whole, val)
100 | }
101 | }
102 |
103 | a.SetString("81367662642302823790328492349823472634926342")
104 | _, err := a.Whole()
105 | if err == nil {
106 | t.Errorf("Expected error for overflowing int64")
107 | }
108 | }
109 |
110 | func TestFractional(t *testing.T) {
111 | var a models.Amount
112 | tests := []struct {
113 | String string
114 | Precision uint64
115 | Fractional int64
116 | }{
117 | {"0", 5, 0},
118 | {"181.1293871230", 9, 129387123},
119 | {"181.1293871230", 10, 1293871230},
120 | {"181.1293871230", 15, 129387123000000},
121 | {"1828.37", 7, 3700000},
122 | {"-0.748", 5, -74800},
123 | {"-9", 5, 0},
124 | {"-9.9", 1, -9},
125 | }
126 |
127 | for _, test := range tests {
128 | a.SetString(test.String)
129 | val, err := a.Fractional(test.Precision)
130 | if err != nil {
131 | t.Errorf("Unexpected error: %s\n", err)
132 | } else if val != test.Fractional {
133 | t.Errorf("Expected '%s'.Fractional(%d) to return %d intead of %d\n", test.String, test.Precision, test.Fractional, val)
134 | }
135 | }
136 | }
137 |
138 | func TestFromParts(t *testing.T) {
139 | var a models.Amount
140 | tests := []struct {
141 | Whole int64
142 | Fractional int64
143 | Precision uint64
144 | Result string
145 | }{
146 | {839, 9080, 4, "839.908"},
147 | {-10, 0, 5, "-10"},
148 | {0, 900, 10, "0.00000009"},
149 | {9128713621, 87272727, 20, "9128713621.00000000000087272727"},
150 | {89, 1, 0, "90"}, // Not sure if this should really be supported, but it is
151 | }
152 |
153 | for _, test := range tests {
154 | a.FromParts(test.Whole, test.Fractional, test.Precision)
155 | if a.String() != test.Result {
156 | t.Errorf("Expected Amount.FromParts(%d, %d, %d) to return %s intead of %s\n", test.Whole, test.Fractional, test.Precision, test.Result, a.String())
157 | }
158 | }
159 | }
160 |
--------------------------------------------------------------------------------