b/henwen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Save responses in Store

Browse Source
This commit is contained in:
Brandon Dyck
2020-09-27 15:44:04 -06:00
parent cd261000fc
commit bc486fa976
3 changed files with 247 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
back/store.go
View File

@ -54,7 +54,7 @@ func NewMemoryStore(genString GenString) (*Store, error) {
pool: pool,
genString: genString,
}
log.Println("creating schema")
err = store.createSchema()
if err != nil {
defer pool.Close()
@ -84,13 +84,14 @@ const schema = `
id INTEGER PRIMARY KEY,
alpha_id TEXT NOT NULL,
event_id INTEGER NOT NULL,
guest_name TEXT NOT NULL,
UNIQUE (alpha_id),
FOREIGN KEY (event_id) REFERENCES event(id)
);
CREATE TABLE response_time (
response_id INTEGER PRIMARY KEY,
response_id INTEGER NOT NULL,
date DATE NOT NULL,
time INTEGER NOT NULL,
@ -103,7 +104,7 @@ const schema = `
BEGIN
SELECT
CASE
WHEN NEW.date BETWEEN event.earliest_date AND event.latest_date
WHEN NEW.date NOT BETWEEN event.earliest_date AND event.latest_date
THEN RAISE(ABORT, 'response date is out of range')
END
FROM response
@ -213,36 +214,58 @@ func (s *Store) GetEventMetadata(ctx context.Context, query GetEventMetadataQuer
return result, nil
}
type GetEventResponsesQuery struct {
type GetEventResponseSummaryQuery struct {
AlphaID string
}
type GetEventResponsesResult struct {
type GetEventResponseSummaryResult struct {
TotalResponses int
}
func (s *Store) GetEventResponses(ctx context.Context, query GetEventResponsesQuery) (GetEventResponsesResult, error) {
func (s *Store) GetEventResponseSummary(ctx context.Context, query GetEventResponseSummaryQuery) (GetEventResponseSummaryResult, error) {
conn := s.pool.Get(ctx)
defer s.pool.Put(conn)
var result GetEventResponsesResult
const dbQuery = `
var found bool
var eventID int
const eventIDQuery = `
SELECT id
FROM event
WHERE alpha_id = ?`
var err = sqlitex.Exec(conn, eventIDQuery,
func(stmt *sqlite.Stmt) error {
found = true
eventID = stmt.ColumnInt(0)
return nil
}, query.AlphaID)
if err != nil {
return GetEventResponseSummaryResult{}, err
}
if !found {
return GetEventResponseSummaryResult{}, errors.New("event not found")
}
var result GetEventResponseSummaryResult
const responseCountQuery = `
SELECT COUNT(*)
FROM response
JOIN event ON response.event_id = event.id
WHERE event.alpha_id = ?;`
err := sqlitex.Exec(conn, dbQuery,
WHERE event_id = ?;`
err = sqlitex.Exec(conn, responseCountQuery,
func(stmt *sqlite.Stmt) error {
result.TotalResponses = stmt.ColumnInt(0)
return nil
}, query.AlphaID)
// TODO return an error if the event does not exist?
return result, err
}, eventID)
if err != nil {
return GetEventResponseSummaryResult{}, err
}
return result, nil
}
type CreateEventResponseCommand struct {
EventAlphaID string
DateHours map[date.Date]int
GuestName string
DateHours map[date.Date]map[int]struct{}
}
type CreateEventResponseResult struct {
@ -258,22 +281,95 @@ func (s *Store) CreateEventResponse(ctx context.Context, cmd CreateEventResponse
defer sqlitex.Save(conn)(&err)
responseAlphaID, err := s.genString(responseAlphaIDLength)
if err != nil {
return CreateEventResponseResult{}, err
return
}
// Create response
const responseQuery = `
INSERT INTO response(event_id, alpha_id)
SELECT event.id AS event_id, ? AS alpha_id
INSERT INTO response(event_id, alpha_id, guest_name)
SELECT event.id AS event_id, ? AS alpha_id, ? as guest_name
FROM event
WHERE event.alpha_id = ?;`
err = sqlitex.Exec(conn, responseQuery, nil, responseAlphaID, cmd.EventAlphaID)
err = sqlitex.Exec(conn, responseQuery, nil, responseAlphaID, cmd.GuestName, cmd.EventAlphaID)
if err != nil {
return CreateEventResponseResult{}, err
return
}
const responseTimeQuery = `
INSERT INTO response_time(response_id, date, time)
SELECT response.id AS response_id, ? AS date, ? AS time
FROM response
WHERE response.alpha_id = ?;`
for d, hs := range cmd.DateHours {
for h := range hs {
err = sqlitex.Exec(conn, responseTimeQuery, nil, d.Format(dbDateLayout), h, responseAlphaID)
if err != nil {
return
}
}
}
// TODO Create response times
return CreateEventResponseResult{
ResponseAlphaID: responseAlphaID,
}, nil
}
type GetEventResponseQuery struct {
EventAlphaID string
ResponseAlphaID string
}
type GetEventResponseResult struct {
GuestName string
DateHours map[date.Date]map[int]struct{}
}
func (s *Store) GetEventResponse(ctx context.Context, query GetEventResponseQuery) (GetEventResponseResult, error) {
conn := s.pool.Get(ctx)
defer s.pool.Put(conn)
var found bool
var result GetEventResponseResult
var responseID int
const responseQuery = `
SELECT guest_name, response.id
FROM response
JOIN event ON response.event_id = event.id
WHERE response.alpha_id = ? AND event.alpha_id = ?;`
var err = sqlitex.Exec(conn, responseQuery,
func(stmt *sqlite.Stmt) error {
found = true
result.GuestName = stmt.ColumnText(0)
responseID = stmt.ColumnInt(1)
return nil
}, query.ResponseAlphaID, query.EventAlphaID)
if err != nil {
return GetEventResponseResult{}, err
}
if !found {
// TODO return a constant or typed error
return GetEventResponseResult{}, errors.New("not found")
}
result.DateHours = make(map[date.Date]map[int]struct{})
const responseTimeQuery = `
SELECT date, time
FROM response_time
WHERE response_id = ?`
err = sqlitex.Exec(conn, responseTimeQuery,
func(stmt *sqlite.Stmt) error {
d, err := date.Parse(dbDateLayout, stmt.ColumnText(0))
if err != nil {
return err
}
if result.DateHours[d] == nil {
result.DateHours[d] = make(map[int]struct{})
}
result.DateHours[d][stmt.ColumnInt(1)] = struct{}{}
return nil
}, responseID)
if err != nil {
return GetEventResponseResult{}, err
}
return result, nil
}

76
back/store_test.go
View File

@ -45,9 +45,10 @@ func TestCreateEvent(t *testing.T) {
is.True(metadataResult.Latest.Equal(latest))
}
func TestGetEventResponses(t *testing.T) {
func TestGetEventResponseSummary(t *testing.T) {
store, err := back.NewMemoryStore(back.SecureGenString)
is.New(t).NoErr(err)
defer store.Close()
createEvent := func(is *is.I) (eventID string) {
event, err := store.CreateEvent(context.Background(), back.CreateEventCommand{
@ -61,7 +62,7 @@ func TestGetEventResponses(t *testing.T) {
}
getTotalResponses := func(is *is.I, eventID string) int {
responses, err := store.GetEventResponses(context.Background(), back.GetEventResponsesQuery{
responses, err := store.GetEventResponseSummary(context.Background(), back.GetEventResponseSummaryQuery{
AlphaID: eventID,
})
is.NoErr(err)
@ -99,3 +100,74 @@ func TestGetEventResponses(t *testing.T) {
is.Equal(getTotalResponses(is, eventID), 1)
})
}
func pending(t *testing.T) {
t.Fatalf("pending")
}
func TestCreateEventResponse(t *testing.T) {
store, err := back.NewMemoryStore(back.SecureGenString)
is.New(t).NoErr(err)
createEvent := func(is *is.I) (eventID string) {
event, err := store.CreateEvent(context.Background(), back.CreateEventCommand{
Name: "blah",
Description: "stuff happening",
Earliest: date.Today(),
Latest: date.Today().Add(1),
})
is.NoErr(err)
return event.AlphaID
}
t.Run("saves GuestName", func(t *testing.T) {
is := is.New(t)
eventID := createEvent(is)
const guestName = "Etaoin Shrdlu"
createResult, err := store.CreateEventResponse(context.Background(), back.CreateEventResponseCommand{
EventAlphaID: eventID,
GuestName: guestName,
})
is.NoErr(err)
getResult, err := store.GetEventResponse(context.Background(), back.GetEventResponseQuery{
EventAlphaID: eventID,
ResponseAlphaID: createResult.ResponseAlphaID,
})
is.NoErr(err)
is.Equal(getResult.GuestName, guestName)
})
t.Run("DateHours saves multiple times on multiple dates", func(t *testing.T) {
is := is.New(t)
earliest := date.Today()
latest := earliest.Add(1)
event, err := store.CreateEvent(context.Background(), back.CreateEventCommand{
Name: "blah",
Description: "stuff happening",
Earliest: earliest,
Latest: latest,
})
is.NoErr(err)
var dateHours = map[date.Date]map[int]struct{}{
earliest: {1: {}, 3: {}, 5: {}, 7: {}},
latest: {2: {}, 4: {}, 6: {}},
}
createResponseResult, err := store.CreateEventResponse(context.Background(), back.CreateEventResponseCommand{
EventAlphaID: event.AlphaID,
GuestName: "Etaoin Shrdlu",
DateHours: dateHours,
})
is.NoErr(err)
response, err := store.GetEventResponse(context.Background(), back.GetEventResponseQuery{
EventAlphaID: event.AlphaID,
ResponseAlphaID: createResponseResult.ResponseAlphaID,
})
is.NoErr(err)
is.Equal(dateHours, response.DateHours)
})
}