forked from tildetown/town
362 lines
8.7 KiB
Go
362 lines
8.7 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"math/rand"
|
|
"os"
|
|
"os/user"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.tilde.town/tildetown/town/invites"
|
|
"git.tilde.town/tildetown/town/models"
|
|
"git.tilde.town/tildetown/town/signup"
|
|
tuser "git.tilde.town/tildetown/town/user"
|
|
"github.com/gdamore/tcell/v2"
|
|
"github.com/rivo/tview"
|
|
)
|
|
|
|
func getTitle() string {
|
|
titles := []string{
|
|
"yo bum rush the show",
|
|
"can i kick it?",
|
|
"super nintendo sega genesis",
|
|
"birthdays was the worst days",
|
|
"where were you when we were getting high?",
|
|
"it's real time, real time, time to get real",
|
|
}
|
|
return titles[rand.Intn(len(titles))]
|
|
}
|
|
|
|
type reviewer struct {
|
|
db *sql.DB
|
|
adminName string
|
|
}
|
|
|
|
func newReviewer(db *sql.DB, adminName string) *reviewer {
|
|
return &reviewer{db: db, adminName: adminName}
|
|
}
|
|
|
|
func (r *reviewer) Review(s *models.TownSignup, decision models.SignupDecision) error {
|
|
s.DecisionTime = time.Now()
|
|
s.Decision = decision
|
|
s.DecidedBy = r.adminName
|
|
return s.Review(r.db)
|
|
}
|
|
|
|
func (r *reviewer) AddNote(s *models.TownSignup, content string) error {
|
|
note := &models.SignupNote{
|
|
Author: r.adminName,
|
|
Content: content,
|
|
SignupID: s.ID,
|
|
}
|
|
|
|
return note.Insert(r.db)
|
|
}
|
|
|
|
func renderSignup(s models.TownSignup) string {
|
|
out := ""
|
|
|
|
pairs := [][]string{
|
|
{"submitted", s.Created.Format("2006-01-02 15:04")},
|
|
{"e-mail", s.Email},
|
|
{"how found / referral", s.How},
|
|
{"why like town / plans", s.Why},
|
|
{"links", s.Links},
|
|
}
|
|
|
|
for _, v := range pairs {
|
|
out += fmt.Sprintf("[-:-:b]%s[-:-:-]\n", v[0])
|
|
out += strings.TrimSpace(v[1])
|
|
out += "\n\n"
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
func renderNotes(s models.TownSignup) string {
|
|
out := ""
|
|
for _, note := range s.Notes {
|
|
out += fmt.Sprintf(`%s said on %s:
|
|
%s`, note.Author, note.Created.Format("2006-01-02 15:04"), note.Content)
|
|
|
|
out += "\n\n"
|
|
|
|
}
|
|
return out
|
|
}
|
|
|
|
func _main() error {
|
|
inviteDB, err := invites.ConnectDB()
|
|
if err != nil {
|
|
return fmt.Errorf("could not connect to invites database: %w", err)
|
|
}
|
|
|
|
signupDB, err := signup.ConnectDB()
|
|
if err != nil {
|
|
return fmt.Errorf("could not connect to signups database: %w", err)
|
|
}
|
|
|
|
u, err := user.Current()
|
|
if err != nil {
|
|
return fmt.Errorf("that's my purse. I don't know you! %w", err)
|
|
}
|
|
isAdmin, err := tuser.IsAdmin(u)
|
|
if err != nil {
|
|
return fmt.Errorf("that's my purse. I don't know you! %w", err)
|
|
}
|
|
|
|
if !isAdmin {
|
|
return errors.New("this command can only be run by a town admin")
|
|
}
|
|
|
|
r := newReviewer(signupDB, u.Username)
|
|
|
|
rand.Seed(time.Now().Unix())
|
|
|
|
su := models.TownSignup{}
|
|
|
|
signups, err := su.All(signupDB)
|
|
if err != nil {
|
|
return fmt.Errorf("could not fetch signups: %w", err)
|
|
}
|
|
|
|
signupIx := 0
|
|
|
|
title := tview.NewTextView()
|
|
title.SetText(getTitle())
|
|
title.SetTextAlign(tview.AlignCenter)
|
|
title.SetTextColor(tcell.ColorPurple)
|
|
title.SetBackgroundColor(tcell.ColorBlack)
|
|
|
|
appView := tview.NewTextView()
|
|
appView.SetDynamicColors(true)
|
|
|
|
legend := tview.NewTextView()
|
|
legend.SetText("s: skip r: random A: approve R: reject N: notate Q: quit")
|
|
legend.SetTextColor(tcell.ColorPurple)
|
|
legend.SetTextAlign(tview.AlignCenter)
|
|
legend.SetBackgroundColor(tcell.ColorBlack)
|
|
|
|
count := tview.NewTextView()
|
|
count.SetDynamicColors(true)
|
|
updateCount := func() {
|
|
count.SetText(fmt.Sprintf("[-:-:b]%d of %d[-:-:-]", signupIx+1, len(signups)))
|
|
if len(signups) == 0 {
|
|
count.SetText("")
|
|
}
|
|
}
|
|
updateCount()
|
|
|
|
notesView := tview.NewTextView()
|
|
notesView.SetDynamicColors(true)
|
|
notesView.SetBorder(true).SetBorderColor(tcell.ColorPurple)
|
|
|
|
bottomFlex := tview.NewFlex()
|
|
bottomFlex.SetDirection(tview.FlexColumn)
|
|
bottomFlex.AddItem(count, 0, 1, false)
|
|
bottomFlex.AddItem(legend, 0, 10, false)
|
|
|
|
innerFlex := tview.NewFlex()
|
|
innerFlex.SetDirection(tview.FlexColumn)
|
|
innerFlex.AddItem(appView, 0, 2, true)
|
|
innerFlex.AddItem(notesView, 0, 1, true)
|
|
|
|
mainFlex := tview.NewFlex()
|
|
mainFlex.SetDirection(tview.FlexRow)
|
|
mainFlex.AddItem(title, 1, -1, false)
|
|
mainFlex.AddItem(innerFlex, 0, 1, false)
|
|
mainFlex.AddItem(bottomFlex, 1, -1, false)
|
|
|
|
pages := tview.NewPages()
|
|
|
|
errorModal := tview.NewModal()
|
|
errorModal.AddButtons([]string{"damn"})
|
|
errorModal.SetDoneFunc(func(ix int, _ string) {
|
|
pages.SwitchToPage("main")
|
|
})
|
|
|
|
render := func() {
|
|
if len(signups) == 0 {
|
|
appView.SetText("no signups")
|
|
return
|
|
}
|
|
currSignup := signups[signupIx]
|
|
err := currSignup.RefreshNotes(signupDB)
|
|
if err != nil {
|
|
errorModal.SetText(fmt.Sprintf("error! failed to add note: %s", err.Error()))
|
|
pages.SwitchToPage("error")
|
|
}
|
|
|
|
appView.SetText(renderSignup(*currSignup))
|
|
notesView.SetText(renderNotes(*currSignup))
|
|
}
|
|
|
|
render()
|
|
|
|
notate := tview.NewForm()
|
|
notate.AddTextArea("note", "", 80, 10, 1000, func(string) {})
|
|
notate.AddButton("submit", func() {
|
|
fi := notate.GetFormItemByLabel("note").(*tview.TextArea)
|
|
err = r.AddNote(signups[signupIx], fi.GetText())
|
|
if err != nil {
|
|
errorModal.SetText(fmt.Sprintf("error! failed to add note: %s", err.Error()))
|
|
pages.SwitchToPage("error")
|
|
return
|
|
}
|
|
|
|
render()
|
|
|
|
pages.SwitchToPage("main")
|
|
})
|
|
notate.AddButton("cancel", func() {
|
|
pages.SwitchToPage("main")
|
|
})
|
|
|
|
reviewModal := tview.NewFlex().SetDirection(tview.FlexRow)
|
|
|
|
providedEmailView := tview.NewTextView()
|
|
providedEmailView.SetTitle("provided email input")
|
|
|
|
reviewForm := tview.NewForm()
|
|
decisionFI := tview.NewDropDown().SetLabel("decision")
|
|
decisionFI.SetOptions([]string{"accepted", "rejected"}, func(_ string, _ int) {})
|
|
|
|
cleanEmailInput := tview.NewInputField()
|
|
cleanEmailInput.SetLabel("clean email")
|
|
cleanEmailInput.SetAcceptanceFunc(func(tx string, _ rune) bool { return len(tx) > 0 })
|
|
|
|
reviewForm.AddFormItem(decisionFI)
|
|
reviewForm.AddFormItem(cleanEmailInput)
|
|
reviewForm.AddButton("submit", func() {
|
|
currSignup := signups[signupIx]
|
|
cleanEmail := reviewForm.GetFormItemByLabel("clean email").(*tview.InputField).GetText()
|
|
currSignup.CleanEmail = cleanEmail
|
|
|
|
decision := models.SignupRejected
|
|
_, d := reviewForm.GetFormItemByLabel("decision").(*tview.DropDown).GetCurrentOption()
|
|
if d == "accepted" {
|
|
decision = models.SignupAccepted
|
|
}
|
|
|
|
err := r.Review(currSignup, decision)
|
|
if err != nil {
|
|
errorModal.SetText(fmt.Sprintf("error! failed to submit review: %s", err.Error()))
|
|
pages.SwitchToPage("error")
|
|
return
|
|
}
|
|
|
|
newSignups := []*models.TownSignup{}
|
|
for ix, s := range signups {
|
|
if ix != signupIx {
|
|
newSignups = append(newSignups, s)
|
|
}
|
|
}
|
|
signups = newSignups
|
|
if len(signups) > 0 {
|
|
if signupIx >= len(signups) {
|
|
signupIx = 0
|
|
}
|
|
}
|
|
updateCount()
|
|
render()
|
|
if decision == models.SignupAccepted {
|
|
invite := &invites.Invite{
|
|
Email: currSignup.CleanEmail,
|
|
}
|
|
|
|
if err = invite.Insert(inviteDB); err != nil {
|
|
errorModal.SetText(fmt.Sprintf("error! failed to create invite: %s", err.Error()))
|
|
pages.SwitchToPage("error")
|
|
}
|
|
|
|
if err = sendInviteEmail(*invite); err != nil {
|
|
errorModal.SetText(fmt.Sprintf("error! failed to send welcome email: %s", err.Error()))
|
|
pages.SwitchToPage("error")
|
|
}
|
|
}
|
|
pages.SwitchToPage("main")
|
|
})
|
|
reviewForm.AddButton("cancel", func() {
|
|
pages.SwitchToPage("main")
|
|
})
|
|
|
|
reviewModal.AddItem(tview.NewTextView().SetText("provided email input"), 1, 1, false)
|
|
reviewModal.AddItem(providedEmailView, 0, 1, false)
|
|
reviewModal.AddItem(reviewForm, 0, 1, true)
|
|
|
|
pages.AddPage("main", mainFlex, true, true)
|
|
pages.AddPage("error", errorModal, false, false)
|
|
pages.AddPage("notate", notate, true, false)
|
|
pages.AddPage("review", reviewModal, true, false)
|
|
|
|
app := tview.NewApplication()
|
|
app.SetRoot(pages, true)
|
|
|
|
app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
|
|
currPage, _ := pages.GetFrontPage()
|
|
if currPage == "notate" || currPage == "review" {
|
|
return event
|
|
}
|
|
switch event.Rune() {
|
|
case 's':
|
|
signupIx++
|
|
if signupIx == len(signups) {
|
|
signupIx = 0
|
|
}
|
|
render()
|
|
case 'r':
|
|
if len(signups) > 0 {
|
|
signupIx = rand.Intn(len(signups))
|
|
render()
|
|
}
|
|
case 'A':
|
|
if len(signups) == 0 {
|
|
return nil
|
|
}
|
|
emailVal := signups[signupIx].Email
|
|
providedEmailView.SetText(emailVal)
|
|
cleanEmailInput.SetPlaceholder(
|
|
strings.TrimSpace(strings.ReplaceAll(emailVal, "\n", " ")))
|
|
decisionFI.SetCurrentOption(0)
|
|
pages.SwitchToPage("review")
|
|
app.SetFocus(cleanEmailInput)
|
|
return nil
|
|
case 'R':
|
|
if len(signups) == 0 {
|
|
return nil
|
|
}
|
|
emailVal := signups[signupIx].Email
|
|
providedEmailView.SetText(emailVal)
|
|
cleanEmailInput.SetPlaceholder(
|
|
strings.TrimSpace(strings.ReplaceAll(emailVal, "\n", " ")))
|
|
decisionFI.SetCurrentOption(1)
|
|
pages.SwitchToPage("review")
|
|
app.SetFocus(cleanEmailInput)
|
|
return nil
|
|
case 'N':
|
|
if len(signups) == 0 {
|
|
return nil
|
|
}
|
|
pages.SwitchToPage("notate")
|
|
return nil
|
|
case 'Q':
|
|
app.Stop()
|
|
}
|
|
|
|
return event
|
|
})
|
|
|
|
return app.Run()
|
|
}
|
|
|
|
func main() {
|
|
err := _main()
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
}
|