mirror of
https://github.com/stashapp/stash.git
synced 2025-12-06 08:26:00 +01:00
c6f6205e4f
* Replace error assertions with Go 1.13 style
Use `errors.As(..)` over type assertions. This enables better use of
wrapped errors in the future, and lets us pass some errorlint checks
in the process.
The rewrite is entirely mechanical, and uses a standard idiom for
doing so.
* Use Go 1.13's errors.Is(..)
Rather than directly checking for error equality, use errors.Is(..).
This protects against error wrapping issues in the future.
Even though something like sql.ErrNoRows doesn't need the wrapping, do
so anyway, for the sake of consistency throughout the code base.
The change almost lets us pass the `errorlint` Go checker except for
a missing case in `js.go` which is to be handled separately; it isn't
mechanical, like these changes are.
* Remove goconst
goconst isn't a useful linter in many cases, because it's false positive
rate is high. It's 100% for the current code base.
* Avoid direct comparison of errors in recover()
Assert that we are catching an error from recover(). If we are,
check that the error caught matches errStop.
* Enable the "errorlint" checker
Configure the checker to avoid checking for errorf wraps. These are
often false positives since the suggestion is to blanket wrap errors
with %w, and that exposes the underlying API which you might not want
to do.
The other warnings are good however, and with the current patch stack,
the code base passes all these checks as well.
* Configure rowserrcheck
The project uses sqlx. Configure rowserrcheck to include said package.
* Mechanically rewrite a large set of errors
Mechanically search for errors that look like
fmt.Errorf("...%s", err.Error())
and rewrite those into
fmt.Errorf("...%v", err)
The `fmt` package is error-aware and knows how to call err.Error()
itself.
The rationale is that this is more idiomatic Go; it paves the
way for using error wrapping later with %w in some sites.
This patch only addresses the entirely mechanical rewriting caught by
a project-side search/replace. There are more individual sites not
addressed by this patch.
89 lines
2.2 KiB
Go
89 lines
2.2 KiB
Go
package api
|
|
|
|
import (
|
|
"embed"
|
|
"errors"
|
|
"fmt"
|
|
"html/template"
|
|
"net/http"
|
|
|
|
"github.com/stashapp/stash/pkg/manager"
|
|
"github.com/stashapp/stash/pkg/manager/config"
|
|
"github.com/stashapp/stash/pkg/session"
|
|
)
|
|
|
|
const loginRootDir = "ui/login"
|
|
const returnURLParam = "returnURL"
|
|
|
|
func getLoginPage(loginUIBox embed.FS) []byte {
|
|
data, err := loginUIBox.ReadFile(loginRootDir + "/login.html")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return data
|
|
}
|
|
|
|
type loginTemplateData struct {
|
|
URL string
|
|
Error string
|
|
}
|
|
|
|
func redirectToLogin(loginUIBox embed.FS, w http.ResponseWriter, returnURL string, loginError string) {
|
|
data := getLoginPage(loginUIBox)
|
|
templ, err := template.New("Login").Parse(string(data))
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("error: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
err = templ.Execute(w, loginTemplateData{URL: returnURL, Error: loginError})
|
|
if err != nil {
|
|
http.Error(w, fmt.Sprintf("error: %s", err), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func getLoginHandler(loginUIBox embed.FS) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if !config.GetInstance().HasCredentials() {
|
|
http.Redirect(w, r, "/", http.StatusFound)
|
|
return
|
|
}
|
|
|
|
redirectToLogin(loginUIBox, w, r.URL.Query().Get(returnURLParam), "")
|
|
}
|
|
}
|
|
|
|
func handleLogin(loginUIBox embed.FS) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
url := r.FormValue(returnURLParam)
|
|
if url == "" {
|
|
url = "/"
|
|
}
|
|
|
|
err := manager.GetInstance().SessionStore.Login(w, r)
|
|
if errors.Is(err, session.ErrInvalidCredentials) {
|
|
// redirect back to the login page with an error
|
|
redirectToLogin(loginUIBox, w, url, "Username or password is invalid")
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
http.Redirect(w, r, url, http.StatusFound)
|
|
}
|
|
}
|
|
|
|
func handleLogout(loginUIBox embed.FS) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if err := manager.GetInstance().SessionStore.Logout(w, r); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// redirect to the login page if credentials are required
|
|
getLoginHandler(loginUIBox)(w, r)
|
|
}
|
|
}
|