Публичный
Open-source lightweight git hosting.
handlers.go
·
359 строк
·
12.5 KB
| 1 | package handlers |
| 2 | |
| 3 | import ( |
| 4 | "bytes" |
| 5 | "fmt" |
| 6 | "log/slog" |
| 7 | "net/http" |
| 8 | "net/url" |
| 9 | "strings" |
| 10 | "time" |
| 11 | |
| 12 | "polar/internal/auth" |
| 13 | "polar/internal/config" |
| 14 | "polar/internal/db" |
| 15 | "polar/internal/i18n" |
| 16 | "polar/internal/repo" |
| 17 | "polar/internal/user" |
| 18 | "polar/internal/web/middleware" |
| 19 | "polar/internal/web/static" |
| 20 | "polar/internal/web/views" |
| 21 | |
| 22 | "github.com/gofiber/fiber/v2" |
| 23 | "github.com/gofiber/fiber/v2/middleware/filesystem" |
| 24 | ) |
| 25 | |
| 26 | type Handler struct { |
| 27 | cfg config.Config |
| 28 | db *db.DB |
| 29 | authSvc *auth.Service |
| 30 | userSvc *user.Service |
| 31 | repoSvc *repo.Service |
| 32 | views *views.Engine |
| 33 | logger *slog.Logger |
| 34 | } |
| 35 | |
| 36 | func New( |
| 37 | cfg config.Config, |
| 38 | database *db.DB, |
| 39 | authSvc *auth.Service, |
| 40 | userSvc *user.Service, |
| 41 | repoSvc *repo.Service, |
| 42 | viewsEngine *views.Engine, |
| 43 | logger *slog.Logger, |
| 44 | ) *Handler { |
| 45 | return &Handler{ |
| 46 | cfg: cfg, |
| 47 | db: database, |
| 48 | authSvc: authSvc, |
| 49 | userSvc: userSvc, |
| 50 | repoSvc: repoSvc, |
| 51 | views: viewsEngine, |
| 52 | logger: logger, |
| 53 | } |
| 54 | } |
| 55 | |
| 56 | func (h *Handler) RegisterRoutes(app *fiber.App) { |
| 57 | app.Use(middleware.RecoverAndLog(h.logger)) |
| 58 | app.Use(middleware.SecurityHeaders()) |
| 59 | |
| 60 | app.Get("/healthz", h.Healthz) |
| 61 | |
| 62 | app.Use("/static", filesystem.New(filesystem.Config{ |
| 63 | Root: http.FS(static.FS), |
| 64 | Browse: false, |
| 65 | MaxAge: 0, |
| 66 | })) |
| 67 | |
| 68 | app.Use(middleware.LocaleAndTheme(h.cfg.Landing.DefaultLang)) |
| 69 | app.Use(middleware.SessionAuth(h.authSvc, h.userSvc)) |
| 70 | app.Use(middleware.CSRFProtection()) |
| 71 | |
| 72 | authLimiter := middleware.NewRateLimiter(20, time.Minute) |
| 73 | |
| 74 | // Public & Root routes |
| 75 | app.Get("/", h.Home) |
| 76 | app.Get("/explore", h.Explore) |
| 77 | |
| 78 | // Auth routes |
| 79 | app.Get("/login", h.LoginPage) |
| 80 | app.Post("/login", authLimiter.Handler(), h.LoginSubmit) |
| 81 | app.Get("/register", h.RegisterPage) |
| 82 | app.Post("/register", authLimiter.Handler(), h.RegisterSubmit) |
| 83 | app.Post("/logout", h.LogoutSubmit) |
| 84 | app.Get("/login/device", h.DeviceVerifyPage) |
| 85 | app.Post("/login/device", h.DeviceVerifySubmit) |
| 86 | app.Post("/api/v1/device/code", h.DeviceCodeAPI) |
| 87 | app.Post("/api/v1/device/token", h.DeviceTokenAPI) |
| 88 | |
| 89 | // Authenticated user routes |
| 90 | app.Get("/repos", middleware.RequireAuth(), h.MyRepos) |
| 91 | app.Get("/new", middleware.RequireAuth(), h.NewRepoPage) |
| 92 | app.Post("/new", middleware.RequireAuth(), h.NewRepoSubmit) |
| 93 | app.Get("/settings", middleware.RequireAuth(), h.SettingsPage) |
| 94 | app.Post("/settings/profile", middleware.RequireAuth(), h.UpdateProfileSubmit) |
| 95 | app.Post("/settings/password", middleware.RequireAuth(), h.UpdatePasswordSubmit) |
| 96 | app.Post("/settings/tokens", middleware.RequireAuth(), h.CreateTokenSubmit) |
| 97 | app.Post("/settings/tokens/:id/revoke", middleware.RequireAuth(), h.RevokeTokenSubmit) |
| 98 | |
| 99 | // Admin routes |
| 100 | app.Get("/admin", middleware.RequireAdmin(), h.AdminPage) |
| 101 | app.Post("/admin/settings", middleware.RequireAdmin(), h.AdminSettingsSubmit) |
| 102 | |
| 103 | // Git Smart HTTP endpoints (supports both /:owner/:repo.git/* and /:owner/:repo/*) |
| 104 | app.Get("/:owner/:repo/info/refs", h.GitInfoRefs) |
| 105 | app.Post("/:owner/:repo/git-upload-pack", h.GitUploadPack) |
| 106 | app.Post("/:owner/:repo/git-receive-pack", h.GitReceivePack) |
| 107 | |
| 108 | // Repository Web UI routes |
| 109 | app.Get("/:owner/:repo/settings", middleware.RequireAuth(), h.RepoSettingsPage) |
| 110 | app.Post("/:owner/:repo/settings", middleware.RequireAuth(), h.RepoSettingsSubmit) |
| 111 | app.Post("/:owner/:repo/settings/rename", middleware.RequireAuth(), h.RepoRenameSubmit) |
| 112 | app.Post("/:owner/:repo/settings/delete", middleware.RequireAuth(), h.RepoDeleteSubmit) |
| 113 | app.Post("/:owner/:repo/settings/collaborators/add", middleware.RequireAuth(), h.RepoCollaboratorAddSubmit) |
| 114 | app.Post("/:owner/:repo/settings/collaborators/remove", middleware.RequireAuth(), h.RepoCollaboratorRemoveSubmit) |
| 115 | |
| 116 | app.Get("/:owner/:repo/branches", h.RepoBranchesPage) |
| 117 | app.Post("/:owner/:repo/branches", middleware.RequireAuth(), h.RepoCreateBranchSubmit) |
| 118 | app.Post("/:owner/:repo/branches/delete", middleware.RequireAuth(), h.RepoDeleteBranchSubmit) |
| 119 | app.Post("/:owner/:repo/tags", middleware.RequireAuth(), h.RepoCreateTagSubmit) |
| 120 | app.Post("/:owner/:repo/tags/delete", middleware.RequireAuth(), h.RepoDeleteTagSubmit) |
| 121 | app.Get("/:owner/:repo/archive/*", h.RepoArchiveZip) |
| 122 | app.Get("/:owner/:repo/new-file", middleware.RequireAuth(), h.RepoNewFilePage) |
| 123 | app.Post("/:owner/:repo/new-file", middleware.RequireAuth(), h.RepoCreateFileSubmit) |
| 124 | app.Get("/:owner/:repo/new-folder", middleware.RequireAuth(), h.RepoNewFolderPage) |
| 125 | app.Post("/:owner/:repo/new-folder", middleware.RequireAuth(), h.RepoCreateFolderSubmit) |
| 126 | |
| 127 | app.Post("/:owner/:repo/fork", middleware.RequireAuth(), h.RepoForkSubmit) |
| 128 | app.Get("/:owner/:repo/forks", h.RepoForksPage) |
| 129 | |
| 130 | app.Get("/:owner/:repo/issues", h.RepoIssuesPage) |
| 131 | app.Get("/:owner/:repo/issues/new", middleware.RequireAuth(), h.RepoNewIssuePage) |
| 132 | app.Post("/:owner/:repo/issues/new", middleware.RequireAuth(), h.RepoNewIssueSubmit) |
| 133 | app.Get("/:owner/:repo/issues/:number", h.RepoIssueDetailPage) |
| 134 | app.Post("/:owner/:repo/issues/:number/comments", middleware.RequireAuth(), h.RepoIssueCommentSubmit) |
| 135 | app.Post("/:owner/:repo/issues/:number/state", middleware.RequireAuth(), h.RepoIssueStateSubmit) |
| 136 | |
| 137 | // Pull Requests |
| 138 | app.Get("/:owner/:repo/pulls", h.RepoPullsPage) |
| 139 | app.Get("/:owner/:repo/pulls/new", middleware.RequireAuth(), h.RepoNewPullPage) |
| 140 | app.Post("/:owner/:repo/pulls/new", middleware.RequireAuth(), h.RepoNewPullSubmit) |
| 141 | app.Get("/:owner/:repo/pulls/:number", h.RepoPullDetailPage) |
| 142 | app.Post("/:owner/:repo/pulls/:number/comments", middleware.RequireAuth(), h.RepoPullCommentSubmit) |
| 143 | app.Post("/:owner/:repo/pulls/:number/state", middleware.RequireAuth(), h.RepoPullStateSubmit) |
| 144 | app.Post("/:owner/:repo/pulls/:number/merge", middleware.RequireAuth(), h.RepoPullMergeSubmit) |
| 145 | app.Post("/:owner/:repo/pulls/:number/review", middleware.RequireAuth(), h.RepoPullReviewSubmit) |
| 146 | |
| 147 | // Releases |
| 148 | app.Get("/:owner/:repo/releases", h.RepoReleasesPage) |
| 149 | app.Get("/:owner/:repo/releases/new", middleware.RequireAuth(), h.RepoNewReleasePage) |
| 150 | app.Post("/:owner/:repo/releases/new", middleware.RequireAuth(), h.RepoNewReleaseSubmit) |
| 151 | app.Post("/:owner/:repo/releases/:id/delete", middleware.RequireAuth(), h.RepoDeleteReleaseSubmit) |
| 152 | |
| 153 | // Activity |
| 154 | app.Get("/:owner/:repo/activity", h.RepoActivityPage) |
| 155 | |
| 156 | app.Get("/:owner/:repo/commits/:ref", h.RepoCommitsPage) |
| 157 | app.Get("/:owner/:repo/commit/:hash", h.RepoCommitDetailPage) |
| 158 | app.Get("/:owner/:repo/tree/:ref/*", h.RepoTreePage) |
| 159 | app.Get("/:owner/:repo/tree/:ref", h.RepoTreePage) |
| 160 | app.Get("/:owner/:repo/blob/:ref/*", h.RepoBlobPage) |
| 161 | app.Get("/:owner/:repo/raw/:ref/*", h.RepoRawBlob) |
| 162 | app.Get("/:owner/:repo", h.RepoHomePage) |
| 163 | |
| 164 | // User profile page |
| 165 | app.Get("/:username", h.UserProfilePage) |
| 166 | } |
| 167 | |
| 168 | func (h *Handler) Healthz(c *fiber.Ctx) error { |
| 169 | if err := h.db.PingContext(c.UserContext()); err != nil { |
| 170 | return c.Status(fiber.StatusServiceUnavailable).JSON(fiber.Map{ |
| 171 | "status": "error", |
| 172 | "db": "unreachable", |
| 173 | }) |
| 174 | } |
| 175 | return c.Status(fiber.StatusOK).JSON(fiber.Map{ |
| 176 | "status": "ok", |
| 177 | "service": "polar", |
| 178 | }) |
| 179 | } |
| 180 | |
| 181 | func (h *Handler) baseData(c *fiber.Ctx, title string) map[string]any { |
| 182 | u := middleware.CurrentUser(c) |
| 183 | lang := h.langOf(c) |
| 184 | theme, _ := c.Locals("theme").(string) |
| 185 | if theme == "" { |
| 186 | theme = "system" |
| 187 | } |
| 188 | csrf, _ := c.Locals("csrf_token").(string) |
| 189 | |
| 190 | flash := c.Cookies("polar_flash") |
| 191 | if flash != "" { |
| 192 | if decoded, err := url.QueryUnescape(flash); err == nil { |
| 193 | flash = decoded |
| 194 | } |
| 195 | c.ClearCookie("polar_flash") |
| 196 | } |
| 197 | |
| 198 | ctx := c.UserContext() |
| 199 | anonRead := h.db.IsAnonymousReadEnabled(ctx) |
| 200 | var paletteRepos []repo.Repository |
| 201 | if u != nil || anonRead { |
| 202 | paletteRepos, _ = h.repoSvc.ListAccessible(ctx, u, 25) |
| 203 | } |
| 204 | |
| 205 | data := map[string]any{ |
| 206 | "Title": title, |
| 207 | "Lang": lang, |
| 208 | "Theme": theme, |
| 209 | "CSRFToken": csrf, |
| 210 | "CurrentUser": u, |
| 211 | "Flash": flash, |
| 212 | "RegistrationEnabled": h.isRegistrationAllowed(c), |
| 213 | "ExploreEnabled": h.db.IsExploreEnabled(ctx), |
| 214 | "LandingEnabled": h.db.IsLandingEnabled(ctx, h.cfg.Landing.Enabled), |
| 215 | "AnonymousReadEnabled": anonRead, |
| 216 | "IssuesEnabled": h.db.IsIssuesEnabled(ctx), |
| 217 | "PaletteRepos": paletteRepos, |
| 218 | } |
| 219 | if extra := h.repoNavData(c); extra != nil { |
| 220 | for k, v := range extra { |
| 221 | data[k] = v |
| 222 | } |
| 223 | } |
| 224 | return data |
| 225 | } |
| 226 | |
| 227 | // repoNavData enriches template data for /:owner/:repo routes with fork |
| 228 | // navigation state used by the repository header. |
| 229 | func (h *Handler) repoNavData(c *fiber.Ctx) map[string]any { |
| 230 | owner, name := c.Params("owner"), strings.TrimSuffix(c.Params("repo"), ".git") |
| 231 | if owner == "" || name == "" { |
| 232 | return nil |
| 233 | } |
| 234 | ctx := c.UserContext() |
| 235 | nr, err := h.repoSvc.GetByOwnerAndName(ctx, owner, name) |
| 236 | if err != nil || nr == nil { |
| 237 | return nil |
| 238 | } |
| 239 | u := middleware.CurrentUser(c) |
| 240 | data := map[string]any{"NavRepo": nr} |
| 241 | data["IsRepoOwner"] = u != nil && u.ID == nr.OwnerID |
| 242 | if u != nil && u.ID != nr.OwnerID { |
| 243 | if fork, ferr := h.repoSvc.FindForkByOwner(ctx, nr.ID, u.ID); ferr == nil && fork != nil { |
| 244 | data["ViewerFork"] = fork |
| 245 | } |
| 246 | } |
| 247 | return data |
| 248 | } |
| 249 | |
| 250 | func (h *Handler) setFlash(c *fiber.Ctx, msg string) { |
| 251 | c.Cookie(&fiber.Cookie{ |
| 252 | Name: "polar_flash", |
| 253 | Value: url.QueryEscape(msg), |
| 254 | Path: "/", |
| 255 | MaxAge: 30, |
| 256 | HTTPOnly: true, |
| 257 | SameSite: "Lax", |
| 258 | }) |
| 259 | } |
| 260 | |
| 261 | // langOf resolves the active UI language for the current request. |
| 262 | func (h *Handler) langOf(c *fiber.Ctx) i18n.Lang { |
| 263 | lang, _ := c.Locals("lang").(i18n.Lang) |
| 264 | if lang == "" { |
| 265 | lang = i18n.Normalize(h.cfg.Landing.DefaultLang) |
| 266 | } |
| 267 | return lang |
| 268 | } |
| 269 | |
| 270 | // tr translates key for the current request and formats it with args. |
| 271 | func (h *Handler) tr(c *fiber.Ctx, key string, args ...any) string { |
| 272 | return fmt.Sprintf(i18n.T(h.langOf(c), key), args...) |
| 273 | } |
| 274 | |
| 275 | // setFlashT stores a localized flash message. |
| 276 | func (h *Handler) setFlashT(c *fiber.Ctx, key string, args ...any) { |
| 277 | h.setFlash(c, h.tr(c, key, args...)) |
| 278 | } |
| 279 | |
| 280 | // renderErrorT renders an error page with localized title and message. |
| 281 | func (h *Handler) renderErrorT(c *fiber.Ctx, status int, titleKey, msgKey string, args ...any) error { |
| 282 | return h.renderError(c, status, i18n.T(h.langOf(c), titleKey), h.tr(c, msgKey, args...)) |
| 283 | } |
| 284 | |
| 285 | func (h *Handler) isRegistrationAllowed(c *fiber.Ctx) bool { |
| 286 | if cnt, err := h.userSvc.Count(c.UserContext()); err == nil && cnt == 0 { |
| 287 | return true |
| 288 | } |
| 289 | return h.db.IsRegistrationEnabled(c.UserContext(), h.cfg.Auth.RegistrationEnabled) |
| 290 | } |
| 291 | |
| 292 | func (h *Handler) render(c *fiber.Ctx, status int, page string, data map[string]any) error { |
| 293 | var buf bytes.Buffer |
| 294 | if err := h.views.Render(&buf, page, data); err != nil { |
| 295 | h.logger.Error("render template failed", "page", page, "err", err) |
| 296 | return c.Status(fiber.StatusInternalServerError).SendString("Template render error") |
| 297 | } |
| 298 | c.Status(status) |
| 299 | c.Set(fiber.HeaderContentType, fiber.MIMETextHTMLCharsetUTF8) |
| 300 | return c.Send(buf.Bytes()) |
| 301 | } |
| 302 | |
| 303 | func (h *Handler) renderError(c *fiber.Ctx, status int, title, message string) error { |
| 304 | data := h.baseData(c, title) |
| 305 | data["StatusCode"] = status |
| 306 | data["Title"] = title |
| 307 | data["Message"] = message |
| 308 | return h.render(c, status, "error", data) |
| 309 | } |
| 310 | |
| 311 | func (h *Handler) Home(c *fiber.Ctx) error { |
| 312 | if !h.db.IsLandingEnabled(c.UserContext(), h.cfg.Landing.Enabled) { |
| 313 | if middleware.CurrentUser(c) != nil { |
| 314 | return c.Redirect("/repos", fiber.StatusSeeOther) |
| 315 | } |
| 316 | return c.Redirect("/login", fiber.StatusSeeOther) |
| 317 | } |
| 318 | data := h.baseData(c, "") |
| 319 | if h.db.IsExploreEnabled(c.UserContext()) && (middleware.CurrentUser(c) != nil || h.db.IsAnonymousReadEnabled(c.UserContext())) { |
| 320 | repos, _ := h.repoSvc.ListPublic(c.UserContext(), 10) |
| 321 | data["Repos"] = repos |
| 322 | } |
| 323 | return h.render(c, fiber.StatusOK, "landing", data) |
| 324 | } |
| 325 | |
| 326 | func (h *Handler) Explore(c *fiber.Ctx) error { |
| 327 | if !h.db.IsExploreEnabled(c.UserContext()) { |
| 328 | return h.renderErrorT(c, fiber.StatusNotFound, "err.not_found", "err.explore_disabled") |
| 329 | } |
| 330 | if middleware.CurrentUser(c) == nil && !h.db.IsAnonymousReadEnabled(c.UserContext()) { |
| 331 | return c.Redirect("/login", fiber.StatusSeeOther) |
| 332 | } |
| 333 | lang, _ := c.Locals("lang").(i18n.Lang) |
| 334 | data := h.baseData(c, i18n.T(lang, "nav.explore")) |
| 335 | repos, _ := h.repoSvc.ListPublic(c.UserContext(), 100) |
| 336 | data["PageHeading"] = i18n.T(lang, "nav.explore") |
| 337 | data["Repos"] = repos |
| 338 | return h.render(c, fiber.StatusOK, "repos", data) |
| 339 | } |
| 340 | |
| 341 | func (h *Handler) MyRepos(c *fiber.Ctx) error { |
| 342 | u := middleware.CurrentUser(c) |
| 343 | lang, _ := c.Locals("lang").(i18n.Lang) |
| 344 | data := h.baseData(c, i18n.T(lang, "nav.repositories")) |
| 345 | repos, _ := h.repoSvc.ListByOwner(c.UserContext(), u.ID, true) |
| 346 | data["PageHeading"] = i18n.T(lang, "nav.repositories") |
| 347 | data["Repos"] = repos |
| 348 | return h.render(c, fiber.StatusOK, "repos", data) |
| 349 | } |
| 350 | |
| 351 | func (h *Handler) cloneURL(c *fiber.Ctx, ownerUsername, repoName string) string { |
| 352 | base := strings.TrimRight(h.cfg.Server.BaseURL, "/") |
| 353 | if base == "" || strings.Contains(base, "localhost:3000") { |
| 354 | if reqBase := c.BaseURL(); reqBase != "" { |
| 355 | base = strings.TrimRight(reqBase, "/") |
| 356 | } |
| 357 | } |
| 358 | return base + "/" + ownerUsername + "/" + repoName + ".git" |
| 359 | } |
| 360 |