package server import ( "encoding/json" "net/http" "strconv" "strings" "time" "gitlab.com/Timfa/bluegit/internal/auth" "gitlab.com/Timfa/bluegit/internal/store" ) func (s *Server) login(w http.ResponseWriter, r *http.Request) { if s.who(r).OK { http.Redirect(w, r, "/", http.StatusFound) return } if s.Dev { id, err := s.Auth.Exchange(r.Context(), "dev", s.Cfg.RedirectURI(), "", "") if err != nil { http.Error(w, err.Error(), http.StatusBadGateway) return } s.finishLogin(w, r, id.AuthID, id.Username, id.AvatarURL, id.IsAdmin, id.AccessToken, id.ExpiresIn) return } state, err := randomState() if err != nil { http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError) return } nonce, err := randomState() if err != nil { http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError) return } verifier, err := auth.NewPKCEVerifier() if err != nil { http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError) return } secure := strings.HasPrefix(s.Cfg.BaseURL, "https://") http.SetCookie(w, &http.Cookie{ Name: "bluegit_oauth_state", Value: state, Path: "/", MaxAge: 600, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode, }) http.SetCookie(w, &http.Cookie{ Name: "bluegit_oauth_nonce", Value: nonce, Path: "/", MaxAge: 600, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode, }) http.SetCookie(w, &http.Cookie{ Name: "bluegit_oauth_pkce", Value: verifier, Path: "/", MaxAge: 600, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode, }) http.Redirect(w, r, s.Auth.AuthorizeURL(state, nonce, s.Cfg.RedirectURI(), auth.PKCEChallenge(verifier)), http.StatusFound) } func (s *Server) callback(w http.ResponseWriter, r *http.Request) { if s.Dev { http.NotFound(w, r) return } if msg := r.URL.Query().Get("error"); msg != "" { s.redirect(w, r, "/login", "", s.tr(r, "err.oauth", msg)) return } stateCookie, err := r.Cookie("bluegit_oauth_state") if err != nil || stateCookie.Value == "" || stateCookie.Value != r.URL.Query().Get("state") { http.Error(w, s.tr(r, "err.oauthState"), http.StatusBadRequest) return } nonceCookie, err := r.Cookie("bluegit_oauth_nonce") nonce := "" if err == nil { nonce = nonceCookie.Value } pkceCookie, err := r.Cookie("bluegit_oauth_pkce") verifier := "" if err == nil { verifier = pkceCookie.Value } http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_state", Value: "", Path: "/", MaxAge: -1}) http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_nonce", Value: "", Path: "/", MaxAge: -1}) http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_pkce", Value: "", Path: "/", MaxAge: -1}) id, err := s.Auth.Exchange(r.Context(), r.URL.Query().Get("code"), s.Cfg.RedirectURI(), nonce, verifier) if err != nil { s.Log.Error("oauth", "err", err) s.redirect(w, r, "/", "", s.tr(r, "err.oauthFail")) return } s.finishLogin(w, r, id.AuthID, id.Username, id.AvatarURL, id.IsAdmin, id.AccessToken, id.ExpiresIn) } func (s *Server) finishLogin(w http.ResponseWriter, r *http.Request, authID int64, username, avatar string, authAdmin bool, token string, expiresIn int) { if expiresIn <= 0 { expiresIn = 86400 } user, err := s.Store.UpsertUser(r.Context(), authID, username, avatar, authAdmin) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } user = s.maybeRefreshEntraAvatar(r.Context(), user, token) exp := time.Now().Add(time.Duration(expiresIn) * time.Second) sess, err := s.Store.CreateSession(r.Context(), user.ID, token, exp) if err != nil { http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError) return } s.setSessionCookie(w, sess.ID, exp) s.redirect(w, r, "/", s.tr(r, "flash.welcome", user.Username), "") } func (s *Server) logout(w http.ResponseWriter, r *http.Request) { if !s.csrfOK(w, r) { return } p := s.who(r) if p.OK { _ = s.Auth.Logout(r.Context(), p.Session.AccessToken) _ = s.Store.DeleteSession(r.Context(), p.Session.ID) } http.SetCookie(w, &http.Cookie{Name: "bluegit_session", Value: "", Path: "/", MaxAge: -1}) http.Redirect(w, r, "/", http.StatusSeeOther) } func (s *Server) home(w http.ResponseWriter, r *http.Request) { v := s.view(w, r, "BlueGit") if v.User != nil { ids, err := s.Store.ListRepoIDs(r.Context(), v.User.ID) if err != nil { http.Error(w, s.tr(r, "err.overview"), http.StatusInternalServerError) return } repos, err := s.Store.ReposByIDs(r.Context(), ids) if err != nil { http.Error(w, s.tr(r, "err.overview"), http.StatusInternalServerError) return } store.SortReposByPush(repos) // Oude links ?all=repos / ?all=groups gaan naar de tabs. if all := r.URL.Query().Get("all"); all == "repos" || all == "groups" { http.Redirect(w, r, "/?tab="+all, http.StatusSeeOther) return } tab := r.URL.Query().Get("tab") if tab != "repos" && tab != "groups" { tab = "" } v.DashTab = tab v.DashRepoN = len(repos) if tab == "repos" { repos = dashPage(&v, r, repos) } else if len(repos) > dashLimit { v.MoreRepos = len(repos) - dashLimit repos = repos[:dashLimit] } v.Repos = repos v.ReleaseRepos = s.releaseOnlyRepos(r, v.User.ID) groups, err := s.Store.ListGroups(r.Context(), v.User.ID) if err != nil { http.Error(w, s.tr(r, "err.overview"), http.StatusInternalServerError) return } if at, err := s.Store.GroupPushTimes(r.Context()); err == nil { store.SortGroupsByPush(groups, at) } v.DashGroupN = len(groups) if tab == "groups" { groups = dashPage(&v, r, groups) } else if len(groups) > dashLimit { v.MoreGroups = len(groups) - dashLimit groups = groups[:dashLimit] } v.Groups = groups v.Title = s.tr(r, "nav.dashboard") v.Page = "dashboard" v.Heat = s.heatmap(r.Context(), v.User.ID, ids, s.langOf(r)) total := 0 if v.Heat != nil { total = v.Heat.Total } card, _, _ := s.profileCard(r, *v.User, v.User.ID, total) card.Heading = "h2" v.Card = &card s.render(w, "dashboard", v) return } ids, err := s.Store.ListRepoIDs(r.Context(), 0) if err == nil { v.Repos, _ = s.Store.ReposByIDs(r.Context(), ids) store.SortReposByPush(v.Repos) } v.ReleaseRepos = s.releaseOnlyRepos(r, 0) v.Title = "" s.render(w, "home", v) } func (s *Server) newPage(w http.ResponseWriter, r *http.Request) { if _, ok := s.loginRequired(w, r); !ok { return } v := s.view(w, r, "title.new") v.Page = "new" v.Groups, _ = s.Store.ListGroups(r.Context(), v.User.ID) s.render(w, "new", v) } func (s *Server) account(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok { return } v := s.view(w, r, "title.account") v.Page = "account" v.Tokens, _ = s.Store.ListTokens(r.Context(), u.ID) for _, tok := range v.Tokens { if !tok.ExpiresAt.IsZero() { v.ShowExpiry = true break } } v.Keys, _ = s.Store.ListSSHKeys(r.Context(), u.ID) v.NewToken = cookieVal(r, "bluegit_token_once") if v.NewToken != "" { http.SetCookie(w, &http.Cookie{Name: "bluegit_token_once", Value: "", Path: "/", MaxAge: -1}) } s.fillUserRunners(w, r, &v, u) s.render(w, "account", v) } func (s *Server) createToken(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok || !s.csrfOK(w, r) { return } plain, _, err := s.opIssueToken(r.Context(), u, r.FormValue("name"), nil, time.Time{}) if err != nil { s.redirect(w, r, "/settings", "", s.trErr(r, err)) return } secure := strings.HasPrefix(s.Cfg.BaseURL, "https://") http.SetCookie(w, &http.Cookie{Name: "bluegit_token_once", Value: plain, Path: "/settings", MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode}) s.redirect(w, r, "/settings", s.tr(r, "flash.tokenCreated"), "") } func (s *Server) deleteToken(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok || !s.csrfOK(w, r) { return } var id int64 _, _ = parseID(r.FormValue("id"), &id) if err := s.opRevokeToken(r.Context(), u, id); err != nil { s.redirect(w, r, "/settings", "", s.tr(r, "err.tokenMissing")) return } s.redirect(w, r, "/settings", s.tr(r, "flash.tokenRevoked"), "") } func (s *Server) addSSH(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok || !s.csrfOK(w, r) { return } if err := s.opAddSSH(r.Context(), u, r.FormValue("name"), r.FormValue("key")); err != nil { s.redirect(w, r, "/settings", "", s.commitProblem(r, err)) return } s.redirect(w, r, "/settings", s.tr(r, "flash.sshAdded"), "") } func (s *Server) deleteSSH(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok || !s.csrfOK(w, r) { return } var id int64 _, _ = parseID(r.FormValue("id"), &id) if err := s.opRemoveSSH(r.Context(), u, id); err != nil { s.redirect(w, r, "/settings", "", s.tr(r, "err.sshMissing")) return } s.redirect(w, r, "/settings", s.tr(r, "flash.sshRemoved"), "") } func (s *Server) export(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok { return } payload := s.opExport(r.Context(), u) w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Content-Disposition", `attachment; filename="bluegit-export.json"`) enc := json.NewEncoder(w) enc.SetIndent("", " ") _ = enc.Encode(payload) } func parseID(s string, dest *int64) (int64, error) { var n int64 for _, c := range s { if c < '0' || c > '9' { return 0, errBadID } n = n*10 + int64(c-'0') } if dest != nil { *dest = n } return n, nil } var errBadID = http.ErrMissingFile // dashLimit is het aantal repos en groepen op het overzicht. const dashLimit = 10 // dashPerPage: de tabs Repositories en Groepen tonen 50 per pagina. const dashPerPage = 50 func dashPage[T any](v *View, r *http.Request, list []T) []T { pages := (len(list) + dashPerPage - 1) / dashPerPage if pages < 1 { pages = 1 } page, _ := strconv.Atoi(r.URL.Query().Get("page")) if page < 1 { page = 1 } if page > pages { page = pages } v.DashPage, v.DashPages = page, pages if page > 1 { v.DashPrev = page - 1 } if page < pages { v.DashNext = page + 1 } from := (page - 1) * dashPerPage to := from + dashPerPage if to > len(list) { to = len(list) } return list[from:to] }