forcen/Planner
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: forcen:cf4b8e01194ffa70be9b43e89daa2cb16a414edb
Branches Tags
forcen:main
..
compare: forcen:8ea8574f3fa3a9dd8976c1d5d374b48b96f650b6
Branches Tags
forcen:main

No commits in common. "cf4b8e01194ffa70be9b43e89daa2cb16a414edb" and "8ea8574f3fa3a9dd8976c1d5d374b48b96f650b6" have entirely different histories.
cf4b8e0119 ... 8ea8574f3f

19 changed files with 211 additions and 804 deletions
Download patch file Download diff file Expand all files Collapse all files

7
apis/base.go
View file

@ -1,16 +1,16 @@
package apis package apis
import ( import (
"database/sql"
"errors" "errors"
"net/http" "net/http"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"gorm.io/gorm"
) )
var db *sql.DB var db *gorm.DB
func BindAPIs(r *gin.Engine, cfg_db *sql.DB) error { func BindAPIs(r *gin.Engine, cfg_db *gorm.DB) error {
if cfg_db == nil { if cfg_db == nil {
return errors.New("Database is null") return errors.New("Database is null")
} }
@ -23,6 +23,5 @@ func BindAPIs(r *gin.Engine, cfg_db *sql.DB) error {
bindPlanAPIs(r) bindPlanAPIs(r)
bindPollAPIs(r) bindPollAPIs(r)
bindUserAPIs(r) bindUserAPIs(r)
bindExpensesAPIs(r)
return nil return nil
} }

230
apis/expenses.go
View file

@ -1,230 +0,0 @@
package apis
import (
"net/http"
"planner/core"
"slices"
"strconv"
"github.com/gin-gonic/gin"
"github.com/shopspring/decimal"
)
type ExpenseDef struct {
Payer string `json:"payer"`
Type string `json:"type"`
Amount decimal.Decimal `json:"amount"`
}
func createExpense(c *gin.Context) {
u := extractUser(db, c)
if u == nil {
c.Status(http.StatusUnauthorized)
return
}
plan_id, err := strconv.ParseInt(c.Param("id"), 10, 32)
if err != nil || plan_id < 0 {
c.Status(http.StatusBadRequest)
return
}
plan, err := u.GetPlan(db, uint(plan_id))
if err != nil {
c.Status(http.StatusBadRequest)
return
}
members, err := plan.GetAllUsers(db)
if err != nil {
c.Status(http.StatusInternalServerError)
return
}
var exp ExpenseDef
if err := c.ShouldBind(&exp); err != nil {
c.Status(http.StatusBadRequest)
return
}
var compare func(m core.Member) bool
if exp.Type == "user" {
compare = func(m core.Member) bool {
return *m.UserId == exp.Payer
}
} else if exp.Type == "non-user" {
compare = func(m core.Member) bool {
return m.Name == exp.Payer
}
} else {
c.String(http.StatusBadRequest, "Invalid member type")
return
}
idx := slices.IndexFunc(members, compare)
if idx != -1 {
expense, err := core.ExpenseCreate(db, *plan, members[idx], exp.Amount)
if err != nil {
c.Status(http.StatusInternalServerError)
return
}
c.JSON(http.StatusOK, expense)
return
}
c.String(http.StatusBadRequest, "Unable to found member")
}
func listExpenses(c *gin.Context) {
u := extractUser(db, c)
if u == nil {
c.Status(http.StatusUnauthorized)
return
}
plan_id, err := strconv.ParseInt(c.Param("id"), 10, 32)
if err != nil || plan_id < 0 {
c.Status(http.StatusBadRequest)
return
}
plan, err := u.GetPlan(db, uint(plan_id))
if err != nil {
c.Status(http.StatusBadRequest)
return
}
expenses, err := core.ExpensesList(db, *plan)
if err != nil {
c.Status(http.StatusInternalServerError)
return
}
c.JSON(http.StatusOK, expenses)
}
func getExpense(c *gin.Context) {
u := extractUser(db, c)
if u == nil {
c.Status(http.StatusUnauthorized)
return
}
expense_id, err := strconv.ParseInt(c.Param("id"), 10, 32)
if err != nil || expense_id < 0 {
c.Status(http.StatusBadRequest)
return
}
expense, err := core.ExpensesGet(db, uint(expense_id))
if err != nil {
c.Status(http.StatusBadRequest)
return
}
_, err = u.GetPlan(db, expense.PlanId)
if err != nil {
c.Status(http.StatusBadRequest)
return
}
c.JSON(http.StatusOK, expense)
}
func deleteExpense(c *gin.Context) {
u := extractUser(db, c)
if u == nil {
c.Status(http.StatusUnauthorized)
return
}
expense_id, err := strconv.ParseInt(c.Param("id"), 10, 32)
if err != nil || expense_id < 0 {
c.Status(http.StatusBadRequest)
return
}
expense, err := core.ExpensesGet(db, uint(expense_id))
if err != nil {
c.Status(http.StatusBadRequest)
return
}
_, err = u.GetPlan(db, expense.PlanId)
if err != nil {
c.Status(http.StatusBadRequest)
return
}
if err = expense.Delete(db); err != nil {
c.Status(http.StatusInternalServerError)
return
}
c.Status(http.StatusOK)
}
func getExpenseDebts(c *gin.Context) {
u := extractUser(db, c)
if u == nil {
c.Status(http.StatusUnauthorized)
return
}
expense_id, err := strconv.ParseInt(c.Param("id"), 10, 32)
if err != nil || expense_id < 0 {
c.Status(http.StatusBadRequest)
return
}
expense, err := core.ExpensesGet(db, uint(expense_id))
if err != nil {
c.Status(http.StatusBadRequest)
return
}
_, err = u.GetPlan(db, expense.PlanId)
if err != nil {
c.Status(http.StatusBadRequest)
return
}
debts, err := expense.GetDebt(db)
if err != nil {
c.Status(http.StatusInternalServerError)
return
}
c.JSON(http.StatusOK, debts)
}
func setExpenseDebts(c *gin.Context) {
u := extractUser(db, c)
if u == nil {
c.Status(http.StatusUnauthorized)
return
}
expense_id, err := strconv.ParseInt(c.Param("id"), 10, 32)
if err != nil || expense_id < 0 {
c.Status(http.StatusBadRequest)
return
}
expense, err := core.ExpensesGet(db, uint(expense_id))
if err != nil {
c.Status(http.StatusBadRequest)
return
}
_, err = u.GetPlan(db, expense.PlanId)
if err != nil {
c.Status(http.StatusBadRequest)
return
}
var debtSpec []core.DebtSpec
if err := c.ShouldBind(&debtSpec); err != nil {
c.Status(http.StatusBadRequest)
return
}
//expense.SetDebt(db, debtSpec)
c.JSON(http.StatusOK, debtSpec)
}
func bindExpensesAPIs(r *gin.Engine) {
r.POST("/plans/:id/expenses", createExpense)
r.GET("/plans/:id/expenses", listExpenses)
r.GET("/expenses/:id", getExpense)
r.DELETE("/expenses/:id", deleteExpense)
r.GET("/expenses/:id/debts", getExpenseDebts)
r.POST("/expenses/:id/debts", setExpenseDebts)
}

14
apis/extract.go
View file

@ -1,22 +1,24 @@
package apis package apis
import ( import (
"database/sql" "github.com/gin-gonic/gin"
"gorm.io/gorm"
"net/http" "net/http"
"planner/core" "planner/core"
"github.com/gin-gonic/gin"
) )
func extractUser(orm *sql.DB, c *gin.Context) *core.User { func extractUser(orm *gorm.DB, c *gin.Context) *core.User {
username, _, ok := c.Request.BasicAuth() username, _, ok := c.Request.BasicAuth()
if !ok { if !ok {
c.Status(http.StatusUnauthorized) c.Status(http.StatusUnauthorized)
return nil return nil
} }
u := core.User{
Username: username,
}
u, err := core.UserGet(db, username) result := orm.Take(&u)
if err != nil { if result.Error != nil {
c.String(http.StatusNotFound, "Unable to find user "+username) c.String(http.StatusNotFound, "Unable to find user "+username)
return nil return nil
} }

20
apis/plans.go
View file

@ -8,7 +8,6 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"planner/core"
. "planner/core" . "planner/core"
) )
@ -23,7 +22,7 @@ func createPlan(c *gin.Context) {
} }
c.Bind(&plan_req) c.Bind(&plan_req)
_, err := PlanCreate(db, u, plan_req.Name) _, err := CreatePlan(db, u, plan_req.Name)
if err != nil { if err != nil {
c.JSON(http.StatusInternalServerError, err) c.JSON(http.StatusInternalServerError, err)
@ -120,7 +119,7 @@ func addPlanMember(c *gin.Context) {
return return
} }
err = plan.AddMember(db, &Member{Name: new_member.Name}) err = plan.AddMember(db, &Member{Name: new_member.Name, Type: "non-user"})
if err == nil { if err == nil {
c.JSON(http.StatusOK, new_member) c.JSON(http.StatusOK, new_member)
@ -145,7 +144,7 @@ func joinPlan(c *gin.Context) {
c.Status(http.StatusBadRequest) c.Status(http.StatusBadRequest)
return return
} }
plan, err := PlanGet(db, uint(plan_id)) plan, err := GetPlan(db, uint(plan_id))
if err != nil || plan == nil { if err != nil || plan == nil {
c.Status(http.StatusInternalServerError) c.Status(http.StatusInternalServerError)
return return
@ -172,7 +171,7 @@ func joinPlan(c *gin.Context) {
c.String(http.StatusConflict, "User already a member") c.String(http.StatusConflict, "User already a member")
return return
} }
plan.AddMember(db, &Member{UserId: &user.Username}) plan.AddMember(db, &Member{Type: "user", UserID: user.Username})
c.Status(http.StatusOK) c.Status(http.StatusOK)
} }
@ -213,10 +212,10 @@ func createPlanPoll(c *gin.Context) {
} }
poll := Poll{ poll := Poll{
PlanId: plan.Id, PlanID: plan.ID,
Options: poll_opts.Options, Options: poll_opts.Options,
} }
poll.Create(db) db.Create(&poll)
c.JSON(http.StatusCreated, poll) c.JSON(http.StatusCreated, poll)
} }
@ -237,11 +236,8 @@ func listPlanPolls(c *gin.Context) {
return return
} }
polls, err := core.PollsList(db, int(params.Id)) var polls []Poll
if err != nil { db.Where("plan_id = ?", params.Id).Find(&polls)
c.String(http.StatusInternalServerError, err.Error())
return
}
c.JSON(http.StatusOK, polls) c.JSON(http.StatusOK, polls)
} }

27
apis/polls.go
View file

@ -25,7 +25,7 @@ func getPoll(c *gin.Context) {
} }
fmt.Println(params) fmt.Println(params)
poll, _ := core.PollGet(db, *user, params.PollId) poll, _ := core.GetPoll(db, *user, params.PollId)
c.JSON(http.StatusOK, poll) c.JSON(http.StatusOK, poll)
} }
@ -45,12 +45,9 @@ func getPollVotes(c *gin.Context) {
return return
} }
votes, err := core.VotesList(db, int(params.PollId)) var votes []core.Vote
if err != nil { db.Where("poll_id = ?", params.PollId).Find(&votes)
c.String(http.StatusInternalServerError, err.Error()) c.JSON(http.StatusOK, &votes)
return
}
c.JSON(http.StatusOK, votes)
} }
func pollVote(c *gin.Context) { func pollVote(c *gin.Context) {
@ -69,7 +66,7 @@ func pollVote(c *gin.Context) {
return return
} }
poll, err := core.PollGet(db, *user, path_params.PollId) poll, err := core.GetPoll(db, *user, path_params.PollId)
if err != nil { if err != nil {
c.String(http.StatusInternalServerError, err.Error()) c.String(http.StatusInternalServerError, err.Error())
return return
@ -80,19 +77,7 @@ func pollVote(c *gin.Context) {
} }
c.Bind(&vote_params) c.Bind(&vote_params)
plan, err := core.PlanGet(db, poll.PlanId) if err := poll.SetVote(db, *user, vote_params.Vote); err != nil {
if err != nil {
c.String(http.StatusInternalServerError, "Unable to find plan: "+err.Error())
return
}
member, err := user.GetMemberFromPlan(db, *plan)
if err != nil {
c.String(http.StatusInternalServerError, "Unable to find member: "+err.Error())
return
}
if err := poll.SetVote(db, *member, vote_params.Vote); err != nil {
c.String(http.StatusBadRequest, err.Error()) c.String(http.StatusBadRequest, err.Error())
} }

27
apis/users.go
View file

@ -6,7 +6,7 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"planner/core" . "planner/core"
) )
func getUserByName(c *gin.Context) { func getUserByName(c *gin.Context) {
@ -14,23 +14,19 @@ func getUserByName(c *gin.Context) {
Name string `fdb:"name"` Name string `fdb:"name"`
} }
if c.ShouldBind(&q) == nil { if c.ShouldBind(&q) == nil {
user, err := core.UserGet(db, q.Name) user := User{
if err != nil { Username: q.Name,
c.String(http.StatusInternalServerError, "Unable to get user: "+err.Error())
return
} }
db.Take(&user)
fmt.Println(user)
c.JSON(http.StatusOK, user) c.JSON(http.StatusOK, user)
} }
} }
func createUser(c *gin.Context) { func createUser(c *gin.Context) {
var u core.User var u User
if c.ShouldBind(&u) == nil { if c.ShouldBind(&u) == nil {
err := u.Create(db) db.Create(&u)
if err != nil {
c.String(http.StatusInternalServerError, "Unable to create user: "+err.Error())
return
}
c.Status(http.StatusCreated) c.Status(http.StatusCreated)
} else { } else {
fmt.Print("Could not bind model") fmt.Print("Could not bind model")
@ -47,13 +43,12 @@ func login(c *gin.Context) {
if q.Username == "" { if q.Username == "" {
c.String(http.StatusBadRequest, "Login data is null") c.String(http.StatusBadRequest, "Login data is null")
} else { } else {
user, err := core.UserGet(db, q.Username) user := User{
if err != nil { Username: q.Username,
c.String(http.StatusInternalServerError, "Unable to get user: "+err.Error())
return
} }
db.Take(&user)
if user.Password == q.Password { if user.Password == q.Password {
c.JSON(http.StatusOK, gin.H{"username": user.Username}) c.JSON(http.StatusOK, map[string]string{"username": user.Username})
} else { } else {
c.Status(http.StatusForbidden) c.Status(http.StatusForbidden)
} }

47
base.sql
View file

@ -1,47 +0,0 @@
CREATE TABLE users (
username TEXT PRIMARY KEY,
password TEXT NOT NULL
);
CREATE TABLE plans (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
owner TEXT REFERENCES users(username) NOT NULL,
description TEXT DEFAULT '',
join_code TEXT NOT NULL
);
CREATE TABLE members (
id INTEGER PRIMARY KEY AUTOINCREMENT,
plan_id INTEGER REFERENCES plans(id) NOT NULL,
name TEXT NOT NULL,
user_id TEXT REFERENCES users(username)
);
CREATE TABLE polls (
id INTEGER PRIMARY KEY AUTOINCREMENT,
plan_id INTEGER REFERENCES plans(id) NOT NULL,
options TEXT DEFAULT ''
);
CREATE TABLE votes (
poll_id INTEGER REFERENCES polls(id),
member_id INTEGER REFERENCES members(id),
value text,
PRIMARY KEY (poll_id,member_id)
);
CREATE TABLE expenses (
id INTEGER PRIMARY KEY AUTOINCREMENT,
plan_id INTEGER REFERENCES plans(id) NOT NULL,
payer_id INTEGER REFERENCES members(id) NOT NULL,
amount DECIMAL NOT NULL
);
CREATE TABLE debts (
expense_id INTEGER REFERENCES expenses(id) NOT NULL,
debtor_id INTEGER REFERENCES members(id) NOT NULL,
amount DECIMAL NOT NULL,
paid DECIMAL,
PRIMARY KEY (expense_id,debtor_id)
);

12
core/debts.go
View file

@ -1,12 +0,0 @@
package core
func (d *Debt) Create(db SqlExecutor) error {
_, err := db.Exec(
"INSERT INTO debts(expense_id, debtor_id, amount, paid) VALUES (?,?,?,?)",
d.ExpenseId,
d.DebtorId,
d.Amount,
d.Paid,
)
return err
}

196
core/expenses.go
View file

@ -1,196 +0,0 @@
package core
import (
"database/sql"
"encoding/json"
"errors"
"fmt"
"github.com/shopspring/decimal"
)
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 ExpenseCreate(db *sql.DB, plan Plan, payer Member, amount decimal.Decimal) (*Expense, error) {
expense := new(Expense)
expense.PlanId = plan.Id
expense.PayerId = payer.Id
expense.Amount = amount
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 *sql.DB) ([]Debt, error) {
var debts []Debt
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 *sql.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)
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
}
}
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 (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
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 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 &e, nil
}

48
core/models.go
View file

@ -1,54 +1,46 @@
package core package core
import "github.com/shopspring/decimal"
type User struct { type User struct {
Username string `json:"username"` Username string `gorm:"primaryKey" json:"username"`
Password string `json:"password"` Password string `json:"password"`
OwnedPlans []Plan `gorm:"foreignKey:Owner;references:Username" json:"-"`
MemberOf []Member `json:"-"`
Votes []Vote `gorm:"foreignKey:UsernameID" json:"-"`
} }
type Member struct { type Member struct {
Id uint `json:"-"` ID uint `gorm:"primaryKey;autoIncrement:true" json:"-"`
PlanId uint `json:"-"` PlanID uint `json:"-"`
Name string `json:"name,omitempty"` Plan Plan `json:"-"`
UserId *string `json:"username,omitempty"` 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"`
User User `gorm:"foreignKey:UserID" json:"-"`
} }
// CREATE TABLE plans(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING, owner STRING, FOREIGN KEY(owner) REFERENCES users(username)) // CREATE TABLE plans(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING, owner STRING, FOREIGN KEY(owner) REFERENCES users(username))
// CREATE TABLE plan_user_relations(username STRING, plan INTEGER, PRIMARY KEY(username, plan), FOREIGN KEY username REFERENCES user(username), FOREIGN KEY plan REFERENCES plans(id)) // CREATE TABLE plan_user_relations(username STRING, plan INTEGER, PRIMARY KEY(username, plan), FOREIGN KEY username REFERENCES user(username), FOREIGN KEY plan REFERENCES plans(id))
type Plan struct { type Plan struct {
Id uint `json:"id"` ID uint `gorm:"primaryKey;autoIncrement:true" json:"id"`
Name string `json:"name"` Name string `json:"name"`
Owner string `json:"owner"` Owner string `json:"owner"`
Description string `json:"description"` Description string `json:"description"`
JoinCode string `json:"join_code,omitempty"` JoinCode string `gorm:"not null" json:"join_code,omitempty"`
} Members []Member `json:"-"`
Polls []Poll `gorm:"foreignKey:PlanID;references:ID" json:"-"`
type Expense struct {
Id uint `json:"id"`
PlanId uint `json:"-"`
PayerId uint `json:"-"`
Amount decimal.Decimal `json:"amount"`
}
type Debt struct {
Id uint
ExpenseId uint `json:"-"`
DebtorId uint `json:"-"`
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)) // CREATE TABLE polls(id INTEGER PRIMARY KEY AUTOINCREMENT, plan INTEGER, name STRING, options JSON, FOREIGN KEY plan REFERENCES plans(id))
type Poll struct { type Poll struct {
Id uint `json:"id"` ID uint `gorm:"primaryKey;autoIncrement:true" json:"id"`
PlanId uint `json:"-"` PlanID uint `json:"-"`
Options string `json:"options"` Options string `json:"options"`
Votes []Vote `gorm:"foreignKey:PollID;references:ID" json:"-"`
} }
// CREATE TABLE votes(id INTEGER, poll INTEGER, user STRING, value JSON, FOREIGN KEY poll REFERENCES polls(id), FOREIGN KEY user REFERENCES user(username)) // CREATE TABLE votes(id INTEGER, poll INTEGER, user STRING, value JSON, FOREIGN KEY poll REFERENCES polls(id), FOREIGN KEY user REFERENCES user(username))
type Vote struct { type Vote struct {
PollId uint `json:"-"` PollID uint `gorm:"primaryKey" json:"-"`
MemberId uint `json:"member_id"` UsernameID string `gorm:"primaryKey" json:"username_id"`
Value string `json:"value"` Value string `json:"value"`
} }

118
core/plans.go
View file

@ -2,13 +2,13 @@ package core
import ( import (
"crypto/rand" "crypto/rand"
"database/sql"
"encoding/base64" "encoding/base64"
"errors" "errors"
"fmt"
"gorm.io/gorm"
) )
func PlanCreate(db *sql.DB, user *User, name string) (*Plan, error) { func CreatePlan(db *gorm.DB, user *User, name string) (*Plan, error) {
join_code := make([]byte, 32) join_code := make([]byte, 32)
_, err := rand.Read(join_code) _, err := rand.Read(join_code)
if err != nil { if err != nil {
@ -18,99 +18,102 @@ func PlanCreate(db *sql.DB, user *User, name string) (*Plan, error) {
var plan Plan = Plan{ var plan Plan = Plan{
Name: name, Name: name,
Owner: user.Username, Owner: user.Username,
Members: []Member{
{
UserID: user.Username,
Type: "user",
},
},
JoinCode: base64.URLEncoding.EncodeToString(join_code), JoinCode: base64.URLEncoding.EncodeToString(join_code),
} }
row := db.QueryRow( result := db.Create(&plan)
"INSERT INTO plans(name, owner, description, join_jode) VALUES (?, ?, '', ?) RETURNING id", if result.Error != nil {
plan.Name, return nil, result.Error
plan.Owner,
plan.JoinCode,
)
if err := row.Scan(&plan.Id); err != nil {
return nil, err
} }
return &plan, nil return &plan, nil
} }
func PlanGet(db *sql.DB, id uint) (*Plan, error) { func GetPlan(orm *gorm.DB, id uint) (*Plan, error) {
plan := Plan{} var plan Plan = Plan{
row := db.QueryRow("SELECT name,owner,description,join_code FROM plans WHERE id=?", id) ID: id,
if err := row.Scan(&plan.Name, &plan.Owner, &plan.Description, &plan.JoinCode); err != nil { }
if errors.Is(err, sql.ErrNoRows) { result := orm.Take(&plan)
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, ErrNotFound return nil, ErrNotFound
} else if result.Error != nil {
return nil, result.Error
} }
return nil, fmt.Errorf("Unexpected database error: %w", err)
}
return &plan, nil return &plan, nil
} }
func (p *Plan) GetAllUsers(db *sql.DB) ([]Member, error) { func (p *Plan) GetAllUsers(orm *gorm.DB) ([]Member, error) {
members := []Member{} var members []Member
rows, err := db.Query("SELECT id,plan_id,name,user_id FROM members WHERE plan_id=?", p.Id) err := orm.Model(p).Association("Members").Find(&members)
if err != nil {
return members, err
}
defer rows.Close()
for rows.Next() {
var m Member
rows.Scan(&m.Id, &m.PlanId, &m.Name, &m.UserId)
members = append(members, m)
}
return members, err return members, err
} }
func (p *Plan) IsMember(db *sql.DB, u *User) (bool, error) { func (p *Plan) IsMember(orm *gorm.DB, u *User) (bool, error) {
var member_count int var member_count int64
row := db.QueryRow("SELECT count(1) FROM members WHERE plan_id=? AND user_id=?", p.Id, u.Username) result := orm.
if err := row.Scan(&member_count); err != nil { Table("members").
return false, nil Where("user_id=? AND plan_id=?", u.Username, p.ID).
Count(&member_count).Error
if result != nil {
return false, ErrNotMember
} }
return member_count == 1, nil return member_count == 1, nil
} }
func (p *Plan) GetMember(db *sql.DB, u *User) (*Member, error) { func (p *Plan) GetMember(orm *gorm.DB, u *User) (*Member, error) {
var m Member var m Member
row := db.QueryRow("SELECT id,plan_id,name,user_id FROM members WHERE plan_id=? AND user_id=?", p.Id, u.Username) result := orm.
if err := row.Scan(&m.Id, &m.PlanId, &m.Name, &m.UserId); err != nil { Table("members").
if errors.Is(err, sql.ErrNoRows) { Where("user_id=? AND plan_id=?", u.Username, p.ID).
Take(&m).Error
if result != nil {
return nil, ErrNotMember return nil, ErrNotMember
} }
return nil, fmt.Errorf("Unable to check if user %s is member in plan %d: %w", u.Username, p.Id, err)
}
return &m, nil return &m, nil
} }
func (p *Plan) HasNonUser(db *sql.DB, name string) (bool, error) { func (p *Plan) HasNonUser(orm *gorm.DB, name string) (bool, error) {
var member_count int var member_count int64
row := db.QueryRow("SELECT count(1) FROM members WHERE plan_id=? AND name=?", p.Id, name) result := orm.
if err := row.Scan(&member_count); err != nil { Table("members").
return false, nil Where("plan_id=? AND name=?", p.ID, name).
Count(&member_count).Error
if result != nil {
return false, result
} }
return member_count == 1, nil return member_count == 1, nil
} }
func (p *Plan) AddMember(db *sql.DB, new_member *Member) error { func (p *Plan) AddMember(orm *gorm.DB, new_member *Member) error {
if new_member == nil { if new_member == nil {
return errors.New("Member is nil") return errors.New("Member is nil")
} }
new_member.PlanId = p.Id new_member.PlanID = p.ID
if new_member.Name != "" { if new_member.Type == "non-user" {
found, err := p.HasNonUser(db, new_member.Name) if new_member.Name == "" {
return errors.New("name required for non user")
}
found, err := p.HasNonUser(orm, new_member.Name)
if err != nil { if err != nil {
return nil return nil
} }
if found { if found {
return errors.New("Non user name taken") return errors.New("Non user name taken")
} }
_, err = db.Exec("INSERT INTO members(plan_id, name) VALUES (?,?)", new_member.PlanId, new_member.Name) return orm.Create(&new_member).Error
return err } else if new_member.Type == "user" {
} else if *new_member.UserId != "" { user, err := GetUser(orm, new_member.UserID)
user, err := UserGet(db, *new_member.UserId)
if err != nil { if err != nil {
return err return err
} }
found, err := p.IsMember(db, &user) found, err := p.IsMember(orm, &user)
if err != nil { if err != nil {
return nil return nil
} }
@ -118,9 +121,8 @@ func (p *Plan) AddMember(db *sql.DB, new_member *Member) error {
return errors.New("User already is member") return errors.New("User already is member")
} }
_, err = db.Exec("INSERT INTO members(plan_id, user_id) VALUES (?,?)", new_member.PlanId, new_member.UserId) return orm.Create(&new_member).Error
return err
} else { } else {
return errors.New("Member object requires one of Name or UserID to be filled") return errors.New("Invalid type for user")
} }
} }

64
core/polls.go
View file

@ -1,59 +1,43 @@
package core package core
import ( import (
"database/sql"
"fmt" "fmt"
"slices"
"strings" "strings"
"gorm.io/gorm"
) )
func (p *Poll) Create(db *sql.DB) error { func GetPoll(orm *gorm.DB, user User, id uint) (*Poll, error) {
row := db.QueryRow( var poll Poll = Poll{
"INSERT INTO polls(plan_id, options) VALUES(?,?) RETURNING id", ID: id,
p.PlanId,
p.Options,
)
if err := row.Scan(&p.Id); err != nil {
return fmt.Errorf("Unable to create new poll for plan %d: %w", p.PlanId, err)
} }
return nil
}
func PollGet(db *sql.DB, user User, id uint) (*Poll, error) { if result := orm.Take(&poll); result.Error != nil {
var poll Poll return nil, result.Error
row := db.QueryRow("SELECT id,plan_id,options FROM polls WHERE id=?", id)
if err := row.Scan(&poll.Id, &poll.PlanId, &poll.Options); err != nil {
return nil, err
} }
fmt.Printf("%+v\n", poll.PlanID)
return &poll, nil return &poll, nil
} }
func PollsList(db *sql.DB, plan_id int) ([]Poll, error) { func (p *Poll) SetVote(orm *gorm.DB, user User, option string) error {
var polls []Poll found := false
rows, err := db.Query("SELECT id,plan_id,options FROM polls WHERE plan_id=?", plan_id)
if err != nil {
return polls, fmt.Errorf("Unable to query polls for plan %d: %w", plan_id, err)
}
defer rows.Close()
for rows.Next() {
var poll Poll
if err := rows.Scan(&poll.Id, &poll.PlanId, &poll.Options); err != nil {
return nil, fmt.Errorf("Unable to scan polls for plan %d: %w", plan_id, err)
}
polls = append(polls, poll)
}
return polls, nil
}
func (p *Poll) SetVote(db *sql.DB, member Member, option string) error {
options := strings.Split(p.Options, ",") options := strings.Split(p.Options, ",")
if !slices.Contains(options, option) { for _, opt := range options {
return fmt.Errorf("%s is not a valid option (%s): %w", option, options, ErrInvalidOption) if opt == option {
found = true
break
}
}
if !found {
return ErrInvalidOption
} }
_, err := db.Exec("INSERT INTO votes(poll_id,member_id,value) VALUES (?,?,?)", p.Id, member.Id, option)
return err if res := orm.Create(Vote{PollID: p.ID, UsernameID: user.Username, Value: option}); res.Error != nil {
return res.Error
}
return nil
} }

9
core/sqlexecutor.go
View file

@ -1,9 +0,0 @@
package core
import "database/sql"
type SqlExecutor interface {
Exec(query string, args ...interface{}) (sql.Result, error)
Query(query string, args ...interface{}) (*sql.Rows, error)
QueryRow(query string, args ...interface{}) *sql.Row
}

93
core/users.go
View file

@ -1,49 +1,31 @@
package core package core
import ( import (
"database/sql"
"errors" "errors"
"fmt"
"gorm.io/gorm"
) )
func (u *User) ListPlans(db *sql.DB) ([]Plan, error) { func (u *User) ListPlans(orm *gorm.DB) ([]Plan, error) {
var plans []Plan var plans []Plan
rows, err := db.Query( err := orm.Debug().Table("plans p").
"SELECT p.id,p.name,p.owner,p.description,p.join_code FROM plans p "+ Select("p.*").
"JOIN members m ON m.plan_id=p.id "+ Joins("JOIN members m ON m.plan_id=p.id").
"WHERE m.user_id=?", Where("m.user_id=?", u.Username).
u.Username, Find(&plans)
) return plans, err.Error
if err != nil {
return plans, fmt.Errorf(
"Unable to query plans for user %s: %w",
u.Username,
err,
)
}
defer rows.Close()
for rows.Next() {
p := Plan{}
err = rows.Scan(&p.Id, &p.Name, &p.Owner, &p.Description, &p.JoinCode)
if err != nil {
return plans, fmt.Errorf(
"Unable to scan plan for user %s: %w",
u.Username,
err,
)
}
plans = append(plans, p)
}
return plans, nil
} }
func (u *User) GetPlan(db *sql.DB, plan_id uint) (*Plan, error) { func (u *User) GetPlan(db *gorm.DB, plan_id uint) (Plan, error) {
plan, err := PlanGet(db, plan_id) var plan Plan = Plan{
ID: plan_id,
}
result := db.Take(&plan)
if errors.Is(err, sql.ErrNoRows) { if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, ErrNotFound return plan, ErrNotFound
} else if err != nil { } else if result.Error != nil {
return nil, err return plan, result.Error
} }
if plan.Owner == u.Username { if plan.Owner == u.Username {
@ -51,43 +33,18 @@ func (u *User) GetPlan(db *sql.DB, plan_id uint) (*Plan, error) {
} }
isMember, err := plan.IsMember(db, u) isMember, err := plan.IsMember(db, u)
if !isMember || err != nil { if !isMember || err != nil {
return nil, err return plan, err
} }
return plan, nil return plan, nil
} }
func (u *User) GetMemberFromPlan(db *sql.DB, p Plan) (*Member, error) { func GetUser(orm *gorm.DB, username string) (User, error) {
m := Member{} user := User{Username: username}
row := db.QueryRow( if err := orm.Take(&user).Error; err != nil {
"SELECT id,plan_id,name,user_id FROM members WHERE user_id=? AND plan_id=?",
u.Username,
p.Id,
)
if err := row.Scan(&m.Id, &m.PlanId, &m.Name, &m.UserId); err != nil {
return nil, fmt.Errorf(
"Unable to get member from user %s and plan %d: %w",
u.Username,
p.Id,
err,
)
}
return &m, nil
}
func UserGet(db *sql.DB, username string) (User, error) {
var user User
row := db.QueryRow("SELECT username, password FROM users WHERE username=?", username)
err := row.Scan(&user.Username, &user.Password)
return user, err return user, err
} }
return user, nil
func (u *User) Create(db *sql.DB) error {
_, err := db.Exec(
"INSERT INTO users(username, password) VALUES (?,?)",
u.Username,
u.Password,
)
return fmt.Errorf("Unable to create user %s: %w", u.Username, err)
} }

23
core/votes.go
View file

@ -1,23 +0,0 @@
package core
import (
"database/sql"
"fmt"
)
func VotesList(db *sql.DB, poll_id int) ([]Vote, error) {
votes := []Vote{}
rows, err := db.Query("SELECT poll_id,member_id,value FROM polls WHERE poll_id=?", poll_id)
if err != nil {
return votes, fmt.Errorf("Unable to get votes for poll %d: %w", poll_id, err)
}
defer rows.Close()
for rows.Next() {
v := Vote{}
err = rows.Scan(&v.PollId, &v.MemberId, &v.Value)
if err != nil {
return votes, fmt.Errorf("Unable to scan vote for poll %d: %w", poll_id, err)
}
}
return votes, nil
}

44
db.go
View file

@ -1,33 +1,45 @@
package main package main
import ( import (
"database/sql" "gorm.io/driver/sqlite"
"gorm.io/gorm"
"log" "log"
"os" "os"
. "planner/core"
_ "github.com/mattn/go-sqlite3"
) )
func bootstrapDatabase() *sql.DB { func bootstrapDatabase() *gorm.DB {
fi, err := os.Stat("./db.sqlite") fi, err := os.Stat("./db.sqlite")
var db *sql.DB var db *gorm.DB
if err != nil { if err != nil {
if os.IsNotExist(err) { if os.IsNotExist(err) {
db, err := sql.Open("sqlite3", "./db.sqlite") db, err := gorm.Open(sqlite.Open("./db.sqlite"), &gorm.Config{})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
return nil return nil
} }
file, err := os.ReadFile("./base.sql") db.AutoMigrate(&User{}, &Member{}, &Plan{}, &Poll{}, &Vote{})
if err != nil {
log.Fatal("Unable to open base.sql", err) //var tables = [...]struct {
} // key string
contents := string(file) // query string
_, err = db.Exec(contents) //}{
if err != nil { // {key: "users", query: "CREATE TABLE users(username STRING PRIMARY KEY, password STRING)"},
log.Fatal("Unable to create base db", err) // {key: "plans", query: "CREATE TABLE plans(id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING, owner STRING, FOREIGN KEY(owner) REFERENCES users(username))"},
} // {key: "plan_user_relations", query: "CREATE TABLE plan_user_relations(username STRING, plan INTEGER, PRIMARY KEY(username, plan), FOREIGN KEY username REFERENCES user(username), FOREIGN KEY plan REFERENCES plans(id))"},
// {key: "polls", query: "CREATE TABLE polls(id INTEGER PRIMARY KEY AUTOINCREMENT, plan INTEGER, name STRING, options JSON, FOREIGN KEY plan REFERENCES plans(id))"},
// {key: "votes", query: "CREATE TABLE votes(id INTEGER, poll INTEGER, user STRING, value JSON, FOREIGN KEY poll REFERENCES polls(id), FOREIGN KEY user REFERENCES user(username))"},
//}
//for _, table := range tables {
// _, err = db.Exec(table.query)
// if err != nil {
// log.Fatal("Failed to create " + table.key + " table")
// log.Fatal(err)
// return false
// }
//}
return db return db
} else { } else {
log.Fatal(err) log.Fatal(err)
@ -40,7 +52,7 @@ func bootstrapDatabase() *sql.DB {
return nil return nil
} }
db, err = sql.Open("sqlite3", "./db.sqlite") db, err = gorm.Open(sqlite.Open("./db.sqlite"), &gorm.Config{})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)

7
go.mod
View file

@ -4,8 +4,9 @@ go 1.23.0
require ( require (
github.com/gin-gonic/gin v1.10.0 github.com/gin-gonic/gin v1.10.0
github.com/mattn/go-sqlite3 v1.14.27 github.com/mattn/go-sqlite3 v1.14.23
github.com/shopspring/decimal v1.4.0 gorm.io/driver/sqlite v1.5.6
gorm.io/gorm v1.25.12
) )
require ( require (
@ -19,6 +20,8 @@ require (
github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.22.0 // indirect github.com/go-playground/validator/v10 v10.22.0 // indirect
github.com/goccy/go-json v0.10.3 // indirect github.com/goccy/go-json v0.10.3 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect
github.com/json-iterator/go v1.1.12 // indirect github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.2.8 // indirect github.com/klauspost/cpuid/v2 v2.2.8 // indirect
github.com/leodido/go-urn v1.4.0 // indirect github.com/leodido/go-urn v1.4.0 // indirect

4
go.sum
View file

@ -45,8 +45,6 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-sqlite3 v1.14.23 h1:gbShiuAP1W5j9UOksQ06aiiqPMxYecovVGwmTxWtuw0= github.com/mattn/go-sqlite3 v1.14.23 h1:gbShiuAP1W5j9UOksQ06aiiqPMxYecovVGwmTxWtuw0=
github.com/mattn/go-sqlite3 v1.14.23/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= github.com/mattn/go-sqlite3 v1.14.23/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/mattn/go-sqlite3 v1.14.27 h1:drZCnuvf37yPfs95E5jd9s3XhdVWLal+6BOK6qrv6IU=
github.com/mattn/go-sqlite3 v1.14.27/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@ -56,8 +54,6 @@ github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNH
github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc= github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=

7
planner.go
View file

@ -12,16 +12,17 @@ import (
func main() { func main() {
fmt.Println("Opening database db.sqlite") fmt.Println("Opening database db.sqlite")
db := bootstrapDatabase() orm := bootstrapDatabase()
if db == nil { if orm == nil {
log.Fatal("Failed to init database") log.Fatal("Failed to init database")
return return
} }
db, _ := orm.DB()
defer db.Close() defer db.Close()
r := gin.Default() r := gin.Default()
apis.BindAPIs(r, db) apis.BindAPIs(r, orm)
r.Run() r.Run()
} }