Rework query to return lists

2024-10-27 19:07:47 +01:00
parent 91a3a0f4f7
commit b86d586c42
4 changed files with 222 additions and 148 deletions
--- a/guildService.go
+++ b/guildService.go
@@ -12,20 +12,30 @@ type GuildServiceQuery struct {
 	ID   *int64  `db:"id"`
 }

-func (gs *GuildService) Query(query GuildServiceQuery) (Guild, error) {
-	guild := Guild{}
+func (gs *GuildService) Query(query GuildServiceQuery) ([]Guild, error) {
+	res := []Guild{}
 	sqlQuery := "SELECT id, name FROM guild"
 	whereQuery := BuildWhereQuery(query)
 	if whereQuery != "" {
 		sqlQuery += " " + whereQuery
 	}

-	err := gs.db.readConn.QueryRow(sqlQuery).Scan(&guild.ID, &guild.Name)
+	rows, err := gs.db.readConn.Query(sqlQuery)
 	if err != nil {
-		return guild, fmt.Errorf("failed getting guild for query %q: %v", sqlQuery, err)
+		return res, fmt.Errorf("failed getting guilds for query %q: %v", sqlQuery, err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		guild := Guild{}
+		err := rows.Scan(&guild.ID, &guild.Name)
+		if err != nil {
+			return res, fmt.Errorf("failed scanning guild: %v", err)
+		}
+		res = append(res, guild)
 	}

-	return guild, nil
+	return res, nil
 }

 func (gs *GuildService) Create(name string) (Guild, error) {
@@ -40,13 +50,24 @@ func (gs *GuildService) Create(name string) (Guild, error) {
 		return guild, fmt.Errorf("failed to get last insert id: %v", err)
 	}

-	return gs.Query(GuildServiceQuery{ID: &id})
+	qres, err := gs.Query(GuildServiceQuery{ID: &id})
+	if err != nil {
+		return guild, fmt.Errorf("failed getting guild for id %d: %v", id, err)
+	}
+	if len(qres) > 1 {
+		return guild, fmt.Errorf("more than one guild found for id %d", id)
+	}
+
+	return qres[0], nil
 }

 func (gs *GuildService) GetOrCreate(name string) (Guild, error) {
 	guild := Guild{}
-	guild, err := gs.Query(GuildServiceQuery{Name: &name})
+	guilds, err := gs.Query(GuildServiceQuery{Name: &name})
 	if err != nil {
+		if len(guilds) > 1 {
+			return guild, fmt.Errorf("more than one guild found for name %s", name)
+		}
 		guild, err = gs.Create(name)
 		if err != nil {
 			return guild, fmt.Errorf("failed creating guild: %v", err)
--- a/main.go
+++ b/main.go
@@ -6,8 +6,6 @@ import (
 	"io"
 	"log"
 	"os"
-	"strings"
-	"time"
 )

 var Error *log.Logger
@@ -32,6 +30,9 @@ func init() {
 }

 var db DB
+var gs GuildService
+var ps PlayerService
+var ns NoteService

 func main() {
 	inputFile := flag.String("if", "input", "Input file")
@@ -48,155 +49,168 @@ func main() {
 	}
 	defer db.Close()

+	gs = GuildService{db: &db}
+	ps = PlayerService{db: &db}
+	ns = NoteService{db: &db}
+
 	inputData, err := os.ReadFile(*inputFile)
 	if err != nil {
 		Error.Printf("Failed reading input file: %v", err)
 		return
 	}
-	note, err := ParseNote(string(inputData))
+	log.Printf("%#v", string(inputData))
+
+	res, err := gs.Query(GuildServiceQuery{})
 	if err != nil {
-		Error.Printf("Failed parsing note: %v", err)
+		Error.Printf("Failed getting guilds: %v", err)
 		return
 	}
+	log.Printf("%#v", res)
+	// note, err := ParseNote(string(inputData))
+	// if err != nil {
+	// 	Error.Printf("Failed parsing note: %v", err)
+	// 	return
+	// }

-	err = SaveNote(note)
-	if err != nil {
-		Error.Printf("Failed saving note: %v", err)
-		return
-	}
+	// err = SaveNote(note)
+	// if err != nil {
+	// 	Error.Printf("Failed saving note: %v", err)
+	// 	return
+	// }
 }

-func ParseNote(data string) (NoteData, error) {
-	res := NoteData{}
-	lines := strings.Split(data, "\n")
-	note := []string{}
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if line == "" {
-			continue
-		}
-		parts := strings.Split(line, ":")
-		switch parts[0] {
-		case "p":
-			res.Player = parts[1]
-		case "d":
-			var err error
-			res.Date, err = time.Parse(time.DateOnly, parts[1])
-			if err != nil {
-				return res, fmt.Errorf("failed to parse date: %v", err)
-			}
-		case "g":
-			res.Guild = parts[1]
-		default:
-			note = append(note, line)
-		}
-	}
-	res.Note = strings.Join(note, "\n")
-	return res, nil
-}
+// func ParseNote(data string) (NoteData, error) {
+// 	res := NoteData{}
+// 	lines := strings.Split(data, "\n")
+// 	note := []string{}
+// 	for _, line := range lines {
+// 		line = strings.TrimSpace(line)
+// 		if line == "" {
+// 			continue
+// 		}
+// 		parts := strings.Split(line, ":")
+// 		switch parts[0] {
+// 		case "p":
+// 			res.Player = parts[1]
+// 		case "d":
+// 			var err error
+// 			res.Date, err = time.Parse(time.DateOnly, parts[1])
+// 			if err != nil {
+// 				return res, fmt.Errorf("failed to parse date: %v", err)
+// 			}
+// 		case "g":
+// 			res.Guild = parts[1]
+// 		default:
+// 			note = append(note, line)
+// 		}
+// 	}
+// 	res.Note = strings.Join(note, "\n")
+// 	return res, nil
+// }

-func SaveNote(data NoteData) error {
-	guild, err := GetOrCreateGuildByName(data.Guild)
-	if err != nil {
-		return fmt.Errorf("failed getting guild for %s: %v", data.Guild, err)
-	}
+// func SaveNote(data NoteData) error {
+// 	guild, err := GetOrCreateGuildByName(data.Guild)
+// 	if err != nil {
+// 		return fmt.Errorf("failed getting guild for %s: %v", data.Guild, err)
+// 	}

-	stinky, err := GetOrCreateStinkyByName(data.Player, guild)
-	if err != nil {
-		return fmt.Errorf("failed getting stinky for %s: %v", data.Player, err)
-	}
+// 	stinky, err := GetOrCreateStinkyByName(data.Player, guild)
+// 	if err != nil {
+// 		return fmt.Errorf("failed getting stinky for %s: %v", data.Player, err)
+// 	}

-	stinky.Guild = guild
-	note := Note{
-		Content:   data.Note,
-		Timestamp: data.Date,
-		Stinky:    stinky,
-	}
-	err = InsertNote(note)
-	if err != nil {
-		return fmt.Errorf("failed inserting note: %v", err)
-	}
+// 	stinky.Guild = guild
+// 	note := Note{
+// 		Content:   data.Note,
+// 		Timestamp: data.Date,
+// 		Stinky:    stinky,
+// 	}
+// 	err = InsertNote(note)
+// 	if err != nil {
+// 		return fmt.Errorf("failed inserting note: %v", err)
+// 	}

-	return nil
-}
+// 	return nil
+// }

-func GetOrCreateGuildByName(name string) (Guild, error) {
-	var guild Guild
-	err := db.readConn.QueryRow("select id, name from guild where name = ?", name).Scan(&guild.ID, &guild.Name)
-	if err != nil {
-		guild, err = CreateGuild(name)
-		if err != nil {
-			return guild, fmt.Errorf("failed creating guild: %v", err)
-		}
-	}
-	return guild, nil
-}
+// func GetOrCreateGuildByName(name string) (Guild, error) {
+// 	var guild Guild
+// 	err := db.readConn.QueryRow("select id, name from guild where name = ?", name).Scan(&guild.ID, &guild.Name)
+// 	if err != nil {
+// 		guild, err = CreateGuild(name)
+// 		if err != nil {
+// 			return guild, fmt.Errorf("failed creating guild: %v", err)
+// 		}
+// 	}
+// 	return guild, nil
+// }

-func CreateGuild(name string) (Guild, error) {
-	guild := Guild{}
-	res, err := db.writeConn.Exec("insert into guild (name) values (?)", name)
-	if err != nil {
-		return guild, fmt.Errorf("failed to insert guild: %v", err)
-	}
+// func CreateGuild(name string) (Guild, error) {
+// 	guild := Guild{}
+// 	res, err := db.writeConn.Exec("insert into guild (name) values (?)", name)
+// 	if err != nil {
+// 		return guild, fmt.Errorf("failed to insert guild: %v", err)
+// 	}

-	id, err := res.LastInsertId()
-	if err != nil {
-		return guild, fmt.Errorf("failed to get last insert id: %v", err)
-	}
+// 	id, err := res.LastInsertId()
+// 	if err != nil {
+// 		return guild, fmt.Errorf("failed to get last insert id: %v", err)
+// 	}

-	return GetGuildById(int(id))
-}
+// 	return GetGuildById(int(id))
+// }

-func GetGuildById(id int) (Guild, error) {
-	var guild Guild
-	err := db.readConn.QueryRow("select id, name from guild where id = ?", id).Scan(&guild.ID, &guild.Name)
-	if err != nil {
-		log.Printf("Guild not found: %v", err)
-	}
-	return guild, nil
-}
+// func GetGuildById(id int) (Guild, error) {
+// 	var guild Guild
+// 	err := db.readConn.QueryRow("select id, name from guild where id = ?", id).Scan(&guild.ID, &guild.Name)
+// 	if err != nil {
+// 		log.Printf("Guild not found: %v", err)
+// 	}
+// 	return guild, nil
+// }

-func GetOrCreateStinkyByName(name string, guild Guild) (Stinky, error) {
-	var stinky Stinky
-	err := db.readConn.QueryRow("select id, name, guild from stinky where name = ?", name).Scan(&stinky.ID, &stinky.Name, &stinky.Guild.ID)
-	if err != nil {
-		log.Printf("Stinky not found, creating: %v", err)
-		stinky, err = CreateStinky(name, Guild{})
-		if err != nil {
-			return stinky, fmt.Errorf("failed creating stinky: %v", err)
-		}
-	}
-	return stinky, nil
-}
+// func GetOrCreateStinkyByName(name string, guild Guild) (Stinky, error) {
+// 	var stinky Stinky
+// 	err := db.readConn.QueryRow("select id, name, guild from stinky where name = ?", name).Scan(&stinky.ID, &stinky.Name, &stinky.Guild.ID)
+// 	if err != nil {
+// 		log.Printf("Stinky not found, creating: %v", err)
+// 		stinky, err = CreateStinky(name, guild)
+// 		if err != nil {
+// 			return stinky, fmt.Errorf("failed creating stinky: %v", err)
+// 		}
+// 	}
+// 	return stinky, nil
+// }

-func CreateStinky(name string, guild Guild) (Stinky, error) {
-	stinky := Stinky{}
-	res, err := db.writeConn.Exec("insert into stinky (name, guild) values (?, ?)", name, guild.ID)
-	if err != nil {
-		return stinky, fmt.Errorf("failed to insert stinky: %v", err)
-	}
+// func CreateStinky(name string, guild Guild) (Stinky, error) {
+// 	stinky := Stinky{}
+// 	res, err := db.writeConn.Exec("insert into stinky (name, guild) values (?, ?)", name, guild.ID)
+// 	if err != nil {
+// 		return stinky, fmt.Errorf("failed to insert stinky: %v", err)
+// 	}

-	id, err := res.LastInsertId()
-	if err != nil {
-		return stinky, fmt.Errorf("failed getting last insert id for %d: %v", id, err)
-	}
+// 	id, err := res.LastInsertId()
+// 	if err != nil {
+// 		return stinky, fmt.Errorf("failed getting last insert id for %d: %v", id, err)
+// 	}

-	return GetStinkyById(int(id))
-}
+// 	return GetStinkyById(int(id))
+// }

-func GetStinkyById(id int) (Stinky, error) {
-	stinky := Stinky{}
-	err := db.readConn.QueryRow("select id, name, guild from stinky where id = ?", id).Scan(&stinky.ID, &stinky.Name, &stinky.Guild.ID)
-	if err != nil {
-		return stinky, fmt.Errorf("failed getting stinky for %d: %v", id, err)
-	}
-	return stinky, nil
-}
+// func GetStinkyById(id int) (Stinky, error) {
+// 	stinky := Stinky{}
+// 	err := db.readConn.QueryRow("select id, name, guild from stinky where id = ?", id).Scan(&stinky.ID, &stinky.Name, &stinky.Guild.ID)
+// 	if err != nil {
+// 		return stinky, fmt.Errorf("failed getting stinky for %d: %v", id, err)
+// 	}
+// 	return stinky, nil
+// }

-func InsertNote(note Note) error {
-	_, err := db.writeConn.Exec("insert into note (content, timestamp, stinky) values (?, ?, ?)", note.Content, note.Timestamp, note.Stinky.ID)
-	if err != nil {
-		return fmt.Errorf("failed to insert note: %v", err)
-	}
-	return nil
-}
+// func InsertNote(note Note) error {
+// 	log.Printf("Inserting note: %#v", note)
+// 	_, err := db.writeConn.Exec("insert into note (content, timestamp, stinky) values (?, ?, ?)", note.Content, note.Timestamp, note.Stinky.ID)
+// 	if err != nil {
+// 		return fmt.Errorf("failed to insert note: %v", err)
+// 	}
+// 	return nil
+// }
--- a/noteService.go
+++ b/noteService.go
@@ -14,20 +14,30 @@ type NoteServiceQuery struct {
 	ID        *int64  `db:"id"`
 }

-func (ns *NoteService) Query(query NoteServiceQuery) (Note, error) {
-	note := Note{}
+func (ns *NoteService) Query(query NoteServiceQuery) ([]Note, error) {
+	res := []Note{}
 	sqlQuery := "SELECT id, content, timestamp, player FROM note"
 	whereQuery := BuildWhereQuery(query)
 	if whereQuery != "" {
 		sqlQuery += " " + whereQuery
 	}

-	err := ns.db.readConn.QueryRow(sqlQuery).Scan(&note.ID, &note.Content, &note.Timestamp, &note.Player.ID)
+	rows, err := ns.db.readConn.Query(sqlQuery)
 	if err != nil {
-		return note, fmt.Errorf("failed getting note for query %q: %v", sqlQuery, err)
+		return res, fmt.Errorf("failed getting notes for query %q: %v", sqlQuery, err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		note := Note{}
+		err := rows.Scan(&note.ID, &note.Content, &note.Timestamp, &note.Player.ID)
+		if err != nil {
+			return res, fmt.Errorf("failed scanning note: %v", err)
+		}
+		res = append(res, note)
 	}

-	return note, nil
+	return res, nil
 }

 func (ns *NoteService) Create(content string, timestamp time.Time, player Player) (Note, error) {
@@ -42,5 +52,13 @@ func (ns *NoteService) Create(content string, timestamp time.Time, player Player
 		return note, fmt.Errorf("failed to get last insert id: %v", err)
 	}

-	return ns.Query(NoteServiceQuery{ID: &id})
+	qres, err := ns.Query(NoteServiceQuery{ID: &id})
+	if err != nil {
+		return note, fmt.Errorf("failed getting note for id %d: %v", id, err)
+	}
+	if len(qres) > 1 {
+		return note, fmt.Errorf("more than one note found for id %d", id)
+	}
+
+	return qres[0], nil
 }
--- a/playerService.go
+++ b/playerService.go
@@ -10,20 +10,30 @@ type PlayerServiceQuery struct {
 	ID   *int64  `db:"id"`
 }

-func (ps *PlayerService) Query(query PlayerServiceQuery) (Player, error) {
-	player := Player{}
+func (ps *PlayerService) Query(query PlayerServiceQuery) ([]Player, error) {
+	res := []Player{}
 	sqlQuery := "SELECT id, name, guild FROM player"
 	whereQuery := BuildWhereQuery(query)
 	if whereQuery != "" {
 		sqlQuery += " " + whereQuery
 	}

-	err := ps.db.readConn.QueryRow(sqlQuery).Scan(&player.ID, &player.Name, &player.Guild.ID)
+	rows, err := ps.db.readConn.Query(sqlQuery)
 	if err != nil {
-		return player, fmt.Errorf("failed getting player for query %q: %v", sqlQuery, err)
+		return res, fmt.Errorf("failed getting players for query %q: %v", sqlQuery, err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		player := Player{}
+		err := rows.Scan(&player.ID, &player.Name, &player.Guild.ID)
+		if err != nil {
+			return res, fmt.Errorf("failed scanning player: %v", err)
+		}
+		res = append(res, player)
 	}

-	return player, nil
+	return res, nil
 }

 func (ps *PlayerService) Create(name string, guild Guild) (Player, error) {
@@ -38,13 +48,24 @@ func (ps *PlayerService) Create(name string, guild Guild) (Player, error) {
 		return player, fmt.Errorf("failed to get last insert id: %v", err)
 	}

-	return ps.Query(PlayerServiceQuery{ID: &id})
+	qres, err := ps.Query(PlayerServiceQuery{ID: &id})
+	if err != nil {
+		return player, fmt.Errorf("failed getting player for id %d: %v", id, err)
+	}
+	if len(qres) > 1 {
+		return player, fmt.Errorf("more than one player found for id %d", id)
+	}
+
+	return qres[0], nil
 }

 func (ps *PlayerService) GetOrCreate(name string, guild Guild) (Player, error) {
 	player := Player{}
-	player, err := ps.Query(PlayerServiceQuery{Name: &name})
+	players, err := ps.Query(PlayerServiceQuery{Name: &name})
 	if err != nil {
+		if len(players) > 1 {
+			return player, fmt.Errorf("more than one player found for name %s", name)
+		}
 		player, err = ps.Create(name, guild)
 		if err != nil {
 			return player, fmt.Errorf("failed creating player: %v", err)