Completed db rewrite

core/expenses.go

@@ -1,11 +1,12 @@
 package core
 
 import (
+	"database/sql"
 	"encoding/json"
 	"errors"
+	"fmt"
 
 	"github.com/shopspring/decimal"
-	"gorm.io/gorm"
 )
 
 type DebtType int
@@ -44,27 +45,42 @@ type DebtSpec struct {
 	DebtType DebtType        `json:"debt_type"`
 }
 
-func CreateExpense(db *gorm.DB, plan Plan, payer Member, amount decimal.Decimal) (*Expense, error) {
+func ExpenseCreate(db *sql.DB, plan Plan, payer Member, amount decimal.Decimal) (*Expense, error) {
 	expense := new(Expense)
-	expense.Plan = plan
-	expense.Payer = payer
+	expense.PlanId = plan.Id
+	expense.PayerId = payer.Id
 	expense.Amount = amount
-	err := db.Create(&expense).Error
-	if err != nil {
+	row := db.QueryRow(
+		"INSERT INTO expenses(plan_id,payer_id,amount) VALUES (?,?,?) RETURNING id",
+		expense.PlanId,
+		expense.PayerId,
+		expense.Amount,
+	)
+	if err := row.Scan(&expense.Id); err != nil {
 		return nil, err
 	}
 	return expense, nil
 }
 
-func (e *Expense) GetDebt(db *gorm.DB) ([]Debt, error) {
+func (e *Expense) GetDebt(db *sql.DB) ([]Debt, error) {
 	var debts []Debt
-	if err := db.Model(e).Association("Debts").Find(&debts); err != nil {
-		return []Debt{}, err
+	rows, err := db.Query("SELECT expense_id,debtor_id,amount,paid FROM debts WHERE expense_id=?")
+	if err != nil {
+		return debts, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var d Debt
+		err = rows.Scan(&d.ExpenseId, &d.DebtorId, &d.Amount, &d.Paid)
+		if err != nil {
+			return []Debt{}, err
+		}
+		debts = append(debts, d)
 	}
 	return debts, nil
 }
 
-func (e *Expense) SetDebt(db *gorm.DB, debtSpec []DebtSpec) error {
+func (e *Expense) SetDebt(db *sql.DB, debtSpec []DebtSpec) error {
 	abs_paid := decimal.Decimal{}
 	debts := make([]Debt, 0)
 	var prop_payers int64 = 0
@@ -75,8 +91,8 @@ func (e *Expense) SetDebt(db *gorm.DB, debtSpec []DebtSpec) error {
 			debts = append(debts, Debt{
 				Amount:    debt.Amount,
 				Paid:      decimal.Decimal{},
-				ExpenseID: e.ID,
-				DebtorID:  debt.Member.ID,
+				ExpenseId: e.Id,
+				DebtorId:  debt.Member.Id,
 			})
 			abs_paid.Add(debt.Amount)
 		}
@@ -86,52 +102,95 @@ func (e *Expense) SetDebt(db *gorm.DB, debtSpec []DebtSpec) error {
 	}
 
 	prop_debt := e.Amount.Sub(abs_paid).DivRound(decimal.NewFromInt(prop_payers), 2)
-	return db.Transaction(func(tx *gorm.DB) error {
-		for _, debt := range debts {
-			if err := db.Create(&debt).Error; err != nil {
-				return err
-			}
-		}
-
-		for _, debt := range debtSpec {
-			if debt.DebtType != ProportionalDebt {
-				continue
-			}
-			if err := db.Create(&Debt{
-				Amount:    prop_debt,
-				Paid:      decimal.Decimal{},
-				ExpenseID: e.ID,
-				DebtorID:  debt.Member.ID,
-			}).Error; err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}
-
-func (e *Expense) Delete(db *gorm.DB) error {
-	return db.Transaction(func(tx *gorm.DB) error {
-		if err := db.Model(e).Association("Debts").Delete(&[]Debt{}); err != nil {
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+	for _, debt := range debts {
+		if err := debt.Create(tx); err != nil {
 			return err
 		}
-		return db.Delete(e, e).Error
-	})
+	}
+
+	for _, debt := range debtSpec {
+		if debt.DebtType != ProportionalDebt {
+			continue
+		}
+		debtObj := Debt{
+			Amount:    prop_debt,
+			Paid:      decimal.Decimal{},
+			ExpenseId: e.Id,
+			DebtorId:  debt.Member.Id,
+		}
+		if err := debtObj.Create(tx); err != nil {
+			return err
+		}
+	}
+	return tx.Commit()
 }
 
-func ListExpenses(db *gorm.DB, plan Plan) ([]Expense, error) {
+func (e *Expense) Delete(db *sql.DB) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+	_, err = tx.Exec("DELETE FROM debts WHERE expense_id=?", e.Id)
+	if err != nil {
+		return fmt.Errorf("Unable to delete debts for expense %d: %w", e.Id, err)
+	}
+	_, err = tx.Exec("DELETE FROM expenses WHERE id=?", e.Id)
+	if err != nil {
+		return fmt.Errorf("Unable to delete expense %d: %w", e.Id, err)
+	}
+	err = tx.Commit()
+	if err != nil {
+		return fmt.Errorf(
+			"Unable to commit transaction when deleting expense %d: %w",
+			e.Id,
+			err,
+		)
+	}
+	return nil
+}
+
+func ExpensesList(db *sql.DB, plan Plan) ([]Expense, error) {
 	var expenses []Expense
-	if err := db.Where("plan_id = ?", plan.ID).Find(&expenses).Error; err != nil {
-		return []Expense{}, err
+	rows, err := db.Query(
+		"SELECT id,plan_id,payer_id,amount FROM expenses WHERE plan_id=$1",
+		plan.Id,
+	)
+	if err != nil {
+		return expenses, fmt.Errorf(
+			"Unable to query for expenses in plan %d: %w",
+			plan.Id,
+			err,
+		)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		e := Expense{}
+		err = rows.Scan(&e.Id, e.PlanId, e.PayerId, e.Amount)
+		if err != nil {
+			return expenses, fmt.Errorf(
+				"Unable to scan expense during list: %w",
+				err,
+			)
+		}
+		expenses = append(expenses, e)
 	}
 	return expenses, nil
 }
 
-func GetExpense(db *gorm.DB, expense_id uint) (*Expense, error) {
-	expense := new(Expense)
-	expense.ID = expense_id
-	if err := db.Take(expense).Error; err != nil {
-		return nil, err
+func ExpensesGet(db *sql.DB, expense_id uint) (*Expense, error) {
+	e := Expense{}
+	row := db.QueryRow(
+		"SELECT id,plan_id,payer_id,amount FROM expenses WHERE id=?",
+		expense_id,
+	)
+	if err := row.Scan(&e.Id, &e.PlanId, &e.PayerId, &e.Amount); err != nil {
+		return nil, fmt.Errorf("Unable to get expense %d: %w", expense_id, err)
 	}
-	return expense, nil
+	return &e, nil
 }