mirror of
https://github.com/riwiwa/muzi.git
synced 2026-02-28 11:56:57 -08:00
388 lines
9.8 KiB
Go
388 lines
9.8 KiB
Go
package web
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"html/template"
|
|
"net/http"
|
|
"os"
|
|
"strconv"
|
|
|
|
"muzi/db"
|
|
|
|
"golang.org/x/crypto/bcrypt"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-chi/chi/v5/middleware"
|
|
"github.com/jackc/pgtype"
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
type ProfileData struct {
|
|
Username string
|
|
Bio string
|
|
Pfp string
|
|
AllowDuplicateEdits bool
|
|
ScrobbleCount int
|
|
ArtistCount int
|
|
Artists []string
|
|
Titles []string
|
|
Times []string
|
|
Page int
|
|
}
|
|
|
|
func Sub(a int, b int) int {
|
|
return a - b
|
|
}
|
|
|
|
func Add(a int, b int) int {
|
|
return a + b
|
|
}
|
|
|
|
func getUserIdByUsername(conn *pgx.Conn, username string) (int, error) {
|
|
var userId int
|
|
err := conn.QueryRow(context.Background(), "SELECT pk FROM users WHERE username = $1;", username).
|
|
Scan(&userId)
|
|
return userId, err
|
|
}
|
|
|
|
func getTimes(conn *pgx.Conn, userId int, lim int, off int) []string {
|
|
var times []string
|
|
rows, err := conn.Query(
|
|
context.Background(),
|
|
"SELECT timestamp FROM history WHERE user_id = $1 ORDER BY timestamp DESC LIMIT $2 OFFSET $3;",
|
|
userId,
|
|
lim,
|
|
off,
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "SELECT timestamp failed: %v\n", err)
|
|
return nil
|
|
}
|
|
for rows.Next() {
|
|
var time pgtype.Timestamptz
|
|
err = rows.Scan(&time)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Scanning time failed: %v\n", err)
|
|
return nil
|
|
}
|
|
times = append(times, time.Time.String())
|
|
}
|
|
return times
|
|
}
|
|
|
|
func getTitles(conn *pgx.Conn, userId int, lim int, off int) []string {
|
|
var titles []string
|
|
rows, err := conn.Query(
|
|
context.Background(),
|
|
"SELECT song_name FROM history WHERE user_id = $1 ORDER BY timestamp DESC LIMIT $2 OFFSET $3;",
|
|
userId,
|
|
lim,
|
|
off,
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "SELECT song_name failed: %v\n", err)
|
|
return nil
|
|
}
|
|
for rows.Next() {
|
|
var title string
|
|
err = rows.Scan(&title)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Scanning title failed: %v\n", err)
|
|
return nil
|
|
}
|
|
titles = append(titles, title)
|
|
}
|
|
return titles
|
|
}
|
|
|
|
func getArtists(conn *pgx.Conn, userId int, lim int, off int) []string {
|
|
var artists []string
|
|
rows, err := conn.Query(
|
|
context.Background(),
|
|
"SELECT artist FROM history WHERE user_id = $1 ORDER BY timestamp DESC LIMIT $2 OFFSET $3;",
|
|
userId,
|
|
lim,
|
|
off,
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "SELECT artist failed: %v\n", err)
|
|
return nil
|
|
}
|
|
for rows.Next() {
|
|
var artist string
|
|
err = rows.Scan(&artist)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Scanning artist name failed: %v\n", err)
|
|
return nil
|
|
}
|
|
artists = append(artists, artist)
|
|
}
|
|
return artists
|
|
}
|
|
|
|
func getScrobbles(conn *pgx.Conn, userId int) int {
|
|
var count int
|
|
err := conn.QueryRow(context.Background(), "SELECT COUNT(*) FROM history WHERE user_id = $1;", userId).
|
|
Scan(&count)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "SELECT COUNT failed: %v\n", err)
|
|
return 0
|
|
}
|
|
return count
|
|
}
|
|
|
|
func getArtistCount(conn *pgx.Conn, userId int) int {
|
|
var count int
|
|
err := conn.QueryRow(context.Background(), "SELECT COUNT(DISTINCT artist) FROM history WHERE user_id = $1;", userId).
|
|
Scan(&count)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "SELECT artist count failed: %v\n", err)
|
|
return 0
|
|
}
|
|
return count
|
|
}
|
|
|
|
func hashPassword(pass []byte) string {
|
|
hashedPassword, err := bcrypt.GenerateFromPassword(pass, bcrypt.DefaultCost)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Couldn't hash password: %v\n", err)
|
|
}
|
|
return string(hashedPassword)
|
|
}
|
|
|
|
func verifyPassword(hashedPassword string, enteredPassword []byte) bool {
|
|
err := bcrypt.CompareHashAndPassword([]byte(hashedPassword), enteredPassword)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error while comparing passwords: %v\n", err)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func createAccount(w http.ResponseWriter, r *http.Request) {
|
|
conn, err := pgx.Connect(
|
|
context.Background(),
|
|
"postgres://postgres:postgres@localhost:5432/muzi",
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot connect to muzi database: %v\n", err)
|
|
return
|
|
}
|
|
defer conn.Close(context.Background())
|
|
|
|
if r.Method == "POST" {
|
|
r.ParseForm()
|
|
|
|
username := r.FormValue("uname")
|
|
hashedPassword := hashPassword([]byte(r.FormValue("pass")))
|
|
|
|
err = db.CreateUsersTable(conn)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error ensuring users table exists: %v\n", err)
|
|
http.Redirect(w, r, "/createaccount", http.StatusSeeOther)
|
|
return
|
|
}
|
|
|
|
_, err = conn.Exec(
|
|
context.Background(),
|
|
`INSERT INTO users (username, password) VALUES ($1, $2);`,
|
|
username,
|
|
hashedPassword,
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot add new user to users table: %v\n", err)
|
|
http.Redirect(w, r, "/createaccount", http.StatusSeeOther)
|
|
} else {
|
|
http.Redirect(w, r, "/profile/"+username, http.StatusSeeOther)
|
|
}
|
|
}
|
|
}
|
|
|
|
func createAccountPageHandler() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
tmp, err := template.New("create_account.gohtml").
|
|
ParseFiles("./templates/create_account.gohtml")
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
err = tmp.Execute(w, nil)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func loginSubmit(w http.ResponseWriter, r *http.Request) {
|
|
conn, err := pgx.Connect(
|
|
context.Background(),
|
|
"postgres://postgres:postgres@localhost:5432/muzi",
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot connect to muzi database: %v\n", err)
|
|
return
|
|
}
|
|
defer conn.Close(context.Background())
|
|
|
|
if r.Method == "POST" {
|
|
r.ParseForm()
|
|
|
|
username := r.FormValue("uname")
|
|
password := r.FormValue("pass")
|
|
var storedPassword string
|
|
err := conn.QueryRow(context.Background(), "SELECT password FROM users WHERE username = $1;", username).
|
|
Scan(&storedPassword)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot get password for entered username: %v\n", err)
|
|
}
|
|
|
|
if verifyPassword(storedPassword, []byte(password)) {
|
|
http.Redirect(w, r, "/profile/"+username, http.StatusSeeOther)
|
|
} else {
|
|
http.Redirect(w, r, "/login?error=1", http.StatusSeeOther)
|
|
}
|
|
}
|
|
}
|
|
|
|
func loginPageHandler() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
type data struct {
|
|
ShowError bool
|
|
}
|
|
d := data{ShowError: false}
|
|
if r.URL.Query().Get("error") != "" {
|
|
d.ShowError = true
|
|
}
|
|
tmp, err := template.New("login.gohtml").ParseFiles("./templates/login.gohtml")
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
err = tmp.Execute(w, d)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func profilePageHandler() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
username := chi.URLParam(r, "username")
|
|
|
|
conn, err := pgx.Connect(
|
|
context.Background(),
|
|
"postgres://postgres:postgres@localhost:5432/muzi",
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot connect to muzi database: %v\n", err)
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer conn.Close(context.Background())
|
|
|
|
userId, err := getUserIdByUsername(conn, username)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot find user %s: %v\n", username, err)
|
|
http.Error(w, "User not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
pageStr := r.URL.Query().Get("page")
|
|
var pageInt int
|
|
if pageStr == "" {
|
|
pageInt = 1
|
|
} else {
|
|
pageInt, err = strconv.Atoi(pageStr)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot convert page URL query from string to int: %v\n", err)
|
|
pageInt = 1
|
|
}
|
|
}
|
|
|
|
lim := 15
|
|
off := (pageInt - 1) * lim
|
|
|
|
var profileData ProfileData
|
|
|
|
err = conn.QueryRow(
|
|
context.Background(),
|
|
"SELECT bio, pfp, allow_duplicate_edits FROM users WHERE pk = $1;",
|
|
userId,
|
|
).Scan(&profileData.Bio, &profileData.Pfp, &profileData.AllowDuplicateEdits)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot get profile for %s: %v\n", username, err)
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
profileData.Username = username
|
|
profileData.ScrobbleCount = getScrobbles(conn, userId)
|
|
profileData.ArtistCount = getArtistCount(conn, userId)
|
|
profileData.Artists = getArtists(conn, userId, lim, off)
|
|
profileData.Titles = getTitles(conn, userId, lim, off)
|
|
profileData.Times = getTimes(conn, userId, lim, off)
|
|
profileData.Page = pageInt
|
|
|
|
funcMap := template.FuncMap{
|
|
"Sub": Sub,
|
|
"Add": Add,
|
|
}
|
|
|
|
tmp, err := template.New("profile.gohtml").
|
|
Funcs(funcMap).
|
|
ParseFiles("./templates/profile.gohtml")
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
tmp.Execute(w, profileData)
|
|
}
|
|
}
|
|
|
|
func updateDuplicateEditsSetting(w http.ResponseWriter, r *http.Request) {
|
|
conn, err := pgx.Connect(
|
|
context.Background(),
|
|
"postgres://postgres:postgres@localhost:5432/muzi",
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Cannot connect to muzi database: %v\n", err)
|
|
return
|
|
}
|
|
defer conn.Close(context.Background())
|
|
|
|
if r.Method == "POST" {
|
|
r.ParseForm()
|
|
username := r.FormValue("username")
|
|
allow := r.FormValue("allow") == "true"
|
|
|
|
_, err = conn.Exec(
|
|
context.Background(),
|
|
`UPDATE users SET allow_duplicate_edits = $1 WHERE username = $2;`,
|
|
allow,
|
|
username,
|
|
)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error updating setting: %v\n", err)
|
|
}
|
|
http.Redirect(w, r, "/profile/"+username, http.StatusSeeOther)
|
|
}
|
|
}
|
|
|
|
func Start() {
|
|
addr := ":1234"
|
|
r := chi.NewRouter()
|
|
r.Use(middleware.Logger)
|
|
r.Handle("/files/*", http.StripPrefix("/files", http.FileServer(http.Dir("./static"))))
|
|
r.Get("/login", loginPageHandler())
|
|
r.Get("/createaccount", createAccountPageHandler())
|
|
r.Get("/profile/{username}", profilePageHandler())
|
|
r.Post("/loginsubmit", loginSubmit)
|
|
r.Post("/createaccountsubmit", createAccount)
|
|
r.Post("/settings/duplicate-edits", updateDuplicateEditsSetting)
|
|
fmt.Printf("WebUI starting on %s\n", addr)
|
|
http.ListenAndServe(addr, r)
|
|
}
|