137 lines
3 KiB
Go
137 lines
3 KiB
Go
package core
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"github.com/shopspring/decimal"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type DebtType int
|
|
|
|
const (
|
|
ProportionalDebt DebtType = iota
|
|
AbsoluteDebt = iota
|
|
)
|
|
|
|
func (dt DebtType) String() string {
|
|
return [...]string{"proportional", "absolute"}[dt]
|
|
}
|
|
|
|
func (dt DebtType) MarshalJSON() ([]byte, error) {
|
|
return json.Marshal(dt.String())
|
|
}
|
|
|
|
func (dt *DebtType) UnmarshalJSON(data []byte) error {
|
|
var s string
|
|
if err := json.Unmarshal(data, &s); err != nil {
|
|
return nil
|
|
}
|
|
if s == "proportional" {
|
|
*dt = ProportionalDebt
|
|
} else if s == "absolute" {
|
|
*dt = AbsoluteDebt
|
|
} else {
|
|
return errors.New("Invalid value for debt type")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type DebtSpec struct {
|
|
Member Member `json:"member"`
|
|
Amount decimal.Decimal `json:"amount"`
|
|
DebtType DebtType `json:"debt_type"`
|
|
}
|
|
|
|
func CreateExpense(db *gorm.DB, plan Plan, payer Member, amount decimal.Decimal) (*Expense, error) {
|
|
expense := new(Expense)
|
|
expense.Plan = plan
|
|
expense.Payer = payer
|
|
expense.Amount = amount
|
|
err := db.Create(&expense).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return expense, nil
|
|
}
|
|
|
|
func (e *Expense) GetDebt(db *gorm.DB) ([]Debt, error) {
|
|
var debts []Debt
|
|
if err := db.Model(e).Association("Debts").Find(&debts); err != nil {
|
|
return []Debt{}, err
|
|
}
|
|
return debts, nil
|
|
}
|
|
|
|
func (e *Expense) SetDebt(db *gorm.DB, debtSpec []DebtSpec) error {
|
|
abs_paid := decimal.Decimal{}
|
|
debts := make([]Debt, 0)
|
|
var prop_payers int64 = 0
|
|
for _, debt := range debtSpec {
|
|
if debt.DebtType == ProportionalDebt {
|
|
prop_payers += 1
|
|
} else {
|
|
debts = append(debts, Debt{
|
|
Amount: debt.Amount,
|
|
Paid: decimal.Decimal{},
|
|
ExpenseID: e.ID,
|
|
DebtorID: debt.Member.ID,
|
|
})
|
|
abs_paid.Add(debt.Amount)
|
|
}
|
|
}
|
|
if abs_paid.Cmp(e.Amount) > 0 {
|
|
return errors.New("Absolute pay amount is larger than debt")
|
|
}
|
|
|
|
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 {
|
|
return err
|
|
}
|
|
return db.Delete(e, e).Error
|
|
})
|
|
}
|
|
|
|
func ListExpenses(db *gorm.DB, plan Plan) ([]Expense, error) {
|
|
var expenses []Expense
|
|
if err := db.Where("plan_id = ?", plan.ID).Find(&expenses).Error; err != nil {
|
|
return []Expense{}, err
|
|
}
|
|
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
|
|
}
|
|
return expense, nil
|
|
}
|