h/projectreshoot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

migrated out more modules and refactored db system

Browse Source
This commit is contained in:
Haelnorr
2026-01-01 21:56:21 +11:00
parent 03095448d6
commit 1e09acdc57
80 changed files with 462 additions and 4992 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
internal/handler/account.go
View File

@@ -2,6 +2,7 @@ package handler
import (
"context"
"database/sql"
"net/http"
"time"
@@ -10,10 +11,10 @@ import (
"projectreshoot/internal/view/page"
"projectreshoot/pkg/contexts"
"projectreshoot/pkg/cookies"
"projectreshoot/pkg/db"
"git.haelnorr.com/h/golib/hlog"
"github.com/pkg/errors"
"github.com/rs/zerolog"
)
// Renders the account page on the 'General' subpage
@@ -44,8 +45,8 @@ func AccountSubpage() http.Handler {
// Handles a request to change the users username
func ChangeUsername(
logger *zerolog.Logger,
conn *db.SafeConn,
logger *hlog.Logger,
conn *sql.DB,
) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
@@ -53,7 +54,7 @@ func ChangeUsername(
defer cancel()
// Start the transaction
tx, err := conn.Begin(ctx)
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
logger.Warn().Err(err).Msg("Error updating username")
w.WriteHeader(http.StatusServiceUnavailable)
@@ -61,7 +62,7 @@ func ChangeUsername(
}
r.ParseForm()
newUsername := r.FormValue("username")
unique, err := models.CheckUsernameUnique(ctx, tx, newUsername)
unique, err := models.CheckUsernameUnique(tx, newUsername)
if err != nil {
tx.Rollback()
logger.Error().Err(err).Msg("Error updating username")
@@ -75,7 +76,7 @@ func ChangeUsername(
return
}
user := contexts.GetUser(r.Context())
err = user.ChangeUsername(ctx, tx, newUsername)
err = user.ChangeUsername(tx, newUsername)
if err != nil {
tx.Rollback()
logger.Error().Err(err).Msg("Error updating username")
@@ -90,8 +91,8 @@ func ChangeUsername(
// Handles a request to change the users bio
func ChangeBio(
logger *zerolog.Logger,
conn *db.SafeConn,
logger *hlog.Logger,
conn *sql.DB,
) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
@@ -99,7 +100,7 @@ func ChangeBio(
defer cancel()
// Start the transaction
tx, err := conn.Begin(ctx)
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
logger.Warn().Err(err).Msg("Error updating bio")
w.WriteHeader(http.StatusServiceUnavailable)
@@ -115,7 +116,7 @@ func ChangeBio(
return
}
user := contexts.GetUser(r.Context())
err = user.ChangeBio(ctx, tx, newBio)
err = user.ChangeBio(tx, newBio)
if err != nil {
tx.Rollback()
logger.Error().Err(err).Msg("Error updating bio")
@@ -144,8 +145,8 @@ func validateChangePassword(
// Handles a request to change the users password
func ChangePassword(
logger *zerolog.Logger,
conn *db.SafeConn,
logger *hlog.Logger,
conn *sql.DB,
) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
@@ -153,7 +154,7 @@ func ChangePassword(
defer cancel()
// Start the transaction
tx, err := conn.Begin(ctx)
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
logger.Warn().Err(err).Msg("Error updating password")
w.WriteHeader(http.StatusServiceUnavailable)
@@ -166,7 +167,7 @@ func ChangePassword(
return
}
user := contexts.GetUser(r.Context())
err = user.SetPassword(ctx, tx, newPass)
err = user.SetPassword(tx, newPass)
if err != nil {
tx.Rollback()
logger.Error().Err(err).Msg("Error updating password")

23
internal/handler/login.go
View File

@@ -2,6 +2,7 @@ package handler
import (
"context"
"database/sql"
"net/http"
"time"
@@ -10,27 +11,26 @@ import (
"projectreshoot/internal/view/page"
"projectreshoot/pkg/config"
"projectreshoot/pkg/cookies"
"projectreshoot/pkg/db"
"git.haelnorr.com/h/golib/hlog"
"git.haelnorr.com/h/golib/jwt"
"github.com/pkg/errors"
"github.com/rs/zerolog"
)
// Validates the username matches a user in the database and the password
// is correct. Returns the corresponding user
func validateLogin(
ctx context.Context,
tx db.SafeTX,
tx *sql.Tx,
r *http.Request,
) (*models.User, error) {
formUsername := r.FormValue("username")
formPassword := r.FormValue("password")
user, err := models.GetUserFromUsername(ctx, tx, formUsername)
user, err := models.GetUserFromUsername(tx, formUsername)
if err != nil {
return nil, errors.Wrap(err, "db.GetUserFromUsername")
}
err = user.CheckPassword(formPassword)
err = user.CheckPassword(tx, formPassword)
if err != nil {
return nil, errors.New("Username or password incorrect")
}
@@ -52,8 +52,9 @@ func checkRememberMe(r *http.Request) bool {
// template for user feedback
func LoginRequest(
config *config.Config,
logger *zerolog.Logger,
conn *db.SafeConn,
logger *hlog.Logger,
conn *sql.DB,
tokenGen *jwt.TokenGenerator,
) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
@@ -61,14 +62,14 @@ func LoginRequest(
defer cancel()
// Start the transaction
tx, err := conn.Begin(ctx)
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
logger.Warn().Err(err).Msg("Failed to set token cookies")
w.WriteHeader(http.StatusServiceUnavailable)
return
}
r.ParseForm()
user, err := validateLogin(ctx, tx, r)
user, err := validateLogin(tx, r)
if err != nil {
tx.Rollback()
if err.Error() != "Username or password incorrect" {
@@ -81,7 +82,7 @@ func LoginRequest(
}
rememberMe := checkRememberMe(r)
err = cookies.SetTokenCookies(w, r, config, user, true, rememberMe)
err = cookies.SetTokenCookies(w, r, config, tokenGen, user, true, rememberMe)
if err != nil {
tx.Rollback()
w.WriteHeader(http.StatusInternalServerError)

53
internal/handler/logout.go
View File

@@ -2,26 +2,25 @@ package handler
import (
"context"
"database/sql"
"net/http"
"strings"
"time"
"projectreshoot/pkg/config"
"projectreshoot/pkg/cookies"
"projectreshoot/pkg/db"
"projectreshoot/pkg/jwt"
"git.haelnorr.com/h/golib/hlog"
"git.haelnorr.com/h/golib/jwt"
"github.com/pkg/errors"
"github.com/rs/zerolog"
)
func revokeAccess(
config *config.Config,
ctx context.Context,
tx *db.SafeWTX,
tokenGen *jwt.TokenGenerator,
tx *sql.Tx,
atStr string,
) error {
aT, err := jwt.ParseAccessToken(config, ctx, tx, atStr)
aT, err := tokenGen.ValidateAccess(tx, atStr)
if err != nil {
if strings.Contains(err.Error(), "Token is expired") ||
strings.Contains(err.Error(), "Token has been revoked") {
@@ -29,7 +28,7 @@ func revokeAccess(
}
return errors.Wrap(err, "jwt.ParseAccessToken")
}
err = jwt.RevokeToken(ctx, tx, aT)
err = aT.Revoke(tx)
if err != nil {
return errors.Wrap(err, "jwt.RevokeToken")
}
@@ -37,12 +36,11 @@ func revokeAccess(
}
func revokeRefresh(
config *config.Config,
ctx context.Context,
tx *db.SafeWTX,
tokenGen *jwt.TokenGenerator,
tx *sql.Tx,
rtStr string,
) error {
rT, err := jwt.ParseRefreshToken(config, ctx, tx, rtStr)
rT, err := tokenGen.ValidateRefresh(tx, rtStr)
if err != nil {
if strings.Contains(err.Error(), "Token is expired") ||
strings.Contains(err.Error(), "Token has been revoked") {
@@ -50,7 +48,7 @@ func revokeRefresh(
}
return errors.Wrap(err, "jwt.ParseRefreshToken")
}
err = jwt.RevokeToken(ctx, tx, rT)
err = rT.Revoke(tx)
if err != nil {
return errors.Wrap(err, "jwt.RevokeToken")
}
@@ -59,20 +57,19 @@ func revokeRefresh(
// Retrieve and revoke the user's tokens
func revokeTokens(
config *config.Config,
ctx context.Context,
tx *db.SafeWTX,
tokenGen *jwt.TokenGenerator,
tx *sql.Tx,
r *http.Request,
) error {
// get the tokens from the cookies
atStr, rtStr := cookies.GetTokenStrings(r)
// revoke the refresh token first as the access token expires quicker
// only matters if there is an error revoking the tokens
err := revokeRefresh(config, ctx, tx, rtStr)
err := revokeRefresh(tokenGen, tx, rtStr)
if err != nil {
return errors.Wrap(err, "revokeRefresh")
}
err = revokeAccess(config, ctx, tx, atStr)
err = revokeAccess(tokenGen, tx, atStr)
if err != nil {
return errors.Wrap(err, "revokeAccess")
}
@@ -81,25 +78,25 @@ func revokeTokens(
// Handle a logout request
func Logout(
config *config.Config,
logger *zerolog.Logger,
conn *db.SafeConn,
conn *sql.DB,
tokenGen *jwt.TokenGenerator,
logger *hlog.Logger,
) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
defer cancel()
// Start the transaction
tx, err := conn.Begin(ctx)
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
logger.Warn().Err(err).Msg("Error occured on user logout")
w.WriteHeader(http.StatusServiceUnavailable)
logger.Error().Err(err).Msg("Failed to start database transaction")
w.WriteHeader(http.StatusInternalServerError)
return
}
err = revokeTokens(config, ctx, tx, r)
defer tx.Rollback()
err = revokeTokens(tokenGen, tx, r)
if err != nil {
tx.Rollback()
logger.Error().Err(err).Msg("Error occured on user logout")
w.WriteHeader(http.StatusInternalServerError)
return

6
internal/handler/movie.go
View File

@@ -4,14 +4,14 @@ import (
"net/http"
"projectreshoot/internal/view/page"
"projectreshoot/pkg/config"
"projectreshoot/pkg/tmdb"
"strconv"
"github.com/rs/zerolog"
"git.haelnorr.com/h/golib/hlog"
"git.haelnorr.com/h/golib/tmdb"
)
func Movie(
logger *zerolog.Logger,
logger *hlog.Logger,
config *config.Config,
) http.Handler {
return http.HandlerFunc(

6
internal/handler/movie_search.go
View File

@@ -5,13 +5,13 @@ import (
"projectreshoot/internal/view/component/search"
"projectreshoot/internal/view/page"
"projectreshoot/pkg/config"
"projectreshoot/pkg/tmdb"
"github.com/rs/zerolog"
"git.haelnorr.com/h/golib/hlog"
"git.haelnorr.com/h/golib/tmdb"
)
func SearchMovies(
logger *zerolog.Logger,
logger *hlog.Logger,
config *config.Config,
) http.Handler {
return http.HandlerFunc(

62
internal/handler/reauthenticatate.go
View File

@@ -2,6 +2,7 @@ package handler
import (
"context"
"database/sql"
"net/http"
"time"
@@ -9,47 +10,45 @@ import (
"projectreshoot/pkg/config"
"projectreshoot/pkg/contexts"
"projectreshoot/pkg/cookies"
"projectreshoot/pkg/db"
"projectreshoot/pkg/jwt"
"git.haelnorr.com/h/golib/hlog"
"git.haelnorr.com/h/golib/jwt"
"github.com/pkg/errors"
"github.com/rs/zerolog"
)
// Get the tokens from the request
func getTokens(
config *config.Config,
ctx context.Context,
tx db.SafeTX,
tokenGen *jwt.TokenGenerator,
tx *sql.Tx,
r *http.Request,
) (*jwt.AccessToken, *jwt.RefreshToken, error) {
// get the existing tokens from the cookies
atStr, rtStr := cookies.GetTokenStrings(r)
aT, err := jwt.ParseAccessToken(config, ctx, tx, atStr)
aT, err := tokenGen.ValidateAccess(tx, atStr)
if err != nil {
return nil, nil, errors.Wrap(err, "jwt.ParseAccessToken")
return nil, nil, errors.Wrap(err, "tokenGen.ValidateAccess")
}
rT, err := jwt.ParseRefreshToken(config, ctx, tx, rtStr)
rT, err := tokenGen.ValidateRefresh(tx, rtStr)
if err != nil {
return nil, nil, errors.Wrap(err, "jwt.ParseRefreshToken")
return nil, nil, errors.Wrap(err, "tokenGen.ValidateRefresh")
}
return aT, rT, nil
}
// Revoke the given token pair
func revokeTokenPair(
ctx context.Context,
tx *db.SafeWTX,
tx *sql.Tx,
aT *jwt.AccessToken,
rT *jwt.RefreshToken,
) error {
err := jwt.RevokeToken(ctx, tx, aT)
err := aT.Revoke(tx)
if err != nil {
return errors.Wrap(err, "jwt.RevokeToken")
return errors.Wrap(err, "aT.Revoke")
}
err = jwt.RevokeToken(ctx, tx, rT)
err = rT.Revoke(tx)
if err != nil {
return errors.Wrap(err, "jwt.RevokeToken")
return errors.Wrap(err, "rT.Revoke")
}
return nil
}
@@ -57,12 +56,12 @@ func revokeTokenPair(
// Issue new tokens for the user, invalidating the old ones
func refreshTokens(
config *config.Config,
ctx context.Context,
tx *db.SafeWTX,
tokenGen *jwt.TokenGenerator,
tx *sql.Tx,
w http.ResponseWriter,
r *http.Request,
) error {
aT, rT, err := getTokens(config, ctx, tx, r)
aT, rT, err := getTokens(tokenGen, tx, r)
if err != nil {
return errors.Wrap(err, "getTokens")
}
@@ -72,11 +71,11 @@ func refreshTokens(
}[aT.TTL]
// issue new tokens for the user
user := contexts.GetUser(r.Context())
err = cookies.SetTokenCookies(w, r, config, user.User, true, rememberMe)
err = cookies.SetTokenCookies(w, r, config, tokenGen, user.User, true, rememberMe)
if err != nil {
return errors.Wrap(err, "cookies.SetTokenCookies")
}
err = revokeTokenPair(ctx, tx, aT, rT)
err = revokeTokenPair(tx, aT, rT)
if err != nil {
return errors.Wrap(err, "revokeTokenPair")
}
@@ -86,12 +85,13 @@ func refreshTokens(
// Validate the provided password
func validatePassword(
tx *sql.Tx,
r *http.Request,
) error {
r.ParseForm()
password := r.FormValue("password")
user := contexts.GetUser(r.Context())
err := user.CheckPassword(password)
err := user.CheckPassword(tx, password)
if err != nil {
return errors.Wrap(err, "user.CheckPassword")
}
@@ -100,9 +100,10 @@ func validatePassword(
// Handle request to reauthenticate (i.e. make token fresh again)
func Reauthenticate(
logger *zerolog.Logger,
logger *hlog.Logger,
config *config.Config,
conn *db.SafeConn,
conn *sql.DB,
tokenGen *jwt.TokenGenerator,
) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
@@ -110,22 +111,21 @@ func Reauthenticate(
defer cancel()
// Start the transaction
tx, err := conn.Begin(ctx)
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
logger.Warn().Err(err).Msg("Failed to refresh user tokens")
w.WriteHeader(http.StatusServiceUnavailable)
logger.Error().Err(err).Msg("Failed to start transaction")
w.WriteHeader(http.StatusInternalServerError)
return
}
err = validatePassword(r)
defer tx.Rollback()
err = validatePassword(tx, r)
if err != nil {
tx.Rollback()
w.WriteHeader(445)
form.ConfirmPassword("Incorrect password").Render(r.Context(), w)
return
}
err = refreshTokens(config, ctx, tx, w, r)
err = refreshTokens(config, tokenGen, tx, w, r)
if err != nil {
tx.Rollback()
logger.Error().Err(err).Msg("Failed to refresh user tokens")
w.WriteHeader(http.StatusInternalServerError)
return

28
internal/handler/register.go
View File

@@ -2,6 +2,7 @@ package handler
import (
"context"
"database/sql"
"net/http"
"time"
@@ -10,23 +11,23 @@ import (
"projectreshoot/internal/view/page"
"projectreshoot/pkg/config"
"projectreshoot/pkg/cookies"
"projectreshoot/pkg/db"
"git.haelnorr.com/h/golib/hlog"
"git.haelnorr.com/h/golib/jwt"
"github.com/pkg/errors"
"github.com/rs/zerolog"
)
func validateRegistration(
ctx context.Context,
tx *db.SafeWTX,
tx *sql.Tx,
r *http.Request,
) (*models.User, error) {
formUsername := r.FormValue("username")
formPassword := r.FormValue("password")
formConfirmPassword := r.FormValue("confirm-password")
unique, err := models.CheckUsernameUnique(ctx, tx, formUsername)
unique, err := models.CheckUsernameUnique(tx, formUsername)
if err != nil {
return nil, errors.Wrap(err, "db.CheckUsernameUnique")
return nil, errors.Wrap(err, "models.CheckUsernameUnique")
}
if !unique {
return nil, errors.New("Username is taken")
@@ -37,9 +38,9 @@ func validateRegistration(
if len(formPassword) > 72 {
return nil, errors.New("Password exceeds maximum length of 72 bytes")
}
user, err := models.CreateNewUser(ctx, tx, formUsername, formPassword)
user, err := models.CreateNewUser(tx, formUsername, formPassword)
if err != nil {
return nil, errors.Wrap(err, "db.CreateNewUser")
return nil, errors.Wrap(err, "models.CreateNewUser")
}
return user, nil
@@ -47,8 +48,9 @@ func validateRegistration(
func RegisterRequest(
config *config.Config,
logger *zerolog.Logger,
conn *db.SafeConn,
tokenGen *jwt.TokenGenerator,
logger *hlog.Logger,
conn *sql.DB,
) http.Handler {
return http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
@@ -56,14 +58,14 @@ func RegisterRequest(
defer cancel()
// Start the transaction
tx, err := conn.Begin(ctx)
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
logger.Warn().Err(err).Msg("Failed to set token cookies")
w.WriteHeader(http.StatusServiceUnavailable)
return
}
r.ParseForm()
user, err := validateRegistration(ctx, tx, r)
user, err := validateRegistration(tx, r)
if err != nil {
tx.Rollback()
if err.Error() != "Username is taken" &&
@@ -78,7 +80,7 @@ func RegisterRequest(
}
rememberMe := checkRememberMe(r)
err = cookies.SetTokenCookies(w, r, config, user, true, rememberMe)
err = cookies.SetTokenCookies(w, r, config, tokenGen, user, true, rememberMe)
if err != nil {
tx.Rollback()
w.WriteHeader(http.StatusInternalServerError)