Finished the PgRepo pattern thingy

This commit is contained in:
2025-09-07 15:39:19 +01:00
parent 693f5a46a9
commit 763d19ec54
58 changed files with 1109 additions and 935 deletions
+21 -11
View File
@@ -3,32 +3,42 @@ package expenses
import (
"context"
"expenses/config"
"github.com/jackc/pgx/v5"
lua "github.com/yuin/gopher-lua"
"expenses/expenses/repo"
"log"
"strings"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
lua "github.com/yuin/gopher-lua"
)
type ExpensesApp struct {
DB *pgx.Conn
Lua *lua.LState
Lua *lua.LState
ExpRepo repo.ExpenseRepository
CategoryRepo repo.CategoryRepository
UserRepo repo.UserRepository
StoreRepo repo.StoreRepository
TypeRepo repo.TypeRepository
}
var (
App *ExpensesApp
)
func NewExpenseApp(db *pgx.Conn, luaVM *lua.LState) *ExpensesApp {
func NewExpenseApp(db *pgxpool.Pool, luaVM *lua.LState) *ExpensesApp {
return &ExpensesApp{
DB: db,
Lua: luaVM,
ExpRepo: repo.NewPgExpRepo(db),
CategoryRepo: repo.NewPgCatRepo(db),
UserRepo: repo.NewPgUserRepo(db),
StoreRepo: repo.NewPgStoreRepo(db),
TypeRepo: repo.NewPgTypeRepo(db),
Lua: luaVM,
}
}
func (a *ExpensesApp) Close() {
ctx := context.Background()
a.DB.Close(ctx)
// TODO
// Close the repos?
a.Lua.Close()
}
@@ -56,7 +66,7 @@ func StartApp() error {
ctx := context.Background()
pgStr := getPgConnString(cfg)
conn, err := pgx.Connect(ctx, pgStr)
conn, err := pgxpool.New(ctx, pgStr)
if err != nil {
log.Fatalf("Failed to open migration DB: %v", err)
}
+2 -7
View File
@@ -8,18 +8,13 @@ import (
func (a *ExpensesApp) GetAllCategories() ([]mod.Category, error) {
ctx := context.Background()
tx, err := a.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return []mod.Category{}, err
}
defer tx.Rollback(ctx)
expenses, err := mod.GetAllCategories(a.DB, tx)
categories, err := a.CategoryRepo.GetAll(ctx)
if err != nil {
return []mod.Category{}, err
}
return expenses, tx.Commit(ctx)
return categories, nil
}
func (a *ExpensesApp) GetCategory(id int32) (mod.Category, error) {
+3 -3
View File
@@ -144,8 +144,8 @@ func CalculateDebts(e *mod.Expense) (mod.Debts, error) {
return debts, nil
}
func (a *ExpensesApp) settleDebt(payment mod.ExpensePayment,
credit mod.ExpensePayment, eId int32) error {
func (a *ExpensesApp) settleDebt(payment mod.Payment,
credit mod.Payment, eId int32) error {
ctx := context.Background()
tx, err := a.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
@@ -169,7 +169,7 @@ func (a *ExpensesApp) settleDebt(payment mod.ExpensePayment,
func (a *ExpensesApp) ProcessDebt(expID int32, debt mod.Debt) error {
// We have to balance the debtor and creditor payments
payment := mod.ExpensePayment{
payment := mod.Payment{
User: mod.User{
UserID: debt.Debtor.UserID,
},
+6 -6
View File
@@ -36,7 +36,7 @@ var (
{ExpShareID: 1, User: user2, Share: dec.NewFromFloat(0.4)},
{ExpShareID: 2, User: user3, Share: dec.NewFromFloat(0.2)},
},
Payments: []mod.ExpensePayment{
Payments: []mod.Payment{
{ExpPaymID: 0, User: user1, PayedAmount: dec.NewFromInt(50)},
{ExpPaymID: 1, User: user1, PayedAmount: dec.NewFromInt(50)},
{ExpPaymID: 2, User: user2, PayedAmount: dec.NewFromInt(0)},
@@ -56,7 +56,7 @@ var (
{ExpShareID: 2, User: user3, Share: dec.NewFromFloat(0.3), Calculated: dec.NewFromFloat(48.0)},
{ExpShareID: 3, User: user4, Share: dec.NewFromFloat(0.1), Calculated: dec.NewFromFloat(16)},
},
Payments: []mod.ExpensePayment{
Payments: []mod.Payment{
{ExpPaymID: 0, User: user1, PayedAmount: dec.NewFromInt(40)},
{ExpPaymID: 1, User: user1, PayedAmount: dec.NewFromInt(40)},
{ExpPaymID: 2, User: user2, PayedAmount: dec.NewFromInt(5)},
@@ -131,7 +131,7 @@ var (
{ExpShareID: 2, User: user3, Share: dec.NewFromFloat(0.3)},
{ExpShareID: 3, User: user4, Share: dec.NewFromFloat(0.1)},
},
Payments: []mod.ExpensePayment{
Payments: []mod.Payment{
{ExpPaymID: 0, User: user1, PayedAmount: dec.NewFromInt(40)},
{ExpPaymID: 1, User: user1, PayedAmount: dec.NewFromInt(8)},
{ExpPaymID: 2, User: user2, PayedAmount: dec.NewFromInt(48)},
@@ -151,7 +151,7 @@ var (
{ExpShareID: 1, User: user2, Share: dec.NewFromFloat(0.33)},
{ExpShareID: 2, User: user3, Share: dec.NewFromFloat(0.33)},
},
Payments: []mod.ExpensePayment{
Payments: []mod.Payment{
{ExpPaymID: 0, User: user1, PayedAmount: dec.NewFromFloat(0.18)},
{ExpPaymID: 1, User: user1, PayedAmount: dec.NewFromFloat(0.16)},
{ExpPaymID: 2, User: user2, PayedAmount: dec.NewFromFloat(0.16)},
@@ -172,7 +172,7 @@ var (
{ExpShareID: 2, User: user3,
Share: dec.NewFromFloat(0.33), Calculated: dec.NewFromFloat(36.66)},
},
Payments: []mod.ExpensePayment{
Payments: []mod.Payment{
{ExpPaymID: 0, User: user1, PayedAmount: dec.NewFromFloat(37.79)},
{ExpPaymID: 1, User: user1, PayedAmount: dec.NewFromFloat(36.66)},
{ExpPaymID: 2, User: user2, PayedAmount: dec.NewFromFloat(36.66)},
@@ -190,7 +190,7 @@ var (
{ExpShareID: 2, User: user3,
Share: dec.NewFromFloat(0.33), Calculated: dec.NewFromFloat(0.16)},
},
Payments: []mod.ExpensePayment{
Payments: []mod.Payment{
{ExpPaymID: 0, User: user1, PayedAmount: dec.NewFromFloat(0.50)},
{ExpPaymID: 1, User: user2, PayedAmount: dec.NewFromFloat(0.0)},
{ExpPaymID: 2, User: user3, PayedAmount: dec.NewFromFloat(0.0)},
+9 -9
View File
@@ -13,8 +13,8 @@ import (
// 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{}
values []string) ([]mod.Payment, error) {
payments := []mod.Payment{}
for k := range userIDs {
userID, err := ParseID(userIDs[k])
if err != nil {
@@ -26,7 +26,7 @@ func ParseFormPayments(userIDs []string, paymentsIDs []string,
return nil, err
}
newPayment := mod.ExpensePayment{
newPayment := mod.Payment{
ExpPaymID: -1,
User: mod.User{
UserID: userID,
@@ -49,11 +49,11 @@ func ParseFormPayments(userIDs []string, paymentsIDs []string,
}
func (a *ExpensesApp) GetExpensePaymentByUserID(eId int32, uId int32,
) (mod.ExpensePayment, error) {
) (mod.Payment, error) {
ctx := context.Background()
tx, err := a.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return mod.ExpensePayment{}, err
return mod.Payment{}, err
}
defer tx.Rollback(ctx)
@@ -64,7 +64,7 @@ func (a *ExpensesApp) GetExpensePaymentByUserID(eId int32, uId int32,
// insertPayment allows us to insert a payment manually
// for now its private, need to figure out if it needs to be public
func (a *ExpensesApp) insertPayment(payment mod.ExpensePayment, eIdx int32) error {
func (a *ExpensesApp) insertPayment(payment mod.Payment, eIdx int32) error {
ctx := context.Background()
tx, err := a.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
@@ -88,7 +88,7 @@ func (a *ExpensesApp) DeletePayment(id int32) error {
}
defer tx.Rollback(ctx)
payment := mod.ExpensePayment{
payment := mod.Payment{
ExpPaymID: id,
}
@@ -100,7 +100,7 @@ func (a *ExpensesApp) DeletePayment(id int32) error {
return tx.Commit(ctx)
}
func (a *ExpensesApp) UpdatePayment(payment mod.ExpensePayment) error {
func (a *ExpensesApp) UpdatePayment(payment mod.Payment) error {
ctx := context.Background()
tx, err := a.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
@@ -117,7 +117,7 @@ func (a *ExpensesApp) UpdatePayment(payment mod.ExpensePayment) error {
}
func (a *ExpensesApp) AddPayment(expID int32, userID int32, sum dec.Decimal) error {
payment := mod.ExpensePayment{
payment := mod.Payment{
User: mod.User{
UserID: userID,
},
+7 -40
View File
@@ -13,18 +13,12 @@ import (
func (a *ExpensesApp) GetAllExpenses() ([]mod.Expense, error) {
ctx := context.Background()
tx, err := a.DB.Begin(ctx)
if err != nil {
return []mod.Expense{}, err
}
defer tx.Rollback(ctx)
expenses, err := mod.GetAllExpenses(a.DB, tx)
expenses, err := a.ExpRepo.GetAll(ctx)
if err != nil {
return []mod.Expense{}, err
}
return expenses, tx.Commit(ctx)
return expenses, nil
}
func (a *ExpensesApp) GetExpensesRanged(startDate string, endDate string) ([]mod.Expense, error) {
@@ -56,18 +50,12 @@ func (a *ExpensesApp) GetExpensesRanged(startDate string, endDate string) ([]mod
func (a *ExpensesApp) GetExpense(id int32) (mod.Expense, error) {
ctx := context.Background()
tx, err := a.DB.Begin(ctx)
if err != nil {
return mod.Expense{}, err
}
defer tx.Rollback(ctx)
expense, err := mod.GetExpense(a.DB, tx, id)
expense, err := a.ExpRepo.Get(ctx, id)
if err != nil {
return mod.Expense{}, err
}
return expense, tx.Commit(ctx)
return expense, nil
}
func (a *ExpensesApp) LoadExpenseShares(e *mod.Expense) error {
@@ -113,22 +101,8 @@ func (a *ExpensesApp) LoadExpenseDebts(e *mod.Expense) error {
func (a *ExpensesApp) DeleteExpense(id int32) error {
ctx := context.Background()
tx, err := a.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return err
}
defer tx.Rollback(ctx)
expense := mod.Expense{
ExpID: id,
}
err = expense.Delete(a.DB, tx)
if err != nil {
return err
}
return tx.Commit(ctx)
err := a.ExpRepo.Delete(ctx, id)
return err
}
func mapShares(e *mod.Expense) map[mod.User]decimal.Decimal {
@@ -190,16 +164,9 @@ func (a *ExpensesApp) analyzeExpense(e *mod.Expense) {
}
func (a *ExpensesApp) NewExpense(exp mod.Expense) error {
ctx := context.Background()
tx, err := a.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return err
}
defer tx.Rollback(ctx)
a.analyzeExpense(&exp)
err = exp.Insert(a.DB, tx)
err := a.Storage.Insert()
if err != nil {
return err
}
+1 -10
View File
@@ -22,16 +22,7 @@ func (a *ExpensesApp) prepareExpense(exp *mod.Expense) error {
}
func (a *ExpensesApp) luaGetAllExpenses(L *lua.LState) int {
// TODO
// It makes no sense this repeats this db thing
ctx := context.Background()
tx, err := a.DB.Begin(ctx)
if err != nil {
return returnWithError(L, err.Error())
}
defer tx.Rollback(ctx)
expenses, err := mod.GetAllExpenses(a.DB, tx)
expenses, err := a.Storage.GetAllExpenses()
tbl := L.NewTable()
for _, e := range expenses {
+1 -83
View File
@@ -1,17 +1,10 @@
package models
import (
"context"
repo "expenses/expenses/db/repository"
experr "expenses/expenses/errors"
"fmt"
"github.com/jackc/pgx/v5"
)
type Category struct {
CategoryID int32 `json:"CategoryID"`
CategoryName string `json:"CategoryName"`
}
type Categories []Category
func NewCategory() Category {
return Category{
@@ -19,78 +12,3 @@ func NewCategory() Category {
CategoryName: "",
}
}
func GetAllCategories(db repo.DBTX, tx pgx.Tx) ([]Category, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
categories, err := queries.GetCategories(ctx)
if err != nil {
return []Category{}, nil
}
return MapRepoCategories(categories), nil
}
func GetCategory(db repo.DBTX, tx pgx.Tx, catID int32) (Category, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
category, err := queries.GetCategory(ctx, catID)
return MapRepoCategory(category), err
}
func (cat *Category) Insert(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.InsertCategory(ctx, cat.CategoryName)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (cat *Category) Delete(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.DeleteCategory(ctx, cat.CategoryID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
func (cat *Category) Update(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.UpdateCategory(ctx, repo.UpdateCategoryParams{
CategoryName: cat.CategoryName,
CategoryID: cat.CategoryID,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
-18
View File
@@ -1,18 +0,0 @@
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
}
+17 -249
View File
@@ -1,33 +1,28 @@
package models
import (
"context"
"encoding/json"
repo "expenses/expenses/db/repository"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgtype"
"github.com/shopspring/decimal"
"time"
)
type Expense struct {
ExpID int32 `json:"ExpID"`
Description string `json:"Description"`
Value decimal.Decimal `json:"Value"`
Store Store `json:"Store"`
Type Type `json:"Type"`
Category Category `json:"Category"`
Owner User `json:"Owner"`
Date time.Time `json:"Date"`
Payments []ExpensePayment `json:"Payments"`
Shares []Share `json:"Shares"`
Debts Debts `json:"Debts"`
PaidOff bool `json:"PaidOff"`
SharesEven bool `json:"SharesEven"`
CreationDate time.Time `json:"CreationDate"`
ExpID int32 `json:"ExpID"`
Description string `json:"Description"`
Value decimal.Decimal `json:"Value"`
Store Store `json:"Store"`
Type Type `json:"Type"`
Category Category `json:"Category"`
Owner User `json:"Owner"`
Date time.Time `json:"Date"`
Payments []Payment `json:"Payments"`
Shares []Share `json:"Shares"`
Debts Debts `json:"Debts"`
PaidOff bool `json:"PaidOff"`
SharesEven bool `json:"SharesEven"`
CreationDate time.Time `json:"CreationDate"`
}
type Expenses []Expense
func NewExpense() Expense {
return Expense{
@@ -38,7 +33,7 @@ func NewExpense() Expense {
Category: NewCategory(),
Owner: NewUser(),
Date: time.Now(),
Payments: []ExpensePayment{},
Payments: []Payment{},
Shares: []Share{},
PaidOff: false,
SharesEven: false,
@@ -49,233 +44,6 @@ func NewExpense() Expense {
// ExpenseFromJSON takes []byte and returns an *Expense
func ExpenseFromJSON(data []byte) (*Expense, error) {
var expense Expense
err := json.Unmarshal(data, &expense)
return &expense, err
}
func GetAllExpenses(db repo.DBTX, tx pgx.Tx) ([]Expense, error) {
ctx := context.Background()
var start pgtype.Timestamp
start.Valid = false
var end pgtype.Timestamp
end.Valid = false
queries := repo.New(db).WithTx(tx)
expenses, err := queries.GetExpenses(ctx, repo.GetExpensesParams{
Startdate: start,
Enddate: end,
})
if err != nil {
return []Expense{}, err
}
return mapRepoGetExpensesRows(expenses), nil
}
func GetExpense(db repo.DBTX, tx pgx.Tx, expID int32) (Expense, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
expense, err := queries.GetExpense(ctx, expID)
if err != nil {
return Expense{}, err
}
return mapRepoGetExpenseRow(expense), nil
}
func (exp *Expense) Insert(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
value, err := decimalToNumeric(exp.Value)
if err != nil {
return err
}
paidOff, err := boolToPgBool(exp.PaidOff)
if err != nil {
return err
}
sharesEven, err := boolToPgBool(exp.SharesEven)
if err != nil {
return err
}
expDate, err := timeToTimestamp(exp.Date)
if err != nil {
return err
}
creationDate, err := timeToTimestamp(exp.CreationDate)
if err != nil {
return err
}
queries := repo.New(db).WithTx(tx)
lastInsertedID, err := queries.InsertExpense(ctx, repo.InsertExpenseParams{
Description: exp.Description,
Value: value,
StoreID: exp.Store.StoreID,
CategoryID: exp.Category.CategoryID,
TypeID: exp.Type.TypeID,
OwnerUserID: exp.Owner.UserID,
ExpDate: expDate,
PaidOff: paidOff,
SharesEven: sharesEven,
CreationDate: creationDate,
})
if err != nil {
return err
}
exp.ExpID = lastInsertedID
err = exp.InsertShares(db, tx)
if err != nil {
return err
}
err = exp.InsertPayments(db, tx)
if err != nil {
return err
}
return nil
}
func (exp *Expense) InsertShares(db repo.DBTX, tx pgx.Tx) error {
for _, share := range exp.Shares {
err := share.Insert(db, tx, exp.ExpID)
if err != nil {
return err
}
}
return nil
}
func (exp *Expense) InsertPayments(db repo.DBTX, tx pgx.Tx) error {
for _, paym := range exp.Payments {
err := paym.Insert(db, tx, exp.ExpID)
if err != nil {
return err
}
}
return nil
}
func (e *Expense) Update(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
value, err := decimalToNumeric(e.Value)
if err != nil {
return err
}
paidOff, err := boolToPgBool(e.PaidOff)
if err != nil {
return err
}
sharesEven, err := boolToPgBool(e.SharesEven)
if err != nil {
return err
}
expDate, err := timeToTimestamp(e.Date)
if err != nil {
return err
}
queries := repo.New(db).WithTx(tx)
res, err := queries.UpdateExpense(ctx, repo.UpdateExpenseParams{
ExpID: e.ExpID,
Description: e.Description,
Value: value,
StoreID: e.Store.StoreID,
CategoryID: e.Category.CategoryID,
TypeID: e.Type.TypeID,
OwnerUserID: e.Owner.UserID,
PaidOff: paidOff,
SharesEven: sharesEven,
ExpDate: expDate,
})
if err != nil {
return err
}
for _, share := range e.Shares {
if share.ExpShareID == -1 {
err := share.Insert(db, tx, e.ExpID)
if err != nil {
return err
}
} else {
share.Update(db, tx)
}
}
for _, paym := range e.Payments {
if paym.ExpPaymID == -1 {
err := paym.Insert(db, tx, e.ExpID)
if err != nil {
return err
}
} else {
paym.Update(db, tx)
}
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were updated")
}
return nil
}
func (e *Expense) Delete(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.DeleteExpense(ctx, e.ExpID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
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(db repo.DBTX, tx pgx.Tx, start time.Time, end time.Time) ([]Expense, error) {
ctx := context.Background()
startPg, err := timeToTimestamp(start)
if err != nil {
return []Expense{}, err
}
endPg, err := timeToTimestamp(end)
if err != nil {
return []Expense{}, err
}
queries := repo.New(db).WithTx(tx)
expenses, err := queries.GetExpenses(ctx, repo.GetExpensesParams{
Startdate: startPg,
Enddate: endPg,
})
if err != nil {
return []Expense{}, err
}
return mapRepoGetExpensesRows(expenses), nil
}
+4 -106
View File
@@ -1,122 +1,20 @@
package models
import (
"context"
"encoding/json"
repo "expenses/expenses/db/repository"
"fmt"
"github.com/jackc/pgx/v5"
_ "github.com/mattn/go-sqlite3"
"github.com/shopspring/decimal"
)
type ExpensePayment struct {
type Payment struct {
ExpPaymID int32
User User
PayedAmount decimal.Decimal
}
type Payments []Payment
// PaymentFromJSON takes []byte and returns an *ExpensePayment
func PaymentFromJSON(data []byte) (*ExpensePayment, error) {
var payment ExpensePayment
func PaymentFromJSON(data []byte) (*Payment, error) {
var payment Payment
err := json.Unmarshal(data, &payment)
return &payment, err
}
func (e *Expense) GetPayments(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
payments, err := queries.GetPayments(ctx, e.ExpID)
if err != nil {
return err
}
e.Payments = mapRepoGetPaymentsRows(payments)
return nil
}
func GetExpensePaymentByUserID(db repo.DBTX, tx pgx.Tx, eId int32, uId int32,
) (ExpensePayment, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
payment, err := queries.GetExpensePaymentByUser(ctx, repo.GetExpensePaymentByUserParams{
ExpID: eId,
UserID: uId,
})
if err != nil {
return ExpensePayment{}, err
}
return mapRepoGetPaymentRow(payment), nil
}
func (p *ExpensePayment) Insert(db repo.DBTX, tx pgx.Tx, expID int32) error {
ctx := context.Background()
payed, err := decimalToNumeric(p.PayedAmount)
if err != nil {
return err
}
queries := repo.New(db).WithTx(tx)
res, err := queries.InsertPayment(ctx, repo.InsertPaymentParams{
ExpID: expID,
UserID: p.User.UserID,
Payed: payed,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p *ExpensePayment) Update(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
payed, err := decimalToNumeric(p.PayedAmount)
if err != nil {
return err
}
queries := repo.New(db).WithTx(tx)
res, err := queries.UpdatePayment(ctx, repo.UpdatePaymentParams{
ExpPaymID: p.ExpPaymID,
Payed: payed,
UserID: p.User.UserID,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p *ExpensePayment) Delete(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.DeletePayment(ctx, p.ExpPaymID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
-98
View File
@@ -1,13 +1,7 @@
package models
import (
"context"
"encoding/json"
"expenses/expenses/db/repository"
repo "expenses/expenses/db/repository"
"fmt"
"github.com/jackc/pgx/v5"
_ "github.com/mattn/go-sqlite3"
dec "github.com/shopspring/decimal"
)
@@ -43,95 +37,3 @@ func (sh Shares) Equal(other Shares) bool {
return true
}
func (e *Expense) GetShares(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repository.New(db).WithTx(tx)
shares, err := queries.GetShares(ctx, e.ExpID)
if err != nil {
return err
}
e.Shares = mapRepoGetSharesRows(shares)
return nil
}
func (sh *Share) Insert(db repo.DBTX, tx pgx.Tx, expID int32) error {
ctx := context.Background()
share, err := decimalToNumeric(sh.Share)
if err != nil {
return err
}
calculated, err := decimalToNumeric(sh.Calculated)
if err != nil {
return err
}
queries := repo.New(db).WithTx(tx)
res, err := queries.InsertShare(ctx, repo.InsertShareParams{
ExpID: expID,
Share: share,
UserID: sh.User.UserID,
Calculated: calculated,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (sh *Share) Update(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
share, err := decimalToNumeric(sh.Share)
if err != nil {
return err
}
calculated, err := decimalToNumeric(sh.Calculated)
if err != nil {
return err
}
queries := repo.New(db).WithTx(tx)
res, err := queries.UpdateShare(ctx, repo.UpdateShareParams{
ExpShareID: sh.ExpShareID,
Share: share,
UserID: sh.User.UserID,
Calculated: calculated,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (sh *Share) Delete(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.DeleteShare(ctx, sh.ExpShareID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
+1 -82
View File
@@ -1,18 +1,10 @@
package models
import (
"context"
repo "expenses/expenses/db/repository"
experr "expenses/expenses/errors"
"fmt"
"github.com/jackc/pgx/v5"
_ "github.com/mattn/go-sqlite3"
)
type Store struct {
StoreID int32 `json:"StoreID"`
StoreName string `json:"StoreName"`
}
type Stores []Store
func NewStore() Store {
return Store{
@@ -20,76 +12,3 @@ func NewStore() Store {
StoreName: "",
}
}
func GetAllStores(db repo.DBTX, tx pgx.Tx) ([]Store, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
storeList, err := queries.GetStores(ctx)
if err != nil {
return []Store{}, err
}
return mapRepoStores(storeList), nil
}
func GetStore(db repo.DBTX, tx pgx.Tx, storeID int32) (Store, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
store, err := queries.GetStore(ctx, storeID)
if err != nil {
return Store{}, err
}
return mapRepoStore(store), nil
}
func (s *Store) Insert(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.InsertStore(ctx, s.StoreName)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (s *Store) Update(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
_, err := queries.UpdateStore(ctx, repo.UpdateStoreParams{
StoreID: s.StoreID,
StoreName: s.StoreName,
})
if err != nil {
return err
}
return nil
}
func (s *Store) Delete(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.DeleteStore(ctx, s.StoreID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
-18
View File
@@ -1,18 +0,0 @@
package models
import repo "expenses/expenses/db/repository"
func mapRepoStore(rs repo.Store) Store {
return Store{
StoreID: rs.StoreID,
StoreName: rs.StoreName,
}
}
func mapRepoStores(rs []repo.Store) []Store {
stores := make([]Store, len(rs))
for k, store := range rs {
stores[k] = mapRepoStore(store)
}
return stores
}
+1 -90
View File
@@ -1,18 +1,10 @@
package models
import (
"context"
repo "expenses/expenses/db/repository"
experr "expenses/expenses/errors"
"fmt"
"github.com/jackc/pgx/v5"
_ "github.com/mattn/go-sqlite3"
)
type Type struct {
TypeID int32 `json:"TypeID"`
TypeName string `json:"TypeName"`
}
type Types []Type
func NewType() Type {
return Type{
@@ -20,84 +12,3 @@ func NewType() Type {
TypeName: "",
}
}
func GetAllTypes(db repo.DBTX, tx pgx.Tx) ([]Type, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
typeList, err := queries.GetTypes(ctx)
if err != nil {
return []Type{}, err
}
return mapRepoTypes(typeList), nil
}
func GetType(db repo.DBTX, tx pgx.Tx, typID int32) (Type, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
typ, err := queries.GetType(ctx, typID)
if err != nil {
return Type{}, err
}
return mapRepoType(typ), nil
}
func (typ *Type) Insert(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
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 := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (typ *Type) Delete(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.DeleteType(ctx, typ.TypeID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
func (typ *Type) Update(db repo.DBTX, tx pgx.Tx) error {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
res, err := queries.UpdateType(ctx, repo.UpdateTypeParams{
TypeID: typ.TypeID,
TypeName: typ.TypeName,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
-18
View File
@@ -1,18 +0,0 @@
package models
import repo "expenses/expenses/db/repository"
func mapRepoType(rt repo.ExpenseType) Type {
return Type{
TypeID: rt.TypeID,
TypeName: rt.TypeName,
}
}
func mapRepoTypes(rt []repo.ExpenseType) []Type {
types := make([]Type, len(rt))
for k, typ := range rt {
types[k] = mapRepoType(typ)
}
return types
}
+1 -19
View File
@@ -1,16 +1,10 @@
package models
import (
"context"
repo "expenses/expenses/db/repository"
"github.com/jackc/pgx/v5"
_ "github.com/mattn/go-sqlite3"
)
type User struct {
UserID int32 `json:"UserID"`
UserName string `json:"UserName"`
}
type Users []User
func NewUser() User {
return User{
@@ -18,15 +12,3 @@ func NewUser() User {
UserName: "",
}
}
func GetAllUsers(db repo.DBTX, tx pgx.Tx) ([]User, error) {
ctx := context.Background()
queries := repo.New(db).WithTx(tx)
userList, err := queries.GetUsers(ctx)
if err != nil {
return []User{}, err
}
return mapRepoUsers(userList), nil
}
-18
View File
@@ -1,18 +0,0 @@
package models
import repo "expenses/expenses/db/repository"
func mapRepoUser(ru repo.User) User {
return User{
UserID: ru.UserID,
UserName: ru.UserName,
}
}
func mapRepoUsers(ru []repo.User) []User {
users := make([]User, len(ru))
for k, u := range ru {
users[k] = mapRepoUser(u)
}
return users
}
+14
View File
@@ -0,0 +1,14 @@
package repo
import (
"context"
mod "expenses/expenses/models"
)
type CategoryRepository interface {
Get(ctx context.Context, id int32) (mod.Category, error)
GetAll(ctx context.Context) (mod.Categories, error)
Update(ctx context.Context, cat mod.Category) error
Insert(ctx context.Context, cat mod.Category) error
Delete(ctx context.Context, id int32) error
}
+34
View File
@@ -0,0 +1,34 @@
package repo
import (
"context"
mod "expenses/expenses/models"
"time"
)
type ExpenseRepository interface {
// Direct expense methods
Get(ctx context.Context, id int32) (mod.Expense, error)
GetAll(ctx context.Context) (mod.Expenses, error)
GetExpensesRange(ctx context.Context, start time.Time,
end time.Time) (mod.Expenses, error)
Update(ctx context.Context, exp mod.Expense) error
Insert(ctx context.Context, exp mod.Expense) error
Delete(ctx context.Context, id int32) error
// Share methods
GetShares(ctx context.Context, eId int32) (mod.Shares, error)
UpdateShare(ctx context.Context, sh mod.Share) error
InsertShare(ctx context.Context, eId int32, sh mod.Share) error
InsertShares(ctx context.Context, eId int32, sh mod.Shares) error
DeleteShare(ctx context.Context, sh mod.Share) error
// Payment methods
GetPayments(ctx context.Context, eId int32) (mod.Payments, error)
GetExpensePaymentByUserID(ctx context.Context, eId int32,
uId int32) (mod.Payment, error)
UpdatePayment(ctx context.Context, pm mod.Payment) error
InsertPayment(ctx context.Context, eId int32, pm mod.Payment) error
InsertPayments(ctx context.Context, eId int32, pm mod.Payments) error
DeletePayment(ctx context.Context, pm mod.Payment) error
}
+83
View File
@@ -0,0 +1,83 @@
package repo
import (
"context"
experr "expenses/expenses/errors"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
"fmt"
"github.com/jackc/pgx/v5/pgxpool"
)
type PgCatRepo struct {
DB *pgxpool.Pool
}
func NewPgCatRepo(db *pgxpool.Pool) CategoryRepository {
return PgCatRepo{
DB: db,
}
}
func (p PgCatRepo) Get(ctx context.Context, id int32) (mod.Category, error) {
queries := pgsqlc.New(p.DB)
category, err := queries.GetCategory(ctx, id)
return MapRepoCategory(category), err
}
func (p PgCatRepo) GetAll(ctx context.Context) (mod.Categories, error) {
queries := pgsqlc.New(p.DB)
categories, err := queries.GetCategories(ctx)
if err != nil {
return mod.Categories{}, nil
}
return MapRepoCategories(categories), nil
}
func (p PgCatRepo) Update(ctx context.Context, cat mod.Category) error {
queries := pgsqlc.New(p.DB)
res, err := queries.UpdateCategory(ctx, pgsqlc.UpdateCategoryParams{
CategoryName: cat.CategoryName,
CategoryID: cat.CategoryID,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
func (p PgCatRepo) Insert(ctx context.Context, cat mod.Category) error {
queries := pgsqlc.New(p.DB)
res, err := queries.InsertCategory(ctx, cat.CategoryName)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p PgCatRepo) Delete(ctx context.Context, id int32) error {
queries := pgsqlc.New(p.DB)
res, err := queries.DeleteCategory(ctx, id)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
@@ -0,0 +1,21 @@
package repo
import (
mod "expenses/expenses/models"
pgsqlc "expenses/expenses/repo/pgdb/pgsqlc"
)
func MapRepoCategory(rc pgsqlc.Category) mod.Category {
return mod.Category{
CategoryID: rc.CategoryID,
CategoryName: rc.CategoryName,
}
}
func MapRepoCategories(rc []pgsqlc.Category) mod.Categories {
categories := make(mod.Categories, len(rc))
for k, cat := range rc {
categories[k] = MapRepoCategory(cat)
}
return categories
}
@@ -1,4 +1,4 @@
package models
package repo
import (
"github.com/jackc/pgx/v5/pgtype"
+134
View File
@@ -0,0 +1,134 @@
package repo
import (
"context"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
"fmt"
)
func (p PgExpRepo) insertPayment(
ctx context.Context, q *pgsqlc.Queries, eId int32, pm mod.Payment) error {
payed, err := decimalToNumeric(pm.PayedAmount)
if err != nil {
return err
}
res, err := q.InsertPayment(ctx, pgsqlc.InsertPaymentParams{
ExpID: eId,
UserID: pm.User.UserID,
Payed: payed,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p PgExpRepo) InsertPayment(
ctx context.Context, eId int32, pm mod.Payment) error {
return p.insertPayment(ctx, pgsqlc.New(p.DB), eId, pm)
}
func (p *PgExpRepo) insertPayments(
ctx context.Context, q *pgsqlc.Queries, eId int32, pm []mod.Payment) error {
for k := range pm {
err := p.insertPayment(ctx, q, eId, pm[k])
if err != nil {
return err
}
}
return nil
}
func (p PgExpRepo) InsertPayments(
ctx context.Context, eId int32, pm mod.Payments) error {
return p.insertPayments(ctx, pgsqlc.New(p.DB), eId, pm)
}
func (p *PgExpRepo) updatePayment(
ctx context.Context, q *pgsqlc.Queries, pm mod.Payment) error {
payed, err := decimalToNumeric(pm.PayedAmount)
if err != nil {
return err
}
res, err := q.UpdatePayment(ctx, pgsqlc.UpdatePaymentParams{
ExpPaymID: pm.ExpPaymID,
Payed: payed,
UserID: pm.User.UserID,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p PgExpRepo) UpdatePayment(
ctx context.Context, pm mod.Payment) error {
return p.updatePayment(ctx, pgsqlc.New(p.DB), pm)
}
func (p *PgExpRepo) deletePayment(
ctx context.Context, q *pgsqlc.Queries, pm mod.Payment) error {
res, err := q.DeletePayment(ctx, pm.ExpPaymID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p PgExpRepo) DeletePayment(ctx context.Context, pm mod.Payment) error {
return p.deletePayment(ctx, pgsqlc.New(p.DB), pm)
}
func (p *PgExpRepo) getPayments(
ctx context.Context, q *pgsqlc.Queries, eId int32) (mod.Payments, error) {
payments, err := q.GetPayments(ctx, eId)
if err != nil {
return mod.Payments{}, err
}
return mapRepoGetPaymentsRows(payments), nil
}
func (p PgExpRepo) GetPayments(
ctx context.Context, eId int32) (mod.Payments, error) {
return p.getPayments(ctx, pgsqlc.New(p.DB), eId)
}
func (p PgExpRepo) GetExpensePaymentByUserID(ctx context.Context, eId int32, uId int32,
) (mod.Payment, error) {
queries := pgsqlc.New(p.DB)
payment, err := queries.GetExpensePaymentByUser(ctx, pgsqlc.GetExpensePaymentByUserParams{
ExpID: eId,
UserID: uId,
})
if err != nil {
return mod.Payment{}, err
}
return mapRepoGetPaymentRow(payment), nil
}
@@ -1,37 +1,38 @@
package models
package repo
import (
repo "expenses/expenses/db/repository"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
)
func mapRepoGetPaymentsRow(s repo.GetPaymentsRow) ExpensePayment {
func mapRepoGetPaymentsRow(s pgsqlc.GetPaymentsRow) mod.Payment {
payed := pgNumericToDecimal(s.ExpensesPayment.Payed)
return ExpensePayment{
return mod.Payment{
ExpPaymID: s.ExpensesPayment.ExpPaymID,
PayedAmount: payed,
User: User{
User: mod.User{
UserID: s.User.UserID,
UserName: s.User.UserName,
},
}
}
func mapRepoGetPaymentsRows(ep []repo.GetPaymentsRow) []ExpensePayment {
payments := make([]ExpensePayment, len(ep))
func mapRepoGetPaymentsRows(ep []pgsqlc.GetPaymentsRow) []mod.Payment {
payments := make([]mod.Payment, len(ep))
for k, exp := range ep {
payments[k] = mapRepoGetPaymentsRow(exp)
}
return payments
}
func mapRepoGetPaymentRow(s repo.GetExpensePaymentByUserRow) ExpensePayment {
func mapRepoGetPaymentRow(s pgsqlc.GetExpensePaymentByUserRow) mod.Payment {
payed := pgNumericToDecimal(s.ExpensesPayment.Payed)
return ExpensePayment{
return mod.Payment{
ExpPaymID: s.ExpensesPayment.ExpPaymID,
PayedAmount: payed,
User: User{
User: mod.User{
UserID: s.User.UserID,
UserName: s.User.UserName,
},
+249
View File
@@ -0,0 +1,249 @@
package repo
import (
"context"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgtype"
"github.com/jackc/pgx/v5/pgxpool"
)
type PgExpRepo struct {
DB *pgxpool.Pool
}
func NewPgExpRepo(db *pgxpool.Pool) ExpenseRepository {
return PgExpRepo{
DB: db,
}
}
func (r *PgExpRepo) withTx(ctx context.Context, fn func(q *pgsqlc.Queries) error) error {
tx, err := r.DB.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return err
}
defer tx.Rollback(ctx)
q := pgsqlc.New(tx) // bind sqlc to this tx
if err := fn(q); err != nil {
return err
}
return tx.Commit(ctx)
}
func (p *PgExpRepo) getAll(ctx context.Context, q *pgsqlc.Queries) (mod.Expenses, error) {
// We want to select all here, no timestamps
var start pgtype.Timestamp
start.Valid = false
var end pgtype.Timestamp
end.Valid = false
expenses, err := q.GetExpenses(ctx, pgsqlc.GetExpensesParams{
Startdate: start,
Enddate: end,
})
if err != nil {
return []mod.Expense{}, err
}
return mapRepoGetExpensesRows(expenses), err
}
func (p PgExpRepo) GetAll(ctx context.Context) (mod.Expenses, error) {
return p.getAll(ctx, pgsqlc.New(p.DB))
}
func (p *PgExpRepo) get(ctx context.Context, q *pgsqlc.Queries, id int32) (mod.Expense, error) {
expense, err := q.GetExpense(ctx, id)
if err != nil {
return mod.Expense{}, err
}
return mapRepoGetExpenseRow(expense), nil
}
func (p PgExpRepo) Get(ctx context.Context, id int32) (mod.Expense, error) {
return p.get(ctx, pgsqlc.New(p.DB), id)
}
func (p PgExpRepo) Update(
ctx context.Context,
exp mod.Expense) error {
return p.withTx(ctx, func(q *pgsqlc.Queries) error {
value, err := decimalToNumeric(exp.Value)
if err != nil {
return err
}
paidOff, err := boolToPgBool(exp.PaidOff)
if err != nil {
return err
}
sharesEven, err := boolToPgBool(exp.SharesEven)
if err != nil {
return err
}
expDate, err := timeToTimestamp(exp.Date)
if err != nil {
return err
}
res, err := q.UpdateExpense(ctx, pgsqlc.UpdateExpenseParams{
ExpID: exp.ExpID,
Description: exp.Description,
Value: value,
StoreID: exp.Store.StoreID,
CategoryID: exp.Category.CategoryID,
TypeID: exp.Type.TypeID,
OwnerUserID: exp.Owner.UserID,
PaidOff: paidOff,
SharesEven: sharesEven,
ExpDate: expDate,
})
if err != nil {
return err
}
for _, share := range exp.Shares {
if share.ExpShareID == -1 {
err := p.insertShare(ctx, q, exp.ExpID, share)
if err != nil {
return err
}
} else {
err := p.updateShare(ctx, q, share)
}
}
for _, paym := range exp.Payments {
if paym.ExpPaymID == -1 {
err := p.insertPayment(ctx, q, exp.ExpID, paym)
if err != nil {
return err
}
} else {
err := p.updatePayment(ctx, q, paym)
if err != nil {
return nil
}
}
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were updated")
}
return nil
})
}
func (p PgExpRepo) Insert(
ctx context.Context,
exp mod.Expense) error {
return p.withTx(ctx, func(q *pgsqlc.Queries) error {
value, err := decimalToNumeric(exp.Value)
if err != nil {
return err
}
paidOff, err := boolToPgBool(exp.PaidOff)
if err != nil {
return err
}
sharesEven, err := boolToPgBool(exp.SharesEven)
if err != nil {
return err
}
expDate, err := timeToTimestamp(exp.Date)
if err != nil {
return err
}
creationDate, err := timeToTimestamp(exp.CreationDate)
if err != nil {
return err
}
lastInsertedID, err := q.InsertExpense(ctx, pgsqlc.InsertExpenseParams{
Description: exp.Description,
Value: value,
StoreID: exp.Store.StoreID,
CategoryID: exp.Category.CategoryID,
TypeID: exp.Type.TypeID,
OwnerUserID: exp.Owner.UserID,
ExpDate: expDate,
PaidOff: paidOff,
SharesEven: sharesEven,
CreationDate: creationDate,
})
if err != nil {
return err
}
exp.ExpID = lastInsertedID
err = p.insertShares(ctx, q, exp.ExpID, exp.Shares)
if err != nil {
return err
}
err = p.insertPayments(ctx, q, exp.ExpID, exp.Payments)
if err != nil {
return err
}
return nil
})
}
func (p PgExpRepo) Delete(ctx context.Context, id int32) error {
queries := pgsqlc.New(p.DB)
res, err := queries.DeleteExpense(ctx, id)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were delete")
}
return nil
}
func (p PgExpRepo) GetExpensesRange(
ctx context.Context, start time.Time, end time.Time) (mod.Expenses, error) {
startPg, err := timeToTimestamp(start)
if err != nil {
return mod.Expenses{}, err
}
endPg, err := timeToTimestamp(end)
if err != nil {
return mod.Expenses{}, err
}
queries := pgsqlc.New(p.DB)
expenses, err := queries.GetExpenses(ctx, pgsqlc.GetExpensesParams{
Startdate: startPg,
Enddate: endPg,
})
if err != nil {
return mod.Expenses{}, err
}
return mapRepoGetExpensesRows(expenses), nil
}
@@ -1,83 +1,84 @@
package models
package repo
import (
repo "expenses/expenses/db/repository"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
)
func mapRepoGetExpenseRow(e repo.GetExpenseRow) Expense {
func mapRepoGetExpenseRow(e pgsqlc.GetExpenseRow) mod.Expense {
value := pgNumericToDecimal(e.Expense.Value)
paidOff := pgBoolToBool(e.Expense.PaidOff)
sharesEven := pgBoolToBool(e.Expense.SharesEven)
expDate := pgTimestampToTime(e.Expense.ExpDate)
creationDate := pgTimestampToTime(e.Expense.CreationDate)
return Expense{
return mod.Expense{
ExpID: e.Expense.ExpID,
Description: e.Expense.Description,
Value: value,
Store: Store{
Store: mod.Store{
StoreID: e.Store.StoreID,
StoreName: e.Store.StoreName,
},
Type: Type{
Type: mod.Type{
TypeID: e.ExpenseType.TypeID,
TypeName: e.ExpenseType.TypeName,
},
Category: Category{
Category: mod.Category{
CategoryID: e.Category.CategoryID,
CategoryName: e.Category.CategoryName,
},
Owner: User{
Owner: mod.User{
UserID: e.User.UserID,
UserName: e.User.UserName,
},
Date: expDate,
Shares: []Share{},
Payments: []ExpensePayment{},
Shares: []mod.Share{},
Payments: []mod.Payment{},
PaidOff: paidOff,
SharesEven: sharesEven,
CreationDate: creationDate,
}
}
func mapRepoGetExpenseRowMulti(e repo.GetExpensesRow) Expense {
func mapRepoGetExpenseRowMulti(e pgsqlc.GetExpensesRow) mod.Expense {
value := pgNumericToDecimal(e.Expense.Value)
paidOff := pgBoolToBool(e.Expense.PaidOff)
sharesEven := pgBoolToBool(e.Expense.SharesEven)
expDate := pgTimestampToTime(e.Expense.ExpDate)
creationDate := pgTimestampToTime(e.Expense.CreationDate)
return Expense{
return mod.Expense{
ExpID: e.Expense.ExpID,
Description: e.Expense.Description,
Value: value,
Store: Store{
Store: mod.Store{
StoreID: e.Store.StoreID,
StoreName: e.Store.StoreName,
},
Type: Type{
Type: mod.Type{
TypeID: e.ExpenseType.TypeID,
TypeName: e.ExpenseType.TypeName,
},
Category: Category{
Category: mod.Category{
CategoryID: e.Category.CategoryID,
CategoryName: e.Category.CategoryName,
},
Owner: User{
Owner: mod.User{
UserID: e.User.UserID,
UserName: e.User.UserName,
},
Date: expDate,
Shares: []Share{},
Payments: []ExpensePayment{},
Shares: []mod.Share{},
Payments: []mod.Payment{},
PaidOff: paidOff,
SharesEven: sharesEven,
CreationDate: creationDate,
}
}
func mapRepoGetExpensesRows(er []repo.GetExpensesRow) []Expense {
expenses := make([]Expense, len(er))
func mapRepoGetExpensesRows(er []pgsqlc.GetExpensesRow) []mod.Expense {
expenses := make([]mod.Expense, len(er))
for k, exp := range er {
expenses[k] = mapRepoGetExpenseRowMulti(exp)
}
+142
View File
@@ -0,0 +1,142 @@
package repo
import (
"context"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
"fmt"
)
func (p *PgExpRepo) insertShare(
ctx context.Context,
q *pgsqlc.Queries,
eId int32,
sh mod.Share) error {
share, err := decimalToNumeric(sh.Share)
if err != nil {
return err
}
calculated, err := decimalToNumeric(sh.Calculated)
if err != nil {
return err
}
res, err := q.InsertShare(ctx, pgsqlc.InsertShareParams{
ExpID: eId,
Share: share,
UserID: sh.User.UserID,
Calculated: calculated,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p PgExpRepo) InsertShare(
ctx context.Context,
eId int32,
sh mod.Share) error {
return p.insertShare(ctx, pgsqlc.New(p.DB), eId, sh)
}
func (p PgExpRepo) InsertShares(
ctx context.Context,
eId int32,
sh mod.Shares) error {
return p.insertShares(ctx, pgsqlc.New(p.DB), eId, sh)
}
func (p *PgExpRepo) insertShares(
ctx context.Context,
q *pgsqlc.Queries,
eId int32,
sh []mod.Share) error {
for k := range sh {
err := p.insertShare(ctx, q, eId, sh[k])
if err != nil {
return err
}
}
return nil
}
func (p PgExpRepo) updateShare(
ctx context.Context, q *pgsqlc.Queries, sh mod.Share) error {
share, err := decimalToNumeric(sh.Share)
if err != nil {
return err
}
calculated, err := decimalToNumeric(sh.Calculated)
if err != nil {
return err
}
res, err := q.UpdateShare(ctx, pgsqlc.UpdateShareParams{
ExpShareID: sh.ExpShareID,
Share: share,
UserID: sh.User.UserID,
Calculated: calculated,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were updated")
}
return nil
}
func (p PgExpRepo) UpdateShare(ctx context.Context, sh mod.Share) error {
return p.updateShare(ctx, pgsqlc.New(p.DB), sh)
}
func (p *PgExpRepo) deleteShare(
ctx context.Context, q *pgsqlc.Queries, sh mod.Share) error {
res, err := q.DeleteShare(ctx, sh.ExpShareID)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were deleted")
}
return nil
}
func (p PgExpRepo) DeleteShare(ctx context.Context, sh mod.Share) error {
return p.deleteShare(ctx, pgsqlc.New(p.DB), sh)
}
func (p *PgExpRepo) getShares(
ctx context.Context, q *pgsqlc.Queries, eId int32) (mod.Shares, error) {
shares, err := q.GetShares(ctx, eId)
if err != nil {
return mod.Shares{}, err
}
return mapRepoGetSharesRows(shares), nil
}
func (p PgExpRepo) GetShares(ctx context.Context, eId int32) (mod.Shares, error) {
return p.getShares(ctx, pgsqlc.New(p.DB), eId)
}
@@ -1,17 +1,18 @@
package models
package repo
import (
repo "expenses/expenses/db/repository"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
)
func mapRepoGetSharesRow(s repo.GetSharesRow) Share {
func mapRepoGetSharesRow(s pgsqlc.GetSharesRow) mod.Share {
share := pgNumericToDecimal(s.ExpensesShare.Share)
calculated := pgNumericToDecimal(s.ExpensesShare.Calculated)
return Share{
return mod.Share{
ExpShareID: s.ExpensesShare.ExpShareID,
Share: share,
User: User{
User: mod.User{
UserID: s.User.UserID,
UserName: s.User.UserName,
},
@@ -19,8 +20,8 @@ func mapRepoGetSharesRow(s repo.GetSharesRow) Share {
}
}
func mapRepoGetSharesRows(es []repo.GetSharesRow) []Share {
shares := make([]Share, len(es))
func mapRepoGetSharesRows(es []pgsqlc.GetSharesRow) mod.Shares {
shares := make(mod.Shares, len(es))
for k, exp := range es {
shares[k] = mapRepoGetSharesRow(exp)
}
+83
View File
@@ -0,0 +1,83 @@
package repo
import (
"context"
experr "expenses/expenses/errors"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
"fmt"
"github.com/jackc/pgx/v5/pgxpool"
)
type PgStoreRepo struct {
DB *pgxpool.Pool
}
func NewPgStoreRepo(db *pgxpool.Pool) StoreRepository {
return PgStoreRepo{
DB: db,
}
}
func (p PgStoreRepo) Get(ctx context.Context, id int32) (mod.Store, error) {
queries := pgsqlc.New(p.DB)
store, err := queries.GetStore(ctx, id)
if err != nil {
return mod.Store{}, err
}
return mapRepoStore(store), nil
}
func (p PgStoreRepo) GetAll(ctx context.Context) (mod.Stores, error) {
queries := pgsqlc.New(p.DB)
storeList, err := queries.GetStores(ctx)
if err != nil {
return mod.Stores{}, err
}
return mapRepoStores(storeList), nil
}
func (p PgStoreRepo) Update(ctx context.Context, s mod.Store) error {
queries := pgsqlc.New(p.DB)
_, err := queries.UpdateStore(ctx, pgsqlc.UpdateStoreParams{
StoreID: s.StoreID,
StoreName: s.StoreName,
})
if err != nil {
return err
}
return nil
}
func (p PgStoreRepo) Insert(ctx context.Context, s mod.Store) error {
queries := pgsqlc.New(p.DB)
res, err := queries.InsertStore(ctx, s.StoreName)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p PgStoreRepo) Delete(ctx context.Context, id int32) error {
queries := pgsqlc.New(p.DB)
res, err := queries.DeleteStore(ctx, id)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
+21
View File
@@ -0,0 +1,21 @@
package repo
import (
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
)
func mapRepoStore(rs pgsqlc.Store) mod.Store {
return mod.Store{
StoreID: rs.StoreID,
StoreName: rs.StoreName,
}
}
func mapRepoStores(rs []pgsqlc.Store) mod.Stores {
stores := make(mod.Stores, len(rs))
for k, store := range rs {
stores[k] = mapRepoStore(store)
}
return stores
}
+91
View File
@@ -0,0 +1,91 @@
package repo
import (
"context"
experr "expenses/expenses/errors"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
"fmt"
"github.com/jackc/pgx/v5/pgxpool"
)
type PgTypeRepo struct {
DB *pgxpool.Pool
}
func NewPgTypeRepo(db *pgxpool.Pool) TypeRepository {
return PgTypeRepo{
DB: db,
}
}
func (p PgTypeRepo) Get(ctx context.Context, id int32) (mod.Type, error) {
queries := pgsqlc.New(p.DB)
typ, err := queries.GetType(ctx, id)
if err != nil {
return mod.Type{}, err
}
return mapRepoType(typ), nil
}
func (p PgTypeRepo) GetAll(ctx context.Context) (mod.Types, error) {
queries := pgsqlc.New(p.DB)
typeList, err := queries.GetTypes(ctx)
if err != nil {
return mod.Types{}, err
}
return mapRepoTypes(typeList), nil
}
func (p PgTypeRepo) Update(ctx context.Context, typ mod.Type) error {
queries := pgsqlc.New(p.DB)
res, err := queries.UpdateType(ctx, pgsqlc.UpdateTypeParams{
TypeID: typ.TypeID,
TypeName: typ.TypeName,
})
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
func (p PgTypeRepo) Insert(ctx context.Context, typ mod.Type) error {
queries := pgsqlc.New(p.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 := res.RowsAffected()
if rowsAffected == 0 {
return fmt.Errorf("no rows were created")
}
return nil
}
func (p PgTypeRepo) Delete(ctx context.Context, id int32) error {
queries := pgsqlc.New(p.DB)
res, err := queries.DeleteType(ctx, id)
if err != nil {
return err
}
rowsAffected := res.RowsAffected()
if rowsAffected == 0 {
return experr.ErrNotFound
}
return nil
}
+21
View File
@@ -0,0 +1,21 @@
package repo
import (
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
)
func mapRepoType(rt pgsqlc.ExpenseType) mod.Type {
return mod.Type{
TypeID: rt.TypeID,
TypeName: rt.TypeName,
}
}
func mapRepoTypes(rt []pgsqlc.ExpenseType) mod.Types {
types := make(mod.Types, len(rt))
for k, typ := range rt {
types[k] = mapRepoType(typ)
}
return types
}
+28
View File
@@ -0,0 +1,28 @@
package repo
import (
"context"
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
"github.com/jackc/pgx/v5/pgxpool"
)
type PgUserRepo struct {
DB *pgxpool.Pool
}
func NewPgUserRepo(db *pgxpool.Pool) UserRepository {
return PgUserRepo{
DB: db,
}
}
func (p PgUserRepo) GetAll(ctx context.Context) (mod.Users, error) {
queries := pgsqlc.New(p.DB)
userList, err := queries.GetUsers(ctx)
if err != nil {
return mod.Users{}, err
}
return mapRepoUsers(userList), nil
}
+21
View File
@@ -0,0 +1,21 @@
package repo
import (
mod "expenses/expenses/models"
"expenses/expenses/repo/pgdb/pgsqlc"
)
func mapRepoUser(ru pgsqlc.User) mod.User {
return mod.User{
UserID: ru.UserID,
UserName: ru.UserName,
}
}
func mapRepoUsers(ru []pgsqlc.User) mod.Users {
users := make(mod.Users, len(ru))
for k, u := range ru {
users[k] = mapRepoUser(u)
}
return users
}
@@ -3,7 +3,7 @@
// sqlc v1.29.0
// source: categories.sql
package repository
package pgsqlc
import (
"context"
@@ -2,7 +2,7 @@
// versions:
// sqlc v1.29.0
package repository
package pgsqlc
import (
"context"
@@ -3,7 +3,7 @@
// sqlc v1.29.0
// source: expenses.sql
package repository
package pgsqlc
import (
"context"
@@ -2,7 +2,7 @@
// versions:
// sqlc v1.29.0
package repository
package pgsqlc
import (
"github.com/jackc/pgx/v5/pgtype"
@@ -3,7 +3,7 @@
// sqlc v1.29.0
// source: payments.sql
package repository
package pgsqlc
import (
"context"
@@ -3,7 +3,7 @@
// sqlc v1.29.0
// source: shares.sql
package repository
package pgsqlc
import (
"context"
@@ -3,7 +3,7 @@
// sqlc v1.29.0
// source: stores.sql
package repository
package pgsqlc
import (
"context"
@@ -3,7 +3,7 @@
// sqlc v1.29.0
// source: types.sql
package repository
package pgsqlc
import (
"context"
@@ -3,7 +3,7 @@
// sqlc v1.29.0
// source: users.sql
package repository
package pgsqlc
import (
"context"
@@ -6,8 +6,8 @@ sql:
gen:
go:
sql_package: "pgx/v5"
package: "repository"
out: "repository"
package: "pgsqlc"
out: "pgsqlc"
rename:
expenseTypes: "ExpenseTypes"
expenseShares: "ExpenseShares"
+14
View File
@@ -0,0 +1,14 @@
package repo
import (
"context"
mod "expenses/expenses/models"
)
type StoreRepository interface {
Get(ctx context.Context, id int32) (mod.Store, error)
GetAll(ctx context.Context) (mod.Stores, error)
Update(ctx context.Context, cat mod.Store) error
Insert(ctx context.Context, cat mod.Store) error
Delete(ctx context.Context, id int32) error
}
+14
View File
@@ -0,0 +1,14 @@
package repo
import (
"context"
mod "expenses/expenses/models"
)
type TypeRepository interface {
Get(ctx context.Context, id int32) (mod.Type, error)
GetAll(ctx context.Context) (mod.Types, error)
Update(ctx context.Context, typ mod.Type) error
Insert(ctx context.Context, typ mod.Type) error
Delete(ctx context.Context, id int32) error
}
+10
View File
@@ -0,0 +1,10 @@
package repo
import (
"context"
mod "expenses/expenses/models"
)
type UserRepository interface {
GetAll(ctx context.Context) (mod.Users, error)
}
+2
View File
@@ -30,6 +30,7 @@ require (
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
github.com/jackc/puddle/v2 v2.2.1 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.2.7 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
@@ -45,6 +46,7 @@ require (
golang.org/x/arch v0.8.0 // indirect
golang.org/x/crypto v0.36.0 // indirect
golang.org/x/net v0.38.0 // indirect
golang.org/x/sync v0.12.0 // indirect
golang.org/x/sys v0.31.0 // indirect
golang.org/x/text v0.23.0 // indirect
google.golang.org/protobuf v1.34.2 // indirect
+1 -1
View File
@@ -17,7 +17,7 @@ func processFormShares(c *gin.Context) ([]mod.Share, error) {
return expenses.ParseFormShares(userIDS, shares, shareIDs)
}
func processFormPayments(c *gin.Context) ([]mod.ExpensePayment, error) {
func processFormPayments(c *gin.Context) ([]mod.Payment, error) {
userIDs := c.PostFormArray("payments-user-ids[]")
paymentIDs := c.PostFormArray("payments-ids[]")
values := c.PostFormArray("payments-payment[]")