Proper model layer

This commit is contained in:
2025-08-08 12:54:42 +01:00
parent f0ca0051b6
commit e76261d5d5
31 changed files with 1098 additions and 968 deletions
+9
View File
@@ -0,0 +1,9 @@
package expenses
import (
"strconv"
)
func ParseID(s string) (int64, error) {
return strconv.ParseInt(s, 10, 16)
}
+6 -2
View File
@@ -1,7 +1,11 @@
package expenses package expenses
import (
mod "expenses/expenses/models"
)
type Debt struct { type Debt struct {
Debtor User Debtor mod.User
Sum float64 Sum float64
} }
@@ -15,7 +19,7 @@ func sortBySum(a, b Debt) int {
return 0 return 0
} }
func (e *Expense) CalculateDebts() ([]Debt, error) { func CalculateDebts(e *mod.Expense) ([]Debt, error) {
dc := NewDebtCalculator(e) dc := NewDebtCalculator(e)
dc.mapShares() dc.mapShares()
dc.mapPayments() dc.mapPayments()
+10 -6
View File
@@ -1,15 +1,19 @@
package expenses package expenses
import (
mod "expenses/expenses/models"
)
type DebtCalculator struct { type DebtCalculator struct {
Shares map[User]float64 Shares map[mod.User]float64
Payments map[User]float64 Payments map[mod.User]float64
Expense *Expense Expense *mod.Expense
} }
func NewDebtCalculator(e *Expense) *DebtCalculator { func NewDebtCalculator(e *mod.Expense) *DebtCalculator {
return &DebtCalculator{ return &DebtCalculator{
Shares: make(map[User]float64), Shares: make(map[mod.User]float64),
Payments: make(map[User]float64), Payments: make(map[mod.User]float64),
Expense: e, Expense: e,
} }
} }
+13 -12
View File
@@ -1,38 +1,39 @@
package expenses package expenses
import ( import (
mod "expenses/expenses/models"
"reflect" "reflect"
"slices" "slices"
"testing" "testing"
) )
var ( var (
user1 = User{ user1 = mod.User{
UserID: 1, UserID: 1,
UserName: "Fernando Silva", UserName: "Fernando Silva",
} }
user2 = User{ user2 = mod.User{
UserID: 2, UserID: 2,
UserName: "Paulo Fultre", UserName: "Paulo Fultre",
} }
user3 = User{ user3 = mod.User{
UserID: 3, UserID: 3,
UserName: "Afonso Esteves", UserName: "Afonso Esteves",
} }
user4 = User{ user4 = mod.User{
UserID: 4, UserID: 4,
UserName: "Sílvio Vieira", UserName: "Sílvio Vieira",
} }
expense1 = Expense{ expense1 = mod.Expense{
ExpID: 0, ExpID: 0,
Value: 150, Value: 150,
Shares: []ExpenseShare{ Shares: []mod.ExpenseShare{
{ExpShareID: 0, User: user1, Share: 0.4}, {ExpShareID: 0, User: user1, Share: 0.4},
{ExpShareID: 1, User: user2, Share: 0.4}, {ExpShareID: 1, User: user2, Share: 0.4},
{ExpShareID: 2, User: user3, Share: 0.2}, {ExpShareID: 2, User: user3, Share: 0.2},
}, },
Payments: []ExpensePayment{ Payments: []mod.ExpensePayment{
{ExpPaymID: 0, User: user1, PayedAmount: 50}, {ExpPaymID: 0, User: user1, PayedAmount: 50},
{ExpPaymID: 1, User: user1, PayedAmount: 50}, {ExpPaymID: 1, User: user1, PayedAmount: 50},
{ExpPaymID: 2, User: user2, PayedAmount: 0}, {ExpPaymID: 2, User: user2, PayedAmount: 0},
@@ -41,16 +42,16 @@ var (
}, },
} }
expense2 = Expense{ expense2 = mod.Expense{
ExpID: 0, ExpID: 0,
Value: 160, Value: 160,
Shares: []ExpenseShare{ Shares: []mod.ExpenseShare{
{ExpShareID: 0, User: user1, Share: 0.3}, {ExpShareID: 0, User: user1, Share: 0.3},
{ExpShareID: 1, User: user2, Share: 0.3}, {ExpShareID: 1, User: user2, Share: 0.3},
{ExpShareID: 2, User: user3, Share: 0.3}, {ExpShareID: 2, User: user3, Share: 0.3},
{ExpShareID: 3, User: user4, Share: 0.1}, {ExpShareID: 3, User: user4, Share: 0.1},
}, },
Payments: []ExpensePayment{ Payments: []mod.ExpensePayment{
{ExpPaymID: 0, User: user1, PayedAmount: 40}, {ExpPaymID: 0, User: user1, PayedAmount: 40},
{ExpPaymID: 1, User: user1, PayedAmount: 40}, {ExpPaymID: 1, User: user1, PayedAmount: 40},
{ExpPaymID: 2, User: user2, PayedAmount: 5}, {ExpPaymID: 2, User: user2, PayedAmount: 5},
@@ -64,13 +65,13 @@ var (
) )
func TestSharesAndPaymentsMapping(t *testing.T) { func TestSharesAndPaymentsMapping(t *testing.T) {
expectedPayments := map[User]float32{ expectedPayments := map[mod.User]float32{
user1: 100, user1: 100,
user2: 0, user2: 0,
user3: 60, user3: 60,
} }
expectedShares := map[User]float32{ expectedShares := map[mod.User]float32{
user1: 0.4, user1: 0.4,
user2: 0.4, user2: 0.4,
user3: 0.2, user3: 0.2,
+40 -104
View File
@@ -1,118 +1,54 @@
package expenses package expenses
import ( import (
"context" mod "expenses/expenses/models"
"expenses/config" "strconv"
repo "expenses/expenses/db/repository"
"database/sql"
"fmt"
_ "github.com/mattn/go-sqlite3"
) )
func (e *Expense) GetPayments() error { // TODO
cfg := config.GetInstance() // Do not pass an array of strings here, have a separate function to do the
ctx := context.Background() // 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) payed, err := strconv.ParseFloat(values[k], 32)
if err != nil { if err != nil {
return err return nil, err
} }
defer db.Close()
queries := repo.New(db) newPayment := mod.ExpensePayment{
payments, err := queries.GetPayments(ctx, e.ExpID) ExpPaymID: -1,
if err != nil { User: mod.User{
return err 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 payments, nil
return nil
} }
func (p *ExpensePayment) Insert(expID int64) error { func DeletePayment(id int64) error {
cfg := config.GetInstance() payment := mod.ExpensePayment{
ctx := context.Background() ExpPaymID: id,
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() return payment.Delete()
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
} }
+36 -82
View File
@@ -1,93 +1,47 @@
package expenses package expenses
import ( import (
"context" "strconv"
"expenses/config"
"expenses/expenses/db/repository"
repo "expenses/expenses/db/repository"
"database/sql" mod "expenses/expenses/models"
"fmt"
_ "github.com/mattn/go-sqlite3"
) )
func (e *Expense) GetShares() error { // TODO
cfg := config.GetInstance() // Do not pass an array of strings here, have a separate function to do the
ctx := context.Background() // 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) share, err := strconv.ParseFloat(shares[i], 32)
if err != nil { if err != nil {
return err return nil, err
} }
defer db.Close()
queries := repository.New(db) newShare := mod.ExpenseShare{
shares, err := queries.GetShares(ctx, e.ExpID) ExpShareID: -1,
if err != nil { User: mod.User{
return err 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 shareList, nil
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
} }
+25 -21
View File
@@ -1,35 +1,39 @@
package expenses package expenses
import (
mod "expenses/expenses/models"
)
type UserExpenseSummary struct { type UserExpenseSummary struct {
User User User mod.User
Share float64 Share float64
PayedTotal float64 PayedTotal float64
} }
func NewUserExpenseSummary() UserExpenseSummary { func NewUserExpenseSummary() UserExpenseSummary {
return UserExpenseSummary{ return UserExpenseSummary{
User: NewUser(), User: mod.NewUser(),
Share: 0.0, Share: 0.0,
PayedTotal: 0.0, PayedTotal: 0.0,
} }
} }
func (e *Expense) GetSummary() ([]UserExpenseSummary, error) { // func (e *Expense) GetSummary() ([]UserExpenseSummary, error) {
summary := []UserExpenseSummary{} // summary := []UserExpenseSummary{}
//
for _, share := range e.Shares { // for _, share := range e.Shares {
curSummary := NewUserExpenseSummary() // curSummary := NewUserExpenseSummary()
curSummary.User = share.User // curSummary.User = share.User
curSummary.Share = share.Share // curSummary.Share = share.Share
//
for _, payment := range e.Payments { // for _, payment := range e.Payments {
if payment.User.UserID == curSummary.User.UserID { // if payment.User.UserID == curSummary.User.UserID {
curSummary.PayedTotal += payment.PayedAmount // curSummary.PayedTotal += payment.PayedAmount
} // }
} // }
//
summary = append(summary, curSummary) // summary = append(summary, curSummary)
} // }
//
return summary, nil // return summary, nil
} // }
+21 -206
View File
@@ -1,226 +1,41 @@
package expenses package expenses
import ( import (
"context" mod "expenses/expenses/models"
"expenses/config" "log"
repo "expenses/expenses/db/repository" "time"
"database/sql"
"fmt"
_ "github.com/mattn/go-sqlite3"
) )
func GetAllExpenses() ([]Expense, error) { func GetAllExpenses() ([]mod.Expense, error) {
cfg := config.GetInstance() return mod.GetAllExpenses()
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) { func GetExpensesRanged(startDate string, endDate string) ([]mod.Expense, error) {
cfg := config.GetInstance() startDateTime, err := time.ParseInLocation("02-Jan-2006 15:04:05", startDate, time.UTC)
ctx := context.Background()
db, err := sql.Open(cfg.DBSys, cfg.DBPath)
if err != nil { 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) endDateTime, err := time.ParseInLocation("02-Jan-2006 15:04:05", endDate, time.UTC)
expense, err := queries.GetExpense(ctx, expID)
if err != nil { 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 { func GetExpense(id int64) (mod.Expense, error) {
cfg := config.GetInstance() return mod.GetExpense(id)
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 { func DeleteExpense(id int64) error {
cfg := config.GetInstance() expense := mod.Expense{
ctx := context.Background() ExpID: id,
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 { return expense.Delete()
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
} }
@@ -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) { func GetAllCategories() ([]Category, error) {
cfg := config.GetInstance() cfg := config.GetInstance()
ctx := context.Background() ctx := context.Background()
+18
View File
@@ -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
}
+261
View File
@@ -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
}
@@ -1,14 +1,6 @@
package expenses package models
import ( import repo "expenses/expenses/db/repository"
repo "expenses/expenses/db/repository"
)
type ExpensePayment struct {
ExpPaymID int64
User User
PayedAmount float64
}
func mapRepoGetPaymentsRow(s repo.GetPaymentsRow) ExpensePayment { func mapRepoGetPaymentsRow(s repo.GetPaymentsRow) ExpensePayment {
return ExpensePayment{ return ExpensePayment{
+124
View File
@@ -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
}
@@ -1,38 +1,6 @@
package expenses package models
import ( import repo "expenses/expenses/db/repository"
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,
}
}
func mapRepoGetExpenseRow(e repo.GetExpenseRow) Expense { func mapRepoGetExpenseRow(e repo.GetExpenseRow) Expense {
return Expense{ return Expense{
@@ -47,7 +15,7 @@ func mapRepoGetExpenseRow(e repo.GetExpenseRow) Expense {
TypeID: e.ExpenseType.TypeID, TypeID: e.ExpenseType.TypeID,
TypeName: e.ExpenseType.TypeName, TypeName: e.ExpenseType.TypeName,
}, },
Category: mod.Category{ Category: Category{
CategoryID: e.Category.CategoryID, CategoryID: e.Category.CategoryID,
CategoryName: e.Category.CategoryName, CategoryName: e.Category.CategoryName,
}, },
@@ -75,7 +43,7 @@ func mapRepoGetExpenseRowMulti(e repo.GetExpensesRow) Expense {
TypeID: e.ExpenseType.TypeID, TypeID: e.ExpenseType.TypeID,
TypeName: e.ExpenseType.TypeName, TypeName: e.ExpenseType.TypeName,
}, },
Category: mod.Category{ Category: Category{
CategoryID: e.Category.CategoryID, CategoryID: e.Category.CategoryID,
CategoryName: e.Category.CategoryName, CategoryName: e.Category.CategoryName,
}, },
@@ -89,11 +57,3 @@ func mapRepoGetExpenseRowMulti(e repo.GetExpensesRow) Expense {
CreationDate: e.Expense.CreationDate, 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
}
+99
View File
@@ -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
}
@@ -1,14 +1,6 @@
package expenses package models
import ( import repo "expenses/expenses/db/repository"
repo "expenses/expenses/db/repository"
)
type ExpenseShare struct {
ExpShareID int64
User User
Share float64
}
func mapRepoGetSharesRow(s repo.GetSharesRow) ExpenseShare { func mapRepoGetSharesRow(s repo.GetSharesRow) ExpenseShare {
return ExpenseShare{ return ExpenseShare{
+135
View File
@@ -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
}
@@ -1,12 +1,7 @@
package expenses package models
import repo "expenses/expenses/db/repository" import repo "expenses/expenses/db/repository"
type Store struct {
StoreID int64
StoreName string
}
func mapRepoStore(rs repo.Store) Store { func mapRepoStore(rs repo.Store) Store {
return Store{ return Store{
StoreID: rs.StoreID, StoreID: rs.StoreID,
+147
View File
@@ -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
}
@@ -1,12 +1,7 @@
package expenses package models
import repo "expenses/expenses/db/repository" import repo "expenses/expenses/db/repository"
type Type struct {
TypeID int64
TypeName string
}
func mapRepoType(rt repo.ExpenseType) Type { func mapRepoType(rt repo.ExpenseType) Type {
return Type{ return Type{
TypeID: rt.TypeID, TypeID: rt.TypeID,
+52
View File
@@ -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
}
+18 -112
View File
@@ -1,130 +1,36 @@
package expenses package expenses
import ( import (
"context" mod "expenses/expenses/models"
experr "expenses/expenses/errors"
"expenses/config"
repo "expenses/expenses/db/repository"
"database/sql"
"fmt"
_ "github.com/mattn/go-sqlite3"
) )
func NewStore() Store { func GetAllStores() ([]mod.Store, error) {
return Store{ return mod.GetAllStores()
StoreID: -1,
StoreName: "",
}
} }
func GetAllStores() ([]Store, error) { func GetStore(id int64) (mod.Store, error) {
cfg := config.GetInstance() return mod.GetStore(id)
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) { func NewStore(name string) error {
cfg := config.GetInstance() newStore := mod.Store{
ctx := context.Background() StoreName: name,
db, err := sql.Open(cfg.DBSys, cfg.DBPath)
if err != nil {
return Store{}, err
} }
defer db.Close() return newStore.Insert()
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 { func UpdateStore(id int64, name string) error {
cfg := config.GetInstance() store := mod.Store{
ctx := context.Background() StoreID: id,
StoreName: name,
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 return store.Update()
} }
func (s *Store) Update() error { func DeleteStore(id int64) error {
cfg := config.GetInstance() store := mod.Store{
ctx := context.Background() StoreID: id,
db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on")
if err != nil {
return err
} }
defer db.Close() return store.Delete()
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
} }
+18 -125
View File
@@ -1,142 +1,35 @@
package expenses package expenses
import ( import (
"context" mod "expenses/expenses/models"
"expenses/config"
repo "expenses/expenses/db/repository"
experr "expenses/expenses/errors"
"database/sql"
"fmt"
_ "github.com/mattn/go-sqlite3"
) )
func NewType() Type { func GetAllTypes() ([]mod.Type, error) {
return Type{ return mod.GetAllTypes()
TypeID: -1,
TypeName: "",
}
} }
func GetAllTypes() ([]Type, error) { func GetType(id int64) (mod.Type, error) {
cfg := config.GetInstance() return mod.GetType(id)
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) { func NewType(name string) error {
cfg := config.GetInstance() newTyp := mod.Type{
ctx := context.Background() TypeName: name,
db, err := sql.Open(cfg.DBSys, cfg.DBPath)
if err != nil {
return Type{}, err
} }
defer db.Close() return newTyp.Insert()
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 { func DeleteType(id int64) error {
cfg := config.GetInstance() typ := mod.Type{
ctx := context.Background() TypeID: id,
db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on")
if err != nil {
return err
} }
defer db.Close() return typ.Delete()
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 { func UpdateType(id int64, name string) error {
cfg := config.GetInstance() newTyp := mod.Type{
ctx := context.Background() TypeID: id,
TypeName: name,
db, err := sql.Open(cfg.DBSys, "file:"+cfg.DBPath+"?_foreign_keys=on")
if err != nil {
return err
} }
defer db.Close() return newTyp.Update()
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
} }
+3 -46
View File
@@ -1,52 +1,9 @@
package expenses package expenses
import ( import (
"expenses/config" mod "expenses/expenses/models"
"database/sql"
"log"
_ "github.com/mattn/go-sqlite3"
) )
type User struct { func GetAllUsers() ([]mod.User, error) {
UserID int64 return mod.GetAllUsers()
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
} }
+2 -2
View File
@@ -79,7 +79,7 @@ func createCategory(c *gin.Context) {
} }
func updateCategory(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 { if err != nil {
NotFoundView(c, "No such category") NotFoundView(c, "No such category")
return return
@@ -97,7 +97,7 @@ func updateCategory(c *gin.Context) {
} }
func deleteCategory(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 { if err != nil {
NotFoundView(c, "No such category") NotFoundView(c, "No such category")
return return
+7 -9
View File
@@ -5,6 +5,7 @@ import (
"encoding/json" "encoding/json"
"expenses/expenses" "expenses/expenses"
experr "expenses/expenses/errors" experr "expenses/expenses/errors"
mod "expenses/expenses/models"
"fmt" "fmt"
"strconv" "strconv"
@@ -45,9 +46,10 @@ func ExpensesGlobalPage(c *gin.Context) {
} }
func expensePage(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 { if err != nil {
c.Redirect(404, "/404") ServerErrorView(c, "failed to parse requested expenses id")
return
} }
expense, err := expenses.GetExpense(expenseID) expense, err := expenses.GetExpense(expenseID)
@@ -142,7 +144,7 @@ func newExpensePage(c *gin.Context) {
"renderNavBar": false, "renderNavBar": false,
"content": "newExpense", "content": "newExpense",
"method": "post", "method": "post",
"expense": expenses.NewExpense(), "expense": mod.NewExpense(),
"categories": categories, "categories": categories,
"stores": stores, "stores": stores,
"types": types, "types": types,
@@ -168,7 +170,7 @@ func createExpense(c *gin.Context) {
} }
func updateExpense(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 { if err != nil {
c.Header("HX-Redirect", "/404") c.Header("HX-Redirect", "/404")
return return
@@ -200,11 +202,7 @@ func deleteExpense(c *gin.Context) {
return return
} }
payment := expenses.Expense{ err = expenses.DeleteExpense(expenseID)
ExpID: expenseID,
}
err = payment.Delete()
if err == experr.ErrNotFound { if err == experr.ErrNotFound {
errMsg := fmt.Sprintf("category %d not found", expenseID) errMsg := fmt.Sprintf("category %d not found", expenseID)
c.String(http.StatusNotFound, errMsg) c.String(http.StatusNotFound, errMsg)
+22 -86
View File
@@ -1,95 +1,31 @@
package pages package pages
import ( import (
mod "expenses/expenses/models"
"expenses/expenses" "expenses/expenses"
mod "expenses/expenses/models"
"strconv" "strconv"
"time" "time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
func processFormShares(c *gin.Context) ([]expenses.ExpenseShare, error) { func processFormShares(c *gin.Context) ([]mod.ExpenseShare, error) {
shares := []expenses.ExpenseShare{} userIDS := c.PostFormArray("shares-user-ids[]")
shareIDs := c.PostFormArray("shares-ids[]")
shares := c.PostFormArray("shares-percent[]")
sharesUserIDs := c.PostFormArray("shares-user-ids[]") return expenses.ParseFormShares(userIDS, shares, shareIDs)
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
} }
func processFormPayments(c *gin.Context) ([]expenses.ExpensePayment, error) { func processFormPayments(c *gin.Context) ([]mod.ExpensePayment, error) {
payments := []expenses.ExpensePayment{} userIDs := c.PostFormArray("payments-user-ids[]")
paymentIDs := c.PostFormArray("payments-ids[]")
values := c.PostFormArray("payments-payment[]")
paymentsUserIDs := c.PostFormArray("payments-user-ids[]") return expenses.ParseFormPayments(userIDs, paymentIDs, values)
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
} }
func expenseFromForm(c *gin.Context) (*expenses.Expense, error) { func expenseFromForm(c *gin.Context) (*mod.Expense, error) {
newDescription := c.PostForm("expense-desc") newDescription := c.PostForm("expense-desc")
newDate := c.PostForm("expense-date") newDate := c.PostForm("expense-date")
@@ -105,20 +41,20 @@ func expenseFromForm(c *gin.Context) (*expenses.Expense, error) {
return nil, err return nil, err
} }
newTyp := c.PostForm("newexp-type-dropdown") typID, err := expenses.ParseID(c.PostForm("newexp-type-dropdown"))
typID, err := strconv.ParseInt(newTyp, 10, 16)
if err != nil { if err != nil {
return nil, err return nil, err
} }
newCat := c.PostForm("newexp-cat-dropdown") catID, err := expenses.ParseID(c.PostForm("newexp-cat-dropdown"))
catID, err := strconv.ParseInt(newCat, 10, 16)
if err != nil { if err != nil {
return nil, err return nil, err
} }
newStore := c.PostForm("newexp-store-dropdown") // TODO:
storeID, err := strconv.ParseInt(newStore, 10, 16) // 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 { if err != nil {
return nil, err return nil, err
} }
@@ -132,20 +68,20 @@ func expenseFromForm(c *gin.Context) (*expenses.Expense, error) {
return nil, err return nil, err
} }
newExp := expenses.Expense{ newExp := mod.Expense{
Description: newDescription, Description: newDescription,
Date: date, Date: date,
Value: value, Value: value,
Type: expenses.Type{ Type: mod.Type{
TypeID: typID, TypeID: typID,
}, },
Category: mod.Category{ Category: mod.Category{
CategoryID: catID, CategoryID: catID,
}, },
Store: expenses.Store{ Store: mod.Store{
StoreID: storeID, StoreID: storeID,
}, },
Owner: expenses.User{ Owner: mod.User{
// TODO // TODO
// This needs to be dynamic - to be added once we have logins and whatnot // This needs to be dynamic - to be added once we have logins and whatnot
UserID: 1, UserID: 1,
+8 -22
View File
@@ -2,8 +2,8 @@ package pages
import ( import (
"expenses/expenses" "expenses/expenses"
mod "expenses/expenses/models"
"log" "log"
"time"
"net/http" "net/http"
@@ -11,12 +11,12 @@ import (
) )
type ExpenseDebtOverview struct { type ExpenseDebtOverview struct {
Exp *expenses.Expense Exp *mod.Expense
Debtors []expenses.Debt Debtors []expenses.Debt
} }
type UserDebtSummary struct { type UserDebtSummary struct {
Debtor expenses.User Debtor mod.User
Total float64 Total float64
} }
@@ -33,24 +33,10 @@ func overviewPage(c *gin.Context) {
} }
func getResults(c *gin.Context) { func getResults(c *gin.Context) {
startDateStr := c.PostForm("range-start") + " 00:00:00" startDate := c.PostForm("range-start") + " 00:00:00"
endDateStr := c.PostForm("range-end") + " 23:59:59" endDate := c.PostForm("range-end") + " 23:59:59"
startDateTime, err := time.ParseInLocation("02-Jan-2006 15:04:05", startDateStr, time.UTC) queriedExpenses, err := expenses.GetExpensesRanged(startDate, endDate)
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)
if err != nil { if err != nil {
log.Printf("getting expenses: %v", err) log.Printf("getting expenses: %v", err)
return return
@@ -70,14 +56,14 @@ func getResults(c *gin.Context) {
} }
} }
userDebtSummary := make(map[expenses.User]float64) userDebtSummary := make(map[mod.User]float64)
expensesWithDebts := []ExpenseDebtOverview{} expensesWithDebts := []ExpenseDebtOverview{}
for _, exp := range queriedExpenses { for _, exp := range queriedExpenses {
if len(exp.Shares) <= 1 { if len(exp.Shares) <= 1 {
continue continue
} }
expenseDebts, err := exp.CalculateDebts() expenseDebts, err := expenses.CalculateDebts(&exp)
if err != nil { if err != nil {
// whatevs yo // whatevs yo
continue continue
+3 -7
View File
@@ -3,25 +3,21 @@ package pages
import ( import (
"expenses/expenses" "expenses/expenses"
experr "expenses/expenses/errors" experr "expenses/expenses/errors"
"strconv"
"fmt" "fmt"
"net/http" "net/http"
"strconv"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
func deletePayment(c *gin.Context) { func deletePayment(c *gin.Context) {
paymentID, err := strconv.ParseInt(c.Param("id"), 10, 16) paymentID, err := expenses.ParseID(c.Param("id"))
if err != nil { if err != nil {
NotFoundView(c, "failed to fetch payment") NotFoundView(c, "failed to fetch payment")
return return
} }
payment := expenses.ExpensePayment{ err = expenses.DeletePayment(paymentID)
ExpPaymID: paymentID,
}
err = payment.Delete()
if err == experr.ErrNotFound { if err == experr.ErrNotFound {
errMsg := fmt.Sprintf("category %d not found", paymentID) errMsg := fmt.Sprintf("category %d not found", paymentID)
c.String(http.StatusNotFound, errMsg) c.String(http.StatusNotFound, errMsg)
+6 -18
View File
@@ -67,13 +67,9 @@ func newStorePage(c *gin.Context) {
} }
func createStore(c *gin.Context) { func createStore(c *gin.Context) {
newStoreName := c.PostForm("store-name") storeName := c.PostForm("store-name")
newStore := expenses.Store{ err := expenses.NewStore(storeName)
StoreName: newStoreName,
}
err := newStore.Insert()
if err != nil { if err != nil {
c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error()))
} }
@@ -82,18 +78,13 @@ func createStore(c *gin.Context) {
} }
func updateStore(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 { if err != nil {
c.Redirect(404, "/404") c.Redirect(404, "/404")
} }
newName := c.PostForm("store-name") newName := c.PostForm("store-name")
newStore := expenses.Store{ err = expenses.UpdateStore(storeID, newName)
StoreID: storeID,
StoreName: newName,
}
err = newStore.Update()
if err != nil { if err != nil {
c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error()))
return return
@@ -103,15 +94,12 @@ func updateStore(c *gin.Context) {
} }
func deleteStore(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 { if err != nil {
c.Redirect(404, "/404") c.Redirect(404, "/404")
} }
store := expenses.Store{ err = expenses.DeleteStore(storeID)
StoreID: storeID,
}
err = store.Delete()
if err == experr.ErrNotFound { if err == experr.ErrNotFound {
errMsg := fmt.Sprintf("category %d not found", storeID) errMsg := fmt.Sprintf("category %d not found", storeID)
c.String(http.StatusNotFound, errMsg) c.String(http.StatusNotFound, errMsg)
+5 -17
View File
@@ -69,11 +69,7 @@ func newTypePage(c *gin.Context) {
func createType(c *gin.Context) { func createType(c *gin.Context) {
newTypName := c.PostForm("type-name") newTypName := c.PostForm("type-name")
newTyp := expenses.Type{ err := expenses.NewType(newTypName)
TypeName: newTypName,
}
err := newTyp.Insert()
if err != nil { if err != nil {
c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error()))
} }
@@ -82,15 +78,12 @@ func createType(c *gin.Context) {
} }
func deleteType(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 { if err != nil {
c.Redirect(404, "/404") c.Redirect(404, "/404")
} }
typ := expenses.Type{ err = expenses.DeleteType(typeID)
TypeID: typeID,
}
err = typ.Delete()
if err == experr.ErrNotFound { if err == experr.ErrNotFound {
errMsg := fmt.Sprintf("category %d not found", typeID) errMsg := fmt.Sprintf("category %d not found", typeID)
c.String(http.StatusNotFound, errMsg) c.String(http.StatusNotFound, errMsg)
@@ -107,18 +100,13 @@ func deleteType(c *gin.Context) {
} }
func updateType(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 { if err != nil {
c.Redirect(404, "/404") c.Redirect(404, "/404")
} }
newName := c.PostForm("type-name") newName := c.PostForm("type-name")
newTyp := expenses.Type{ err = expenses.UpdateType(typeID, newName)
TypeID: typeID,
TypeName: newName,
}
err = newTyp.Update()
if err != nil { if err != nil {
c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error())) c.Header("HX-Trigger", fmt.Sprintf("{\"formState\":\"%s\"}", err.Error()))
return return