1 files changed, 127 insertions, 77 deletions
diff --git a/server/guest/store.go b/server/guest/store.go
index 1a07161..a5b9374 100644
--- a/server/guest/store.go
+++ b/server/guest/store.go
@@ -4,135 +4,185 @@ import (
 	"context"
 	"errors"
 
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 
-type MemStore struct {
-	db *pgxpool.Pool
+type Store struct {
+	database *pgxpool.Pool
 }
 
-func NewMemStore(db *pgxpool.Pool) *MemStore {
-	return &MemStore{
-		db,
+func NewStore(database *pgxpool.Pool) *Store {
+	return &Store{
+		database,
 	}
 }
 
-func (m MemStore) Find(creds Credentials) (Guest, error) {
-	rows, err := m.db.Query(context.Background(), "select * from guest")
-	var guest Guest
+func (store Store) Find(credentials Credentials) (Guest, error) {
+	guestRows, err := store.database.Query(context.Background(),
+		"select * from guest")
 	if err != nil {
-		return guest, err
+		return Guest{}, err
 	}
-	defer rows.Close()
+	defer guestRows.Close()
+	guest, found := createGuest(credentials, guestRows)
 
-	found := false
-	for rows.Next() {
-		err := rows.Scan(&guest.Id, &guest.FirstName, &guest.LastName, &guest.Attendance, &guest.Email, &guest.Message, &guest.PartySize)
-		if err != nil {
-			return guest, err
-		}
-		if guest.FirstName == creds.FirstName && guest.LastName == creds.LastName {
-			found = true
-			break
-		}
+	partyRows, err := store.database.Query(context.Background(),
+		"select * from party")
+	if err != nil {
+		return Guest{}, err
 	}
+	defer partyRows.Close()
 
-	rows, err = m.db.Query(context.Background(), "select * from party")
+	guest, err = addParty(guest, partyRows)
 	if err != nil {
-		return guest, err
+		return Guest{}, err
 	}
-	defer rows.Close()
 
-	for rows.Next() {
-		var guestId int
-		var partyGuest PartyGuest
-		err := rows.Scan(&guestId, &partyGuest.FirstName, &partyGuest.LastName)
+	if found {
+		return guest, nil
+	}
+	return Guest{}, errors.New("guest not found")
+}
+
+func createGuest(credentials Credentials, guestRows pgx.Rows) (Guest, bool) {
+	var guest Guest
+	for guestRows.Next() {
+		err := guestRows.Scan(&guest.ID, &guest.FirstName, &guest.LastName,
+			&guest.Attendance, &guest.Email, &guest.Message, &guest.PartySize)
 		if err != nil {
-			return guest, err
+			return Guest{}, false
 		}
-		if guestId == guest.Id {
-			guest.PartyList = append(guest.PartyList, partyGuest)
+		if guest.FirstName == credentials.FirstName &&
+			guest.LastName == credentials.LastName {
+			return guest, true
 		}
 	}
+	return Guest{}, false
+}
 
-	if found {
-		return guest, nil
+func addParty(guestWithoutParty Guest, partyRows pgx.Rows) (Guest, error) {
+	guestWithParty := guestWithoutParty
+	for partyRows.Next() {
+		var guestID int
+		var partyGuest PartyGuest
+		err := partyRows.Scan(&guestID, &partyGuest.FirstName, &partyGuest.LastName)
+		if err != nil {
+			return Guest{}, err
+		}
+		if guestID == guestWithParty.ID {
+			guestWithParty.PartyList = append(guestWithParty.PartyList, partyGuest)
+		}
 	}
-	return guest, errors.New("Guest not found")
+	return guestWithParty, nil
 }
 
-func (m MemStore) Get() ([]Guest, error) {
-	rows, err := m.db.Query(context.Background(), "select * from guest")
+func (store Store) Get() ([]Guest, error) {
+	guestRows, err := store.database.Query(context.Background(),
+		"select * from guest")
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer guestRows.Close()
 
-	guestSlice := []Guest{}
-	for rows.Next() {
-		var guest Guest
-		err := rows.Scan(&guest.Id, &guest.FirstName, &guest.LastName, &guest.Attendance, &guest.Email, &guest.Message, &guest.PartySize)
-		if err != nil {
-			return guestSlice, err
-		}
-		guestSlice = append(guestSlice, guest)
+	guestsWithoutParty, err := store.createGuestSlice(guestRows)
+	if err != nil {
+		return []Guest{}, err
 	}
 
-	rows, err = m.db.Query(context.Background(), "select * from party")
+	partyRows, err := store.database.Query(context.Background(),
+		"select * from party")
 	if err != nil {
-		return guestSlice, err
+		return []Guest{}, err
 	}
-	defer rows.Close()
+	defer partyRows.Close()
 
-	for rows.Next() {
-		var guestId int
+	guestsWithParty, err := addPartySlice(guestsWithoutParty, partyRows)
+	if err != nil {
+		return []Guest{}, err
+	}
+	return guestsWithParty, nil
+}
+
+func (store Store) createGuestSlice(guestRows pgx.Rows) ([]Guest, error) {
+	guests := []Guest{}
+	for guestRows.Next() {
+		var guest Guest
+		err := guestRows.Scan(&guest.ID, &guest.FirstName, &guest.LastName,
+			&guest.Attendance, &guest.Email, &guest.Message, &guest.PartySize)
+		if err != nil {
+			return []Guest{}, err
+		}
+		guests = append(guests, guest)
+	}
+	return guests, nil
+}
+
+func addPartySlice(guestsWithoutParty []Guest,
+	partyRows pgx.Rows) ([]Guest, error) {
+	guestsWithParty := guestsWithoutParty
+	for partyRows.Next() {
+		var guestID int
 		var partyGuest PartyGuest
-		err := rows.Scan(&guestId, &partyGuest.FirstName, &partyGuest.LastName)
+		err := partyRows.Scan(&guestID, &partyGuest.FirstName, &partyGuest.LastName)
 		if err != nil {
-			return guestSlice, err
+			return []Guest{}, err
 		}
-		for i, g := range guestSlice {
-			if guestId == g.Id {
-				guestSlice[i].PartyList = append(g.PartyList, partyGuest)
+		for i, guest := range guestsWithParty {
+			if guestID == guest.ID {
+				guestsWithParty[i].PartyList = append(guest.PartyList, partyGuest)
 			}
 		}
 	}
-	return guestSlice, nil
+	return guestsWithParty, nil
 }
 
-func (m MemStore) Add(guest Guest) error {
-	statement := "insert into guest (id, first_name, last_name, attendance, email, message, party_size) values ($1, $2, $3, $4, $5, $6, $7)"
-	_, err := m.db.Exec(context.Background(), statement, guest.Id, guest.FirstName, guest.LastName, guest.Attendance, guest.Email, guest.Message, guest.PartySize)
-	if err != nil {
+func (store Store) Add(guest Guest) error {
+	if err := store.insertGuest(guest); err != nil {
 		return err
 	}
+	return store.insertParty(guest)
+}
 
-	statement = "insert into party (guest_id, first_name, last_name) values ($1, $2, $3)"
-	for _, pg := range guest.PartyList {
-		_, err = m.db.Exec(context.Background(), statement, guest.Id, pg.FirstName, pg.LastName)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
+func (store Store) insertGuest(guest Guest) error {
+	statement := `insert into guest (id, first_name, last_name, attendance,
+		email, message, party_size) values ($1, $2, $3, $4, $5, $6, $7)`
+	_, err := store.database.Exec(context.Background(), statement, guest.ID,
+		guest.FirstName, guest.LastName, guest.Attendance, guest.Email,
+		guest.Message, guest.PartySize)
+	return err
 }
 
-func (m MemStore) Update(guest Guest) error {
-	statement := "update guest set attendance = $1, email = $2, message = $3, party_size = $4 where id = $5"
-	_, err := m.db.Exec(context.Background(), statement, guest.Attendance, guest.Email, guest.Message, guest.PartySize, guest.Id)
-	if err != nil {
+func (store Store) Update(guest Guest) error {
+	if err := store.updateGuest(guest); err != nil {
 		return err
 	}
-
-	statement = "delete from party where guest_id = $1"
-	_, err = m.db.Exec(context.Background(), statement, guest.Id)
-	if err != nil {
+	if err := store.deleteOldParty(guest.ID); err != nil {
 		return err
 	}
+	return store.insertParty(guest)
+}
+
+func (store Store) updateGuest(guest Guest) error {
+	statement := `update guest set attendance = $1, email = $2, message = $3,
+		party_size = $4 where id = $5`
+	_, err := store.database.Exec(context.Background(), statement,
+		guest.Attendance, guest.Email, guest.Message, guest.PartySize, guest.ID)
+	return err
+}
+
+func (store Store) deleteOldParty(guestID int) error {
+	statement := "delete from party where guest_id = $1"
+	_, err := store.database.Exec(context.Background(), statement, guestID)
+	return err
+}
 
-	statement = "insert into party (guest_id, first_name, last_name) values ($1, $2, $3)"
+func (store Store) insertParty(guest Guest) error {
+	statement := `insert into party (guest_id, first_name, last_name)
+		values ($1, $2, $3)`
 	for _, pg := range guest.PartyList {
-		_, err = m.db.Exec(context.Background(), statement, guest.Id, pg.FirstName, pg.LastName)
+		_, err := store.database.Exec(context.Background(), statement, guest.ID,
+			pg.FirstName, pg.LastName)
 		if err != nil {
 			return err
 		}