Added expenses to plan

core/expenses.go

@@ -0,0 +1,137 @@
+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
+}

core/models.go

@@ -1,5 +1,7 @@
 package core
 
+import "github.com/shopspring/decimal"
+
 type User struct {
 	Username   string   `gorm:"primaryKey" json:"username"`
 	Password   string   `json:"password"`
@@ -12,9 +14,8 @@ type Member struct {
 	ID     uint   `gorm:"primaryKey;autoIncrement:true" json:"-"`
 	PlanID uint   `json:"-"`
 	Plan   Plan   `json:"-"`
-	Type   string `gorm:"check:type in ('user','non-user')" json:"type"`
-	Name   string `gorm:"check:type=='member' OR name IS NOT NULL" json:"name"`
-	UserID string `json:"username"`
+	Name   string `gorm:"check:user_id IS NOT NULL OR name IS NOT NULL" json:"name,omitempty"`
+	UserID string `json:"username,omitempty"`
 	User   User   `gorm:"foreignKey:UserID" json:"-"`
 }
 
@@ -30,6 +31,25 @@ type Plan struct {
 	Polls       []Poll   `gorm:"foreignKey:PlanID;references:ID" json:"-"`
 }
 
+type Expense struct {
+	ID      uint            `gorm:"primaryKey;autoIncrement:true" json:"id"`
+	PlanID  uint            `json:"-"`
+	Plan    Plan            `json:"-"`
+	PayerID uint            `json:"-"`
+	Payer   Member          `gorm:"foreignKey:PayerID" json:"-"`
+	Amount  decimal.Decimal `json:"amount"`
+	Debts   []Debt          `gorm:"foreignKey:ExpenseID" json:"debts,omitempty"`
+}
+
+type Debt struct {
+	ExpenseID uint    `gorm:"primaryKey" json:"-"`
+	Expense   Expense `gorm:"foreignKey:ExpenseID"`
+	DebtorID  uint    `gorm:"primaryKey" json:"-"`
+	Debtor    Member  `gorm:"foreignKey:DebtorID"`
+	Amount    decimal.Decimal
+	Paid      decimal.Decimal
+}
+
 // CREATE TABLE polls(id INTEGER PRIMARY KEY AUTOINCREMENT, plan INTEGER, name STRING, options JSON, FOREIGN KEY plan REFERENCES plans(id))
 type Poll struct {
 	ID      uint   `gorm:"primaryKey;autoIncrement:true" json:"id"`

core/plans.go

@@ -21,7 +21,6 @@ func CreatePlan(db *gorm.DB, user *User, name string) (*Plan, error) {
 		Members: []Member{
 			{
 				UserID: user.Username,
-				Type:   "user",
 			},
 		},
 		JoinCode: base64.URLEncoding.EncodeToString(join_code),
@@ -95,10 +94,7 @@ func (p *Plan) AddMember(orm *gorm.DB, new_member *Member) error {
 		return errors.New("Member is nil")
 	}
 	new_member.PlanID = p.ID
-	if new_member.Type == "non-user" {
-		if new_member.Name == "" {
-			return errors.New("name required for non user")
-		}
+	if new_member.Name != "" {
 		found, err := p.HasNonUser(orm, new_member.Name)
 		if err != nil {
 			return nil
@@ -107,7 +103,7 @@ func (p *Plan) AddMember(orm *gorm.DB, new_member *Member) error {
 			return errors.New("Non user name taken")
 		}
 		return orm.Create(&new_member).Error
-	} else if new_member.Type == "user" {
+	} else if new_member.UserID != "" {
 		user, err := GetUser(orm, new_member.UserID)
 		if err != nil {
 			return err
@@ -123,6 +119,6 @@ func (p *Plan) AddMember(orm *gorm.DB, new_member *Member) error {
 
 		return orm.Create(&new_member).Error
 	} else {
-		return errors.New("Invalid type for user")
+		return errors.New("Member object requires one of Name or UserID to be filled")
 	}
 }