From e76261d5d53f199dc9d32392117989a7be02d9d3 Mon Sep 17 00:00:00 2001 From: Eduardo Silva Date: Fri, 8 Aug 2025 12:54:42 +0100 Subject: [PATCH] Proper model layer --- src/expenses/aux.go | 9 + src/expenses/expenseDebts.go | 8 +- src/expenses/expenseDebts_aux.go | 16 +- src/expenses/expenseDebts_aux_test.go | 25 +- src/expenses/expensePayments.go | 144 +++------- src/expenses/expenseShares.go | 118 +++----- src/expenses/expenseSummary.go | 46 +-- src/expenses/expenses.go | 227 ++------------- .../models/{categories.go => category.go} | 15 - src/expenses/models/categoryRepoMap.go | 18 ++ src/expenses/models/expense.go | 261 ++++++++++++++++++ .../expensePaymentRepoMap.go} | 12 +- src/expenses/models/expensePayments.go | 124 +++++++++ .../expenseRepoMap.go} | 48 +--- src/expenses/models/expenseShare.go | 99 +++++++ .../expenseShareRepoMap.go} | 12 +- src/expenses/models/store.go | 135 +++++++++ .../storeRepoMap.go} | 7 +- src/expenses/models/type.go | 147 ++++++++++ .../typeRepoMap.go} | 7 +- src/expenses/models/user.go | 52 ++++ src/expenses/stores.go | 130 ++------- src/expenses/types.go | 143 ++-------- src/expenses/users.go | 49 +--- src/pages/categories.go | 4 +- src/pages/expenses.go | 16 +- src/pages/expensesHelper.go | 108 ++------ src/pages/overview.go | 30 +- src/pages/payments.go | 10 +- src/pages/stores.go | 24 +- src/pages/types.go | 22 +- 31 files changed, 1098 insertions(+), 968 deletions(-) create mode 100644 src/expenses/aux.go rename src/expenses/models/{categories.go => category.go} (88%) create mode 100644 src/expenses/models/categoryRepoMap.go create mode 100644 src/expenses/models/expense.go rename src/expenses/{expensePaymentsDomainModel.go => models/expensePaymentRepoMap.go} (74%) create mode 100644 src/expenses/models/expensePayments.go rename src/expenses/{expensesDomainModel.go => models/expenseRepoMap.go} (58%) create mode 100644 src/expenses/models/expenseShare.go rename src/expenses/{expensesSharesDomainModel.go => models/expenseShareRepoMap.go} (74%) create mode 100644 src/expenses/models/store.go rename src/expenses/{storesDomainModel.go.go => models/storeRepoMap.go} (81%) create mode 100644 src/expenses/models/type.go rename src/expenses/{typesDomainModel.go.go => models/typeRepoMap.go} (81%) create mode 100644 src/expenses/models/user.go diff --git a/src/expenses/aux.go b/src/expenses/aux.go new file mode 100644 index 0000000..b7a32b8 --- /dev/null +++ b/src/expenses/aux.go @@ -0,0 +1,9 @@ +package expenses + +import ( + "strconv" +) + +func ParseID(s string) (int64, error) { + return strconv.ParseInt(s, 10, 16) +} diff --git a/src/expenses/expenseDebts.go b/src/expenses/expenseDebts.go index 6616a36..155f531 100644 --- a/src/expenses/expenseDebts.go +++ b/src/expenses/expenseDebts.go @@ -1,7 +1,11 @@ package expenses +import ( + mod "expenses/expenses/models" +) + type Debt struct { - Debtor User + Debtor mod.User Sum float64 } @@ -15,7 +19,7 @@ func sortBySum(a, b Debt) int { return 0 } -func (e *Expense) CalculateDebts() ([]Debt, error) { +func CalculateDebts(e *mod.Expense) ([]Debt, error) { dc := NewDebtCalculator(e) dc.mapShares() dc.mapPayments() diff --git a/src/expenses/expenseDebts_aux.go b/src/expenses/expenseDebts_aux.go index 3f2992e..85cbc4d 100644 --- a/src/expenses/expenseDebts_aux.go +++ b/src/expenses/expenseDebts_aux.go @@ -1,15 +1,19 @@ package expenses +import ( + mod "expenses/expenses/models" +) + type DebtCalculator struct { - Shares map[User]float64 - Payments map[User]float64 - Expense *Expense + Shares map[mod.User]float64 + Payments map[mod.User]float64 + Expense *mod.Expense } -func NewDebtCalculator(e *Expense) *DebtCalculator { +func NewDebtCalculator(e *mod.Expense) *DebtCalculator { return &DebtCalculator{ - Shares: make(map[User]float64), - Payments: make(map[User]float64), + Shares: make(map[mod.User]float64), + Payments: make(map[mod.User]float64), Expense: e, } } diff --git a/src/expenses/expenseDebts_aux_test.go b/src/expenses/expenseDebts_aux_test.go index ce4c743..9d3c0b4 100644 --- a/src/expenses/expenseDebts_aux_test.go +++ b/src/expenses/expenseDebts_aux_test.go @@ -1,38 +1,39 @@ package expenses import ( + mod "expenses/expenses/models" "reflect" "slices" "testing" ) var ( - user1 = User{ + user1 = mod.User{ UserID: 1, UserName: "Fernando Silva", } - user2 = User{ + user2 = mod.User{ UserID: 2, UserName: "Paulo Fultre", } - user3 = User{ + user3 = mod.User{ UserID: 3, UserName: "Afonso Esteves", } - user4 = User{ + user4 = mod.User{ UserID: 4, UserName: "Sílvio Vieira", } - expense1 = Expense{ + expense1 = mod.Expense{ ExpID: 0, Value: 150, - Shares: []ExpenseShare{ + Shares: []mod.ExpenseShare{ {ExpShareID: 0, User: user1, Share: 0.4}, {ExpShareID: 1, User: user2, Share: 0.4}, {ExpShareID: 2, User: user3, Share: 0.2}, }, - Payments: []ExpensePayment{ + Payments: []mod.ExpensePayment{ {ExpPaymID: 0, User: user1, PayedAmount: 50}, {ExpPaymID: 1, User: user1, PayedAmount: 50}, {ExpPaymID: 2, User: user2, PayedAmount: 0}, @@ -41,16 +42,16 @@ var ( }, } - expense2 = Expense{ + expense2 = mod.Expense{ ExpID: 0, Value: 160, - Shares: []ExpenseShare{ + Shares: []mod.ExpenseShare{ {ExpShareID: 0, User: user1, Share: 0.3}, {ExpShareID: 1, User: user2, Share: 0.3}, {ExpShareID: 2, User: user3, Share: 0.3}, {ExpShareID: 3, User: user4, Share: 0.1}, }, - Payments: []ExpensePayment{ + Payments: []mod.ExpensePayment{ {ExpPaymID: 0, User: user1, PayedAmount: 40}, {ExpPaymID: 1, User: user1, PayedAmount: 40}, {ExpPaymID: 2, User: user2, PayedAmount: 5}, @@ -64,13 +65,13 @@ var ( ) func TestSharesAndPaymentsMapping(t *testing.T) { - expectedPayments := map[User]float32{ + expectedPayments := map[mod.User]float32{ user1: 100, user2: 0, user3: 60, } - expectedShares := map[User]float32{ + expectedShares := map[mod.User]float32{ user1: 0.4, user2: 0.4, user3: 0.2, diff --git a/src/expenses/expensePayments.go b/src/expenses/expensePayments.go index 9167ae3..f4ebe9a 100644 --- a/src/expenses/expensePayments.go +++ b/src/expenses/expensePayments.go @@ -1,118 +1,54 @@ package expenses import ( - "context" - "expenses/config" - repo "expenses/expenses/db/repository" - - "database/sql" - "fmt" - - _ "github.com/mattn/go-sqlite3" + mod "expenses/expenses/models" + "strconv" ) -func (e *Expense) GetPayments() error { - cfg := config.GetInstance() - ctx := context.Background() +// TODO +// Do not pass an array of strings here, have a separate function to do the +// conversion that the user calls before calling this +// Can even create a struct to then hold the data +func ParseFormPayments(userIDs []string, paymentsIDs []string, + values []string) ([]mod.ExpensePayment, error) { + payments := []mod.ExpensePayment{} + for k := range userIDs { + userID, err := strconv.ParseInt(userIDs[k], 10, 16) + if err != nil { + return nil, err + } - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return err - } - defer db.Close() + payed, err := strconv.ParseFloat(values[k], 32) + if err != nil { + return nil, err + } - queries := repo.New(db) - payments, err := queries.GetPayments(ctx, e.ExpID) - if err != nil { - return err + newPayment := mod.ExpensePayment{ + ExpPaymID: -1, + User: mod.User{ + UserID: userID, + }, + PayedAmount: payed, + } + + if paymentsIDs[k] != "" { + id, err := strconv.ParseInt(paymentsIDs[k], 10, 16) + if err != nil { + return nil, err + } + newPayment.ExpPaymID = id + } + + payments = append(payments, newPayment) } - e.Payments = mapRepoGetPaymentsRows(payments) - return nil + return payments, nil } -func (p *ExpensePayment) Insert(expID int64) error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.InsertPayment(ctx, repo.InsertPaymentParams{ - ExpID: expID, - UserID: p.User.UserID, - Payed: p.PayedAmount, - }) - if err != nil { - return err +func DeletePayment(id int64) error { + payment := mod.ExpensePayment{ + ExpPaymID: id, } - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - return nil -} - -func (p *ExpensePayment) Update() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.UpdatePayment(ctx, repo.UpdatePaymentParams{ - ExpPaymID: p.ExpPaymID, - Payed: p.PayedAmount, - UserID: p.User.UserID, - }) - if err != nil { - return err - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - return nil -} - -func (p *ExpensePayment) Delete() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.DeletePayment(ctx, p.ExpPaymID) - if err != nil { - return err - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - return nil + return payment.Delete() } diff --git a/src/expenses/expenseShares.go b/src/expenses/expenseShares.go index f7dc1a8..1e810e1 100644 --- a/src/expenses/expenseShares.go +++ b/src/expenses/expenseShares.go @@ -1,93 +1,47 @@ package expenses import ( - "context" - "expenses/config" - "expenses/expenses/db/repository" - repo "expenses/expenses/db/repository" + "strconv" - "database/sql" - "fmt" - - _ "github.com/mattn/go-sqlite3" + mod "expenses/expenses/models" ) -func (e *Expense) GetShares() error { - cfg := config.GetInstance() - ctx := context.Background() +// TODO +// Do not pass an array of strings here, have a separate function to do the +// conversion that the user calls before calling this +// Can even create a struct to then hold the data +func ParseFormShares(userIDs []string, shares []string, sharesIDs []string, +) ([]mod.ExpenseShare, error) { + shareList := []mod.ExpenseShare{} + for i := range userIDs { + userID, err := strconv.ParseInt(userIDs[i], 10, 16) + if err != nil { + return nil, err + } - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return err - } - defer db.Close() + share, err := strconv.ParseFloat(shares[i], 32) + if err != nil { + return nil, err + } - queries := repository.New(db) - shares, err := queries.GetShares(ctx, e.ExpID) - if err != nil { - return err + newShare := mod.ExpenseShare{ + ExpShareID: -1, + User: mod.User{ + UserID: userID, + }, + Share: share, + } + + if sharesIDs[i] != "" { + id, err := strconv.ParseInt(sharesIDs[i], 10, 16) + if err != nil { + return nil, err + } + newShare.ExpShareID = id + } + + shareList = append(shareList, newShare) } - e.Shares = mapRepoGetSharesRows(shares) - return nil -} - -func (sh *ExpenseShare) Insert(expID int64) error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.InsertShare(ctx, repo.InsertShareParams{ - ExpID: expID, - Share: sh.Share, - UserID: sh.User.UserID, - }) - if err != nil { - return err - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - return nil -} - -func (sh *ExpenseShare) Update() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.UpdateShare(ctx, repo.UpdateShareParams{ - ExpShareID: sh.ExpShareID, - Share: sh.Share, - UserID: sh.User.UserID, - }) - if err != nil { - return err - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - return nil + return shareList, nil } diff --git a/src/expenses/expenseSummary.go b/src/expenses/expenseSummary.go index f208684..5ae62ff 100644 --- a/src/expenses/expenseSummary.go +++ b/src/expenses/expenseSummary.go @@ -1,35 +1,39 @@ package expenses +import ( + mod "expenses/expenses/models" +) + type UserExpenseSummary struct { - User User + User mod.User Share float64 PayedTotal float64 } func NewUserExpenseSummary() UserExpenseSummary { return UserExpenseSummary{ - User: NewUser(), + User: mod.NewUser(), Share: 0.0, PayedTotal: 0.0, } } -func (e *Expense) GetSummary() ([]UserExpenseSummary, error) { - summary := []UserExpenseSummary{} - - for _, share := range e.Shares { - curSummary := NewUserExpenseSummary() - curSummary.User = share.User - curSummary.Share = share.Share - - for _, payment := range e.Payments { - if payment.User.UserID == curSummary.User.UserID { - curSummary.PayedTotal += payment.PayedAmount - } - } - - summary = append(summary, curSummary) - } - - return summary, nil -} +// func (e *Expense) GetSummary() ([]UserExpenseSummary, error) { + // summary := []UserExpenseSummary{} + // + // for _, share := range e.Shares { + // curSummary := NewUserExpenseSummary() + // curSummary.User = share.User + // curSummary.Share = share.Share + // + // for _, payment := range e.Payments { + // if payment.User.UserID == curSummary.User.UserID { + // curSummary.PayedTotal += payment.PayedAmount + // } + // } + // + // summary = append(summary, curSummary) + // } + // + // return summary, nil +// } diff --git a/src/expenses/expenses.go b/src/expenses/expenses.go index 14cceab..2417adb 100644 --- a/src/expenses/expenses.go +++ b/src/expenses/expenses.go @@ -1,226 +1,41 @@ package expenses import ( - "context" - "expenses/config" - repo "expenses/expenses/db/repository" - - "database/sql" - "fmt" - - _ "github.com/mattn/go-sqlite3" + mod "expenses/expenses/models" + "log" + "time" ) -func GetAllExpenses() ([]Expense, error) { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return []Expense{}, err - } - defer db.Close() - - queries := repo.New(db) - expenses, err := queries.GetExpenses(ctx, repo.GetExpensesParams{ - Startdate: nil, - Enddate: nil, - }) - if err != nil { - return []Expense{}, err - } - - return mapRepoGetExpensesRows(expenses), nil +func GetAllExpenses() ([]mod.Expense, error) { + return mod.GetAllExpenses() } -func GetExpense(expID int64) (Expense, error) { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) +func GetExpensesRanged(startDate string, endDate string) ([]mod.Expense, error) { + startDateTime, err := time.ParseInLocation("02-Jan-2006 15:04:05", startDate, time.UTC) if err != nil { - return Expense{}, err + log.Printf("error startDate: %v", err) + return []mod.Expense{}, nil } - defer db.Close() + start := startDateTime.Unix() - queries := repo.New(db) - expense, err := queries.GetExpense(ctx, expID) + endDateTime, err := time.ParseInLocation("02-Jan-2006 15:04:05", endDate, time.UTC) if err != nil { - return Expense{}, err + log.Printf("error endDate: %v", err) + return []mod.Expense{}, nil } + end := endDateTime.Unix() - return mapRepoGetExpenseRow(expense), nil + return mod.GetExpensesRange(start, end) } -func (exp *Expense) Insert() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err - } - defer db.Close() - - // tx, err := db.Begin() - // if err != nil { - // return err - // } - // defer tx.Rollback() - - queries := repo.New(db) - res, err := queries.InsertExpense(ctx, repo.InsertExpenseParams{ - Description: exp.Description, - Value: exp.Value, - StoreID: exp.Store.StoreID, - CategoryID: exp.Category.CategoryID, - TypeID: exp.Type.TypeID, - OwnerUserID: exp.Owner.UserID, - ExpDate: exp.Date, - CreationDate: exp.CreationDate, - }) - if err != nil { - return err - } - - expenseID, err := res.LastInsertId() - if err != nil { - return fmt.Errorf("failed to retrieve last inserted expense ID: %v", err) - } - - exp.ExpID = expenseID - - for _, share := range exp.Shares { - err := share.Insert(exp.ExpID) - if err != nil { - return err - } - } - for _, paym := range exp.Payments { - err := paym.Insert(exp.ExpID) - if err != nil { - return err - } - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - // if err = tx.Commit(); err != nil { - // TODO - // Add some kind of log here otherwise we could jusr return the commit res - // return err - // } - - return nil +func GetExpense(id int64) (mod.Expense, error) { + return mod.GetExpense(id) } -func (e *Expense) Update() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.UpdateExpense(ctx, repo.UpdateExpenseParams{ - ExpID: e.ExpID, - Description: e.Description, - Value: e.Value, - StoreID: e.Store.StoreID, - CategoryID: e.Category.CategoryID, - TypeID: e.Type.TypeID, - OwnerUserID: e.Owner.UserID, - ExpDate: e.Date, - }) - if err != nil { - return err +func DeleteExpense(id int64) error { + expense := mod.Expense{ + ExpID: id, } - for _, share := range e.Shares { - if share.ExpShareID == -1 { - err := share.Insert(e.ExpID) - if err != nil { - return err - } - } else { - share.Update() - } - } - - for _, paym := range e.Payments { - if paym.ExpPaymID == -1 { - err := paym.Insert(e.ExpID) - if err != nil { - return err - } - } else { - paym.Update() - } - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were updated") - } - - return nil -} - -func (e *Expense) Delete() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.DeleteExpense(ctx, e.ExpID) - if err != nil { - return err - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - return nil -} - -// SHITTY QUERIES THAT I NEED TO PUT IN SOMEWHERE MORE OGRANHJASLD -func GetExpensesRange(start int64, end int64) ([]Expense, error) { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return []Expense{}, err - } - defer db.Close() - - queries := repo.New(db) - expenses, err := queries.GetExpenses(ctx, repo.GetExpensesParams{ - Startdate: start, - Enddate: end, - }) - if err != nil { - return []Expense{}, err - } - - return mapRepoGetExpensesRows(expenses), nil + return expense.Delete() } diff --git a/src/expenses/models/categories.go b/src/expenses/models/category.go similarity index 88% rename from src/expenses/models/categories.go rename to src/expenses/models/category.go index aef9712..75dff0b 100644 --- a/src/expenses/models/categories.go +++ b/src/expenses/models/category.go @@ -22,21 +22,6 @@ func NewCategory() Category { } } -func MapRepoCategory(rc repo.Category) Category { - return Category{ - CategoryID: rc.CategoryID, - CategoryName: rc.CategoryName, - } -} - -func MapRepoCategories(rc []repo.Category) []Category { - categories := make([]Category, len(rc)) - for k, cat := range rc { - categories[k] = MapRepoCategory(cat) - } - return categories -} - func GetAllCategories() ([]Category, error) { cfg := config.GetInstance() ctx := context.Background() diff --git a/src/expenses/models/categoryRepoMap.go b/src/expenses/models/categoryRepoMap.go new file mode 100644 index 0000000..ffaf8c7 --- /dev/null +++ b/src/expenses/models/categoryRepoMap.go @@ -0,0 +1,18 @@ +package models + +import repo "expenses/expenses/db/repository" + +func MapRepoCategory(rc repo.Category) Category { + return Category{ + CategoryID: rc.CategoryID, + CategoryName: rc.CategoryName, + } +} + +func MapRepoCategories(rc []repo.Category) []Category { + categories := make([]Category, len(rc)) + for k, cat := range rc { + categories[k] = MapRepoCategory(cat) + } + return categories +} diff --git a/src/expenses/models/expense.go b/src/expenses/models/expense.go new file mode 100644 index 0000000..c3ae40c --- /dev/null +++ b/src/expenses/models/expense.go @@ -0,0 +1,261 @@ +package models + +import ( + "context" + "expenses/config" + repo "expenses/expenses/db/repository" + + "database/sql" + "fmt" +) + +type Expense struct { + ExpID int64 + Description string + Value float64 + Store Store + Type Type + Category Category + Owner User + Date int64 + Payments []ExpensePayment + Shares []ExpenseShare + CreationDate int64 +} + +func NewExpense() Expense { + return Expense{ + ExpID: -1, + Description: "", + Value: 0.0, + Store: NewStore(), + Category: NewCategory(), + Owner: NewUser(), + Date: 0, + Payments: []ExpensePayment{}, + Shares: []ExpenseShare{}, + CreationDate: 0, + } +} + +func mapRepoGetExpensesRows(er []repo.GetExpensesRow) []Expense { + expenses := make([]Expense, len(er)) + for k, exp := range er { + expenses[k] = mapRepoGetExpenseRowMulti(exp) + } + return expenses +} + +func GetAllExpenses() ([]Expense, error) { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return []Expense{}, err + } + defer db.Close() + + queries := repo.New(db) + expenses, err := queries.GetExpenses(ctx, repo.GetExpensesParams{ + Startdate: nil, + Enddate: nil, + }) + if err != nil { + return []Expense{}, err + } + + return mapRepoGetExpensesRows(expenses), nil +} + +func GetExpense(expID int64) (Expense, error) { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return Expense{}, err + } + defer db.Close() + + queries := repo.New(db) + expense, err := queries.GetExpense(ctx, expID) + if err != nil { + return Expense{}, err + } + + return mapRepoGetExpenseRow(expense), nil +} + +func (exp *Expense) Insert() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + // tx, err := db.Begin() + // if err != nil { + // return err + // } + // defer tx.Rollback() + + queries := repo.New(db) + res, err := queries.InsertExpense(ctx, repo.InsertExpenseParams{ + Description: exp.Description, + Value: exp.Value, + StoreID: exp.Store.StoreID, + CategoryID: exp.Category.CategoryID, + TypeID: exp.Type.TypeID, + OwnerUserID: exp.Owner.UserID, + ExpDate: exp.Date, + CreationDate: exp.CreationDate, + }) + if err != nil { + return err + } + + expenseID, err := res.LastInsertId() + if err != nil { + return fmt.Errorf("failed to retrieve last inserted expense ID: %v", err) + } + + exp.ExpID = expenseID + + for _, share := range exp.Shares { + err := share.Insert(exp.ExpID) + if err != nil { + return err + } + } + for _, paym := range exp.Payments { + err := paym.Insert(exp.ExpID) + if err != nil { + return err + } + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + // if err = tx.Commit(); err != nil { + // TODO + // Add some kind of log here otherwise we could jusr return the commit res + // return err + // } + + return nil +} + +func (e *Expense) Update() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.UpdateExpense(ctx, repo.UpdateExpenseParams{ + ExpID: e.ExpID, + Description: e.Description, + Value: e.Value, + StoreID: e.Store.StoreID, + CategoryID: e.Category.CategoryID, + TypeID: e.Type.TypeID, + OwnerUserID: e.Owner.UserID, + ExpDate: e.Date, + }) + if err != nil { + return err + } + + for _, share := range e.Shares { + if share.ExpShareID == -1 { + err := share.Insert(e.ExpID) + if err != nil { + return err + } + } else { + share.Update() + } + } + + for _, paym := range e.Payments { + if paym.ExpPaymID == -1 { + err := paym.Insert(e.ExpID) + if err != nil { + return err + } + } else { + paym.Update() + } + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were updated") + } + + return nil +} + +func (e *Expense) Delete() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.DeleteExpense(ctx, e.ExpID) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} + +// SHITTY QUERIES THAT I NEED TO PUT IN SOMEWHERE MORE OGRANHJASLD +func GetExpensesRange(start int64, end int64) ([]Expense, error) { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return []Expense{}, err + } + defer db.Close() + + queries := repo.New(db) + expenses, err := queries.GetExpenses(ctx, repo.GetExpensesParams{ + Startdate: start, + Enddate: end, + }) + if err != nil { + return []Expense{}, err + } + + return mapRepoGetExpensesRows(expenses), nil +} diff --git a/src/expenses/expensePaymentsDomainModel.go b/src/expenses/models/expensePaymentRepoMap.go similarity index 74% rename from src/expenses/expensePaymentsDomainModel.go rename to src/expenses/models/expensePaymentRepoMap.go index 5628f61..3f1beab 100644 --- a/src/expenses/expensePaymentsDomainModel.go +++ b/src/expenses/models/expensePaymentRepoMap.go @@ -1,14 +1,6 @@ -package expenses +package models -import ( - repo "expenses/expenses/db/repository" -) - -type ExpensePayment struct { - ExpPaymID int64 - User User - PayedAmount float64 -} +import repo "expenses/expenses/db/repository" func mapRepoGetPaymentsRow(s repo.GetPaymentsRow) ExpensePayment { return ExpensePayment{ diff --git a/src/expenses/models/expensePayments.go b/src/expenses/models/expensePayments.go new file mode 100644 index 0000000..0ded578 --- /dev/null +++ b/src/expenses/models/expensePayments.go @@ -0,0 +1,124 @@ +package models + +import ( + "context" + "expenses/config" + repo "expenses/expenses/db/repository" + + "database/sql" + "fmt" + + _ "github.com/mattn/go-sqlite3" +) + +type ExpensePayment struct { + ExpPaymID int64 + User User + PayedAmount float64 +} + +func (e *Expense) GetPayments() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + payments, err := queries.GetPayments(ctx, e.ExpID) + if err != nil { + return err + } + + e.Payments = mapRepoGetPaymentsRows(payments) + return nil +} + +func (p *ExpensePayment) Insert(expID int64) error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.InsertPayment(ctx, repo.InsertPaymentParams{ + ExpID: expID, + UserID: p.User.UserID, + Payed: p.PayedAmount, + }) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} + +func (p *ExpensePayment) Update() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.UpdatePayment(ctx, repo.UpdatePaymentParams{ + ExpPaymID: p.ExpPaymID, + Payed: p.PayedAmount, + UserID: p.User.UserID, + }) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} + +func (p *ExpensePayment) Delete() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.DeletePayment(ctx, p.ExpPaymID) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} diff --git a/src/expenses/expensesDomainModel.go b/src/expenses/models/expenseRepoMap.go similarity index 58% rename from src/expenses/expensesDomainModel.go rename to src/expenses/models/expenseRepoMap.go index 089dbd6..38dc54f 100644 --- a/src/expenses/expensesDomainModel.go +++ b/src/expenses/models/expenseRepoMap.go @@ -1,38 +1,6 @@ -package expenses +package models -import ( - mod "expenses/expenses/models" - repo "expenses/expenses/db/repository" -) - -type Expense struct { - ExpID int64 - Description string - Value float64 - Store Store - Type Type - Category mod.Category - Owner User - Date int64 - Payments []ExpensePayment - Shares []ExpenseShare - CreationDate int64 -} - -func NewExpense() Expense { - return Expense{ - ExpID: -1, - Description: "", - Value: 0.0, - Store: NewStore(), - Category: mod.NewCategory(), - Owner: NewUser(), - Date: 0, - Payments: []ExpensePayment{}, - Shares: []ExpenseShare{}, - CreationDate: 0, - } -} +import repo "expenses/expenses/db/repository" func mapRepoGetExpenseRow(e repo.GetExpenseRow) Expense { return Expense{ @@ -47,7 +15,7 @@ func mapRepoGetExpenseRow(e repo.GetExpenseRow) Expense { TypeID: e.ExpenseType.TypeID, TypeName: e.ExpenseType.TypeName, }, - Category: mod.Category{ + Category: Category{ CategoryID: e.Category.CategoryID, CategoryName: e.Category.CategoryName, }, @@ -75,7 +43,7 @@ func mapRepoGetExpenseRowMulti(e repo.GetExpensesRow) Expense { TypeID: e.ExpenseType.TypeID, TypeName: e.ExpenseType.TypeName, }, - Category: mod.Category{ + Category: Category{ CategoryID: e.Category.CategoryID, CategoryName: e.Category.CategoryName, }, @@ -89,11 +57,3 @@ func mapRepoGetExpenseRowMulti(e repo.GetExpensesRow) Expense { CreationDate: e.Expense.CreationDate, } } - -func mapRepoGetExpensesRows(er []repo.GetExpensesRow) []Expense { - expenses := make([]Expense, len(er)) - for k, exp := range er { - expenses[k] = mapRepoGetExpenseRowMulti(exp) - } - return expenses -} diff --git a/src/expenses/models/expenseShare.go b/src/expenses/models/expenseShare.go new file mode 100644 index 0000000..d8e9d3c --- /dev/null +++ b/src/expenses/models/expenseShare.go @@ -0,0 +1,99 @@ +package models + +import ( + "context" + "expenses/config" + "expenses/expenses/db/repository" + repo "expenses/expenses/db/repository" + + "database/sql" + "fmt" + + _ "github.com/mattn/go-sqlite3" +) + +type ExpenseShare struct { + ExpShareID int64 + User User + Share float64 +} + +func (e *Expense) GetShares() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return err + } + defer db.Close() + + queries := repository.New(db) + shares, err := queries.GetShares(ctx, e.ExpID) + if err != nil { + return err + } + + e.Shares = mapRepoGetSharesRows(shares) + return nil +} + +func (sh *ExpenseShare) Insert(expID int64) error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.InsertShare(ctx, repo.InsertShareParams{ + ExpID: expID, + Share: sh.Share, + UserID: sh.User.UserID, + }) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} + +func (sh *ExpenseShare) Update() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.UpdateShare(ctx, repo.UpdateShareParams{ + ExpShareID: sh.ExpShareID, + Share: sh.Share, + UserID: sh.User.UserID, + }) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} diff --git a/src/expenses/expensesSharesDomainModel.go b/src/expenses/models/expenseShareRepoMap.go similarity index 74% rename from src/expenses/expensesSharesDomainModel.go rename to src/expenses/models/expenseShareRepoMap.go index cd4d216..efa60a6 100644 --- a/src/expenses/expensesSharesDomainModel.go +++ b/src/expenses/models/expenseShareRepoMap.go @@ -1,14 +1,6 @@ -package expenses +package models -import ( - repo "expenses/expenses/db/repository" -) - -type ExpenseShare struct { - ExpShareID int64 - User User - Share float64 -} +import repo "expenses/expenses/db/repository" func mapRepoGetSharesRow(s repo.GetSharesRow) ExpenseShare { return ExpenseShare{ diff --git a/src/expenses/models/store.go b/src/expenses/models/store.go new file mode 100644 index 0000000..5c2da85 --- /dev/null +++ b/src/expenses/models/store.go @@ -0,0 +1,135 @@ +package models + +import ( + "context" + "expenses/config" + repo "expenses/expenses/db/repository" + experr "expenses/expenses/errors" + + "database/sql" + "fmt" + + _ "github.com/mattn/go-sqlite3" +) + +type Store struct { + StoreID int64 + StoreName string +} + +func NewStore() Store { + return Store{ + StoreID: -1, + StoreName: "", + } +} + +func GetAllStores() ([]Store, error) { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return []Store{}, err + } + defer db.Close() + + queries := repo.New(db) + storeList, err := queries.GetStores(ctx) + if err != nil { + return []Store{}, err + } + + return mapRepoStores(storeList), nil +} + +func GetStore(storeID int64) (Store, error) { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return Store{}, err + } + defer db.Close() + + queries := repo.New(db) + store, err := queries.GetStore(ctx, storeID) + if err != nil { + return Store{}, err + } + + return mapRepoStore(store), nil +} + +func (s *Store) Insert() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.InsertStore(ctx, s.StoreName) + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} + +func (s *Store) Update() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.UpdateStore(ctx, repo.UpdateStoreParams{ + StoreID: s.StoreID, + StoreName: s.StoreName, + }) + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return experr.ErrNotFound + } + + return nil +} + +func (s *Store) Delete() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.DeleteStore(ctx, s.StoreID) + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return experr.ErrNotFound + } + + return nil +} diff --git a/src/expenses/storesDomainModel.go.go b/src/expenses/models/storeRepoMap.go similarity index 81% rename from src/expenses/storesDomainModel.go.go rename to src/expenses/models/storeRepoMap.go index 35a3455..d3e65c7 100644 --- a/src/expenses/storesDomainModel.go.go +++ b/src/expenses/models/storeRepoMap.go @@ -1,12 +1,7 @@ -package expenses +package models import repo "expenses/expenses/db/repository" -type Store struct { - StoreID int64 - StoreName string -} - func mapRepoStore(rs repo.Store) Store { return Store{ StoreID: rs.StoreID, diff --git a/src/expenses/models/type.go b/src/expenses/models/type.go new file mode 100644 index 0000000..7c66f20 --- /dev/null +++ b/src/expenses/models/type.go @@ -0,0 +1,147 @@ +package models + +import ( + "context" + "expenses/config" + repo "expenses/expenses/db/repository" + experr "expenses/expenses/errors" + + "database/sql" + "fmt" + + _ "github.com/mattn/go-sqlite3" +) + +type Type struct { + TypeID int64 + TypeName string +} + +func NewType() Type { + return Type{ + TypeID: -1, + TypeName: "", + } +} + +func GetAllTypes() ([]Type, error) { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return []Type{}, err + } + defer db.Close() + + queries := repo.New(db) + typeList, err := queries.GetTypes(ctx) + if err != nil { + return []Type{}, err + } + + return mapRepoTypes(typeList), nil +} + +func GetType(typID int64) (Type, error) { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return Type{}, err + } + defer db.Close() + + queries := repo.New(db) + typ, err := queries.GetType(ctx, typID) + if err != nil { + return Type{}, err + } + + return mapRepoType(typ), nil +} + +func (typ *Type) Insert() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.InsertType(ctx, typ.TypeName) + if err != nil { + return err + } + + // TODO + // Move all theses things outside of this, I'll handle it wherever I'm doing + // logics + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return fmt.Errorf("no rows were created") + } + + return nil +} + +func (typ *Type) Delete() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.DeleteType(ctx, typ.TypeID) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return experr.ErrNotFound + } + + return nil +} + +func (typ *Type) Update() error { + cfg := config.GetInstance() + ctx := context.Background() + + db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") + if err != nil { + return err + } + defer db.Close() + + queries := repo.New(db) + res, err := queries.UpdateType(ctx, repo.UpdateTypeParams{ + TypeID: typ.TypeID, + TypeName: typ.TypeName, + }) + if err != nil { + return err + } + + rowsAffected, err := res.RowsAffected() + if err != nil { + return err + } else if rowsAffected == 0 { + return experr.ErrNotFound + } + + return nil +} diff --git a/src/expenses/typesDomainModel.go.go b/src/expenses/models/typeRepoMap.go similarity index 81% rename from src/expenses/typesDomainModel.go.go rename to src/expenses/models/typeRepoMap.go index aada7da..c9ae82e 100644 --- a/src/expenses/typesDomainModel.go.go +++ b/src/expenses/models/typeRepoMap.go @@ -1,12 +1,7 @@ -package expenses +package models import repo "expenses/expenses/db/repository" -type Type struct { - TypeID int64 - TypeName string -} - func mapRepoType(rt repo.ExpenseType) Type { return Type{ TypeID: rt.TypeID, diff --git a/src/expenses/models/user.go b/src/expenses/models/user.go new file mode 100644 index 0000000..f7aa2f6 --- /dev/null +++ b/src/expenses/models/user.go @@ -0,0 +1,52 @@ +package models + +import ( + "expenses/config" + + "database/sql" + "log" + + _ "github.com/mattn/go-sqlite3" +) + +type User struct { + UserID int64 + UserName string +} + +func NewUser() User { + return User{ + UserID: -1, + UserName: "", + } +} + +func GetAllUsers() ([]User, error) { + cfg := config.GetInstance() + + db, err := sql.Open(cfg.DBSys, cfg.DBPath) + if err != nil { + return nil, err + } + defer db.Close() + + query := "SELECT UserID,UserName " + + "FROM users" + + var userList []User + rows, err := db.Query(query) + if err != nil { + return nil, err + } + + for rows.Next() { + user := &User{} + err := rows.Scan(&user.UserID, &user.UserName) + if err != nil { + log.Fatalf("Failed to parse data from db: %v", err) + } + userList = append(userList, *user) + } + + return userList, nil +} diff --git a/src/expenses/stores.go b/src/expenses/stores.go index 55057f3..d5ea228 100644 --- a/src/expenses/stores.go +++ b/src/expenses/stores.go @@ -1,130 +1,36 @@ package expenses import ( - "context" - experr "expenses/expenses/errors" - "expenses/config" - repo "expenses/expenses/db/repository" - - "database/sql" - "fmt" - - _ "github.com/mattn/go-sqlite3" + mod "expenses/expenses/models" ) -func NewStore() Store { - return Store{ - StoreID: -1, - StoreName: "", - } +func GetAllStores() ([]mod.Store, error) { + return mod.GetAllStores() } -func GetAllStores() ([]Store, error) { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return []Store{}, err - } - defer db.Close() - - queries := repo.New(db) - storeList, err := queries.GetStores(ctx) - if err != nil { - return []Store{}, err - } - - return mapRepoStores(storeList), nil +func GetStore(id int64) (mod.Store, error) { + return mod.GetStore(id) } -func GetStore(storeID int64) (Store, error) { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return Store{}, err +func NewStore(name string) error { + newStore := mod.Store{ + StoreName: name, } - defer db.Close() - - queries := repo.New(db) - store, err := queries.GetStore(ctx, storeID) - if err != nil { - return Store{}, err - } - - return mapRepoStore(store), nil + return newStore.Insert() } -func (s *Store) Insert() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.InsertStore(ctx, s.StoreName) - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") +func UpdateStore(id int64, name string) error { + store := mod.Store{ + StoreID: id, + StoreName: name, } - return nil + return store.Update() } -func (s *Store) Update() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err +func DeleteStore(id int64) error { + store := mod.Store{ + StoreID: id, } - defer db.Close() - - queries := repo.New(db) - res, err := queries.UpdateStore(ctx, repo.UpdateStoreParams{ - StoreID: s.StoreID, - StoreName: s.StoreName, - }) - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return experr.ErrNotFound - } - - return nil -} - -func (s *Store) Delete() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.DeleteStore(ctx, s.StoreID) - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return experr.ErrNotFound - } - - return nil + return store.Delete() } diff --git a/src/expenses/types.go b/src/expenses/types.go index c9ee751..5bd6564 100644 --- a/src/expenses/types.go +++ b/src/expenses/types.go @@ -1,142 +1,35 @@ package expenses import ( - "context" - "expenses/config" - repo "expenses/expenses/db/repository" - experr "expenses/expenses/errors" - - "database/sql" - "fmt" - - _ "github.com/mattn/go-sqlite3" + mod "expenses/expenses/models" ) -func NewType() Type { - return Type{ - TypeID: -1, - TypeName: "", - } +func GetAllTypes() ([]mod.Type, error) { + return mod.GetAllTypes() } -func GetAllTypes() ([]Type, error) { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return []Type{}, err - } - defer db.Close() - - queries := repo.New(db) - typeList, err := queries.GetTypes(ctx) - if err != nil { - return []Type{}, err - } - - return mapRepoTypes(typeList), nil +func GetType(id int64) (mod.Type, error) { + return mod.GetType(id) } -func GetType(typID int64) (Type, error) { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return Type{}, err +func NewType(name string) error { + newTyp := mod.Type{ + TypeName: name, } - defer db.Close() - - queries := repo.New(db) - typ, err := queries.GetType(ctx, typID) - if err != nil { - return Type{}, err - } - - return mapRepoType(typ), nil + return newTyp.Insert() } -func (typ *Type) Insert() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err +func DeleteType(id int64) error { + typ := mod.Type{ + TypeID: id, } - defer db.Close() - - queries := repo.New(db) - res, err := queries.InsertType(ctx, typ.TypeName) - if err != nil { - return err - } - - // TODO - // Move all theses things outside of this, I'll handle it wherever I'm doing - // logics - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return fmt.Errorf("no rows were created") - } - - return nil + return typ.Delete() } -func (typ *Type) Delete() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err +func UpdateType(id int64, name string) error { + newTyp := mod.Type{ + TypeID: id, + TypeName: name, } - defer db.Close() - - queries := repo.New(db) - res, err := queries.DeleteType(ctx, typ.TypeID) - if err != nil { - return err - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return experr.ErrNotFound - } - - return nil -} - -func (typ *Type) Update() error { - cfg := config.GetInstance() - ctx := context.Background() - - db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on") - if err != nil { - return err - } - defer db.Close() - - queries := repo.New(db) - res, err := queries.UpdateType(ctx, repo.UpdateTypeParams{ - TypeID: typ.TypeID, - TypeName: typ.TypeName, - }) - if err != nil { - return err - } - - rowsAffected, err := res.RowsAffected() - if err != nil { - return err - } else if rowsAffected == 0 { - return experr.ErrNotFound - } - - return nil + return newTyp.Update() } diff --git a/src/expenses/users.go b/src/expenses/users.go index 4f7deeb..dc189c2 100644 --- a/src/expenses/users.go +++ b/src/expenses/users.go @@ -1,52 +1,9 @@ package expenses import ( - "expenses/config" - - "database/sql" - "log" - - _ "github.com/mattn/go-sqlite3" + mod "expenses/expenses/models" ) -type User struct { - UserID int64 - UserName string -} - -func NewUser() User { - return User{ - UserID: -1, - UserName: "", - } -} - -func GetAllUsers() ([]User, error) { - cfg := config.GetInstance() - - db, err := sql.Open(cfg.DBSys, cfg.DBPath) - if err != nil { - return nil, err - } - defer db.Close() - - query := "SELECT UserID,UserName " + - "FROM users" - - var userList []User - rows, err := db.Query(query) - if err != nil { - return nil, err - } - - for rows.Next() { - user := &User{} - err := rows.Scan(&user.UserID, &user.UserName) - if err != nil { - log.Fatalf("Failed to parse data from db: %v", err) - } - userList = append(userList, *user) - } - - return userList, nil +func GetAllUsers() ([]mod.User, error) { + return mod.GetAllUsers() } diff --git a/src/pages/categories.go b/src/pages/categories.go index a4ef09a..7e355e3 100644 --- a/src/pages/categories.go +++ b/src/pages/categories.go @@ -79,7 +79,7 @@ func createCategory(c *gin.Context) { } func updateCategory(c *gin.Context) { - categoryID, err := strconv.ParseInt(c.Param("id"), 10, 16) + categoryID, err := expenses.ParseID(c.Param("id")) if err != nil { NotFoundView(c, "No such category") return @@ -97,7 +97,7 @@ func updateCategory(c *gin.Context) { } func deleteCategory(c *gin.Context) { - categoryID, err := strconv.ParseInt(c.Param("id"), 10, 16) + categoryID, err := expenses.ParseID(c.Param("id")) if err != nil { NotFoundView(c, "No such category") return diff --git a/src/pages/expenses.go b/src/pages/expenses.go index f34ed50..bf3d1b9 100644 --- a/src/pages/expenses.go +++ b/src/pages/expenses.go @@ -5,6 +5,7 @@ import ( "encoding/json" "expenses/expenses" experr "expenses/expenses/errors" + mod "expenses/expenses/models" "fmt" "strconv" @@ -45,9 +46,10 @@ func ExpensesGlobalPage(c *gin.Context) { } func expensePage(c *gin.Context) { - expenseID, err := strconv.ParseInt(c.Param("id"), 10, 64) + expenseID, err := expenses.ParseID(c.Param("id")) if err != nil { - c.Redirect(404, "/404") + ServerErrorView(c, "failed to parse requested expenses id") + return } expense, err := expenses.GetExpense(expenseID) @@ -142,7 +144,7 @@ func newExpensePage(c *gin.Context) { "renderNavBar": false, "content": "newExpense", "method": "post", - "expense": expenses.NewExpense(), + "expense": mod.NewExpense(), "categories": categories, "stores": stores, "types": types, @@ -168,7 +170,7 @@ func createExpense(c *gin.Context) { } func updateExpense(c *gin.Context) { - expenseID, err := strconv.ParseInt(c.Param("id"), 10, 16) + expenseID, err := expenses.ParseID(c.Param("id")) if err != nil { c.Header("HX-Redirect", "/404") return @@ -200,11 +202,7 @@ func deleteExpense(c *gin.Context) { return } - payment := expenses.Expense{ - ExpID: expenseID, - } - - err = payment.Delete() + err = expenses.DeleteExpense(expenseID) if err == experr.ErrNotFound { errMsg := fmt.Sprintf("category %d not found", expenseID) c.String(http.StatusNotFound, errMsg) diff --git a/src/pages/expensesHelper.go b/src/pages/expensesHelper.go index 5d91353..2e00406 100644 --- a/src/pages/expensesHelper.go +++ b/src/pages/expensesHelper.go @@ -1,95 +1,31 @@ package pages import ( - mod "expenses/expenses/models" "expenses/expenses" + mod "expenses/expenses/models" "strconv" "time" "github.com/gin-gonic/gin" ) -func processFormShares(c *gin.Context) ([]expenses.ExpenseShare, error) { - shares := []expenses.ExpenseShare{} +func processFormShares(c *gin.Context) ([]mod.ExpenseShare, error) { + userIDS := c.PostFormArray("shares-user-ids[]") + shareIDs := c.PostFormArray("shares-ids[]") + shares := c.PostFormArray("shares-percent[]") - sharesUserIDs := c.PostFormArray("shares-user-ids[]") - formSharesIDs := c.PostFormArray("shares-ids[]") - formShares := c.PostFormArray("shares-percent[]") - - for i := range sharesUserIDs { - userID, err := strconv.ParseInt(sharesUserIDs[i], 10, 16) - if err != nil { - return nil, err - } - - share, err := strconv.ParseFloat(formShares[i], 32) - if err != nil { - return nil, err - } - - newShare := expenses.ExpenseShare{ - ExpShareID: -1, - User: expenses.User{ - UserID: userID, - }, - Share: share, - } - - if formSharesIDs[i] != "" { - id, err := strconv.ParseInt(formSharesIDs[i], 10, 16) - if err != nil { - return nil, err - } - newShare.ExpShareID = id - } - - shares = append(shares, newShare) - } - - return shares, nil + return expenses.ParseFormShares(userIDS, shares, shareIDs) } -func processFormPayments(c *gin.Context) ([]expenses.ExpensePayment, error) { - payments := []expenses.ExpensePayment{} +func processFormPayments(c *gin.Context) ([]mod.ExpensePayment, error) { + userIDs := c.PostFormArray("payments-user-ids[]") + paymentIDs := c.PostFormArray("payments-ids[]") + values := c.PostFormArray("payments-payment[]") - paymentsUserIDs := c.PostFormArray("payments-user-ids[]") - formPaymentsIDs := c.PostFormArray("payments-ids[]") - formPaymentsValues := c.PostFormArray("payments-payment[]") - - for k := range paymentsUserIDs { - userID, err := strconv.ParseInt(paymentsUserIDs[k], 10, 16) - if err != nil { - return nil, err - } - - payed, err := strconv.ParseFloat(formPaymentsValues[k], 32) - if err != nil { - return nil, err - } - - newPayment := expenses.ExpensePayment{ - ExpPaymID: -1, - User: expenses.User{ - UserID: userID, - }, - PayedAmount: payed, - } - - if formPaymentsIDs[k] != "" { - id, err := strconv.ParseInt(formPaymentsIDs[k], 10, 16) - if err != nil { - return nil, err - } - newPayment.ExpPaymID = id - } - - payments = append(payments, newPayment) - } - - return payments, nil + return expenses.ParseFormPayments(userIDs, paymentIDs, values) } -func expenseFromForm(c *gin.Context) (*expenses.Expense, error) { +func expenseFromForm(c *gin.Context) (*mod.Expense, error) { newDescription := c.PostForm("expense-desc") newDate := c.PostForm("expense-date") @@ -105,20 +41,20 @@ func expenseFromForm(c *gin.Context) (*expenses.Expense, error) { return nil, err } - newTyp := c.PostForm("newexp-type-dropdown") - typID, err := strconv.ParseInt(newTyp, 10, 16) + typID, err := expenses.ParseID(c.PostForm("newexp-type-dropdown")) if err != nil { return nil, err } - newCat := c.PostForm("newexp-cat-dropdown") - catID, err := strconv.ParseInt(newCat, 10, 16) + catID, err := expenses.ParseID(c.PostForm("newexp-cat-dropdown")) if err != nil { return nil, err } - newStore := c.PostForm("newexp-store-dropdown") - storeID, err := strconv.ParseInt(newStore, 10, 16) + // TODO: + // Move the names of the dropdowns to a variable that can be passed to the + // html page + storeID, err := expenses.ParseID(c.PostForm("newexp-store-dropdown")) if err != nil { return nil, err } @@ -132,20 +68,20 @@ func expenseFromForm(c *gin.Context) (*expenses.Expense, error) { return nil, err } - newExp := expenses.Expense{ + newExp := mod.Expense{ Description: newDescription, Date: date, Value: value, - Type: expenses.Type{ + Type: mod.Type{ TypeID: typID, }, Category: mod.Category{ CategoryID: catID, }, - Store: expenses.Store{ + Store: mod.Store{ StoreID: storeID, }, - Owner: expenses.User{ + Owner: mod.User{ // TODO // This needs to be dynamic - to be added once we have logins and whatnot UserID: 1, diff --git a/src/pages/overview.go b/src/pages/overview.go index 96c2de7..15b131f 100644 --- a/src/pages/overview.go +++ b/src/pages/overview.go @@ -2,8 +2,8 @@ package pages import ( "expenses/expenses" + mod "expenses/expenses/models" "log" - "time" "net/http" @@ -11,12 +11,12 @@ import ( ) type ExpenseDebtOverview struct { - Exp *expenses.Expense + Exp *mod.Expense Debtors []expenses.Debt } type UserDebtSummary struct { - Debtor expenses.User + Debtor mod.User Total float64 } @@ -33,24 +33,10 @@ func overviewPage(c *gin.Context) { } func getResults(c *gin.Context) { - startDateStr := c.PostForm("range-start") + " 00:00:00" - endDateStr := c.PostForm("range-end") + " 23:59:59" + startDate := c.PostForm("range-start") + " 00:00:00" + endDate := c.PostForm("range-end") + " 23:59:59" - startDateTime, err := time.ParseInLocation("02-Jan-2006 15:04:05", startDateStr, time.UTC) - if err != nil { - log.Printf("error startDate: %v", err) - return - } - startDate := startDateTime.Unix() - - endDateTime, err := time.ParseInLocation("02-Jan-2006 15:04:05", endDateStr, time.UTC) - if err != nil { - log.Printf("error endDate: %v", err) - return - } - endDate := endDateTime.Unix() - - queriedExpenses, err := expenses.GetExpensesRange(startDate, endDate) + queriedExpenses, err := expenses.GetExpensesRanged(startDate, endDate) if err != nil { log.Printf("getting expenses: %v", err) return @@ -70,14 +56,14 @@ func getResults(c *gin.Context) { } } - userDebtSummary := make(map[expenses.User]float64) + userDebtSummary := make(map[mod.User]float64) expensesWithDebts := []ExpenseDebtOverview{} for _, exp := range queriedExpenses { if len(exp.Shares) <= 1 { continue } - expenseDebts, err := exp.CalculateDebts() + expenseDebts, err := expenses.CalculateDebts(&exp) if err != nil { // whatevs yo continue diff --git a/src/pages/payments.go b/src/pages/payments.go index 1aa0a1f..739f089 100644 --- a/src/pages/payments.go +++ b/src/pages/payments.go @@ -3,25 +3,21 @@ package pages import ( "expenses/expenses" experr "expenses/expenses/errors" - "strconv" "fmt" "net/http" + "strconv" "github.com/gin-gonic/gin" ) func deletePayment(c *gin.Context) { - paymentID, err := strconv.ParseInt(c.Param("id"), 10, 16) + paymentID, err := expenses.ParseID(c.Param("id")) if err != nil { NotFoundView(c, "failed to fetch payment") return } - payment := expenses.ExpensePayment{ - ExpPaymID: paymentID, - } - - err = payment.Delete() + err = expenses.DeletePayment(paymentID) if err == experr.ErrNotFound { errMsg := fmt.Sprintf("category %d not found", paymentID) c.String(http.StatusNotFound, errMsg) diff --git a/src/pages/stores.go b/src/pages/stores.go index 6064e2f..2201b55 100644 --- a/src/pages/stores.go +++ b/src/pages/stores.go @@ -67,13 +67,9 @@ func newStorePage(c *gin.Context) { } func createStore(c *gin.Context) { - newStoreName := c.PostForm("store-name") + storeName := c.PostForm("store-name") - newStore := expenses.Store{ - StoreName: newStoreName, - } - - err := newStore.Insert() + err := expenses.NewStore(storeName) if err != nil { c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) } @@ -82,18 +78,13 @@ func createStore(c *gin.Context) { } func updateStore(c *gin.Context) { - storeID, err := strconv.ParseInt(c.Param("id"), 10, 16) + storeID, err := expenses.ParseID(c.Param("id")) if err != nil { c.Redirect(404, "/404") } newName := c.PostForm("store-name") - newStore := expenses.Store{ - StoreID: storeID, - StoreName: newName, - } - - err = newStore.Update() + err = expenses.UpdateStore(storeID, newName) if err != nil { c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) return @@ -103,15 +94,12 @@ func updateStore(c *gin.Context) { } func deleteStore(c *gin.Context) { - storeID, err := strconv.ParseInt(c.Param("id"), 10, 16) + storeID, err := expenses.ParseID(c.Param("id")) if err != nil { c.Redirect(404, "/404") } - store := expenses.Store{ - StoreID: storeID, - } - err = store.Delete() + err = expenses.DeleteStore(storeID) if err == experr.ErrNotFound { errMsg := fmt.Sprintf("category %d not found", storeID) c.String(http.StatusNotFound, errMsg) diff --git a/src/pages/types.go b/src/pages/types.go index 1763cbb..2cbacd8 100644 --- a/src/pages/types.go +++ b/src/pages/types.go @@ -69,11 +69,7 @@ func newTypePage(c *gin.Context) { func createType(c *gin.Context) { newTypName := c.PostForm("type-name") - newTyp := expenses.Type{ - TypeName: newTypName, - } - - err := newTyp.Insert() + err := expenses.NewType(newTypName) if err != nil { c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) } @@ -82,15 +78,12 @@ func createType(c *gin.Context) { } func deleteType(c *gin.Context) { - typeID, err := strconv.ParseInt(c.Param("id"), 10, 16) + typeID, err := expenses.ParseID(c.Param("id")) if err != nil { c.Redirect(404, "/404") } - typ := expenses.Type{ - TypeID: typeID, - } - err = typ.Delete() + err = expenses.DeleteType(typeID) if err == experr.ErrNotFound { errMsg := fmt.Sprintf("category %d not found", typeID) c.String(http.StatusNotFound, errMsg) @@ -107,18 +100,13 @@ func deleteType(c *gin.Context) { } func updateType(c *gin.Context) { - typeID, err := strconv.ParseInt(c.Param("id"), 10, 16) + typeID, err := expenses.ParseID(c.Param("id")) if err != nil { c.Redirect(404, "/404") } newName := c.PostForm("type-name") - newTyp := expenses.Type{ - TypeID: typeID, - TypeName: newName, - } - - err = newTyp.Update() + err = expenses.UpdateType(typeID, newName) if err != nil { c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) return