package server import ( "context" "errors" "os" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/names" "gitlab.com/Timfa/bluegit/internal/state" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/webhook" ) func (s *Server) opCreateGroup(ctx context.Context, user store.User, display, description, defaultRole string) (store.Group, error) { display = strings.TrimSpace(display) path, err := slugKind("group", display) if err != nil { return store.Group{}, fail(400, err) } role := access.Role("") if strings.TrimSpace(defaultRole) != "" { role, err = access.ParseRole(defaultRole) if err != nil { return store.Group{}, fail(400, err) } } g, err := s.Store.CreateGroup(ctx, user.ID, display, path, description, role) if err != nil { return store.Group{}, fail(400, err) } return g, nil } func slugKind(kind, raw string) (string, error) { path, err := names.Slug(kind, raw) if err != nil { return "", i18n.E("slug.bad") } return path, nil } func (s *Server) opUpdateGroup(ctx context.Context, user store.User, g store.Group, description, visibility, defaultRole string) error { role, err := s.Store.GroupRole(ctx, g.ID, user.ID) if err != nil || !role.AtLeast(access.RoleMaintainer) { return fail(403, i18n.E("err.forbidden")) } if visibility != "public" { visibility = "private" } next := g.DefaultRole if strings.TrimSpace(defaultRole) != "" { next, err = access.ParseRole(defaultRole) if err != nil { return fail(400, err) } } if err := s.Store.UpdateGroup(ctx, g.ID, description, visibility, next); err != nil { return fail(400, err) } return nil } func (s *Server) opTransferGroup(ctx context.Context, user store.User, g store.Group, username, confirm string) error { if user.ID != g.OwnerID { return fail(403, i18n.E("err.ownerOnly")) } username = strings.ToLower(strings.TrimSpace(username)) if username == "" || confirm != username { return fail(400, i18n.E("err.ownerConfirm")) } to, err := s.Store.UserByUsername(ctx, username) if err != nil { return fail(400, i18n.E("err.ownerMember")) } if err := s.Store.TransferGroupOwner(ctx, g.ID, user.ID, to.ID); err != nil { return fail(400, err) } return nil } func (s *Server) opCreateRepo(ctx context.Context, user store.User, rawName, description, groupPath, visibility string, readme bool) (store.Repo, error) { if s.StoragePath() == "" { return store.Repo{}, fail(503, i18n.E("err.noStorage")) } name, err := slugKind("repo", rawName) if err != nil { return store.Repo{}, fail(400, err) } ownerKind := "user" ownerID := user.ID if gpath := strings.TrimSpace(groupPath); gpath != "" { g, err := s.Store.GroupByPath(ctx, gpath) if err != nil { return store.Repo{}, fail(404, i18n.E("err.groupMissing")) } role, err := s.Store.GroupRole(ctx, g.ID, user.ID) if err != nil || !role.CanManageSettings() { return store.Repo{}, fail(403, i18n.E("err.forbidden")) } ownerKind, ownerID = "group", g.ID } if visibility != "public" { visibility = "private" } repo, err := s.Store.CreateRepo(ctx, ownerKind, ownerID, name, description, s.Cfg.Git.DefaultBranch, visibility) if err != nil { return store.Repo{}, fail(400, err) } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil { _ = s.Store.DeleteRepo(ctx, repo.ID) return store.Repo{}, fail(500, i18n.E("err.gitInit", err.Error())) } if readme { role, _ := s.Store.EffectiveRole(ctx, user.ID, repo.ID) if _, err := s.opWriteFiles(ctx, user, repo, role, repo.DefaultBranch, "", "Initial commit", "", map[string]string{ "README.md": "# " + repo.Name + "\n", }, nil); err != nil { _ = s.Store.DeleteRepo(ctx, repo.ID) _ = os.RemoveAll(dir) return store.Repo{}, err } } return repo, nil } func (s *Server) opUpdateRepo(ctx context.Context, user store.User, repo store.Repo, description, visibility string) error { role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID) if err != nil || !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } if visibility != "public" { visibility = "private" } if visibility == "public" && s.forkMustStayPrivate(ctx, repo) { return fail(400, i18n.E("err.forkPrivate")) } if err := s.Store.UpdateRepo(ctx, repo.ID, description, visibility); err != nil { return fail(400, err) } if visibility != repo.Visibility { s.ReadCache().DropRepo(repo.ID) } return nil } // opSetDefaultBranch zet HEAD en de metadata naar een bestaande branch. func (s *Server) opSetDefaultBranch(ctx context.Context, user store.User, repo store.Repo, branch string) error { role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID) if err != nil || !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } branch = strings.TrimSpace(branch) if err := names.ValidBranch(branch); err != nil { return fail(400, err) } if branch == repo.DefaultBranch { return nil } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if !gitrepo.HasBranch(ctx, s.Git, dir, branch) { return fail(400, i18n.E("err.branchMissing")) } if err := gitrepo.SetHEAD(ctx, s.Git, dir, branch); err != nil { return err } return s.Store.SetDefaultBranch(ctx, repo.ID, branch) } // opSetRepoCIPaused zet of nieuwe pipelines mogen worden ingepland. func (s *Server) opSetRepoCIPaused(ctx context.Context, user store.User, repo store.Repo, paused bool) error { role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID) if err != nil || !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } return s.Store.SetRepoCIPaused(ctx, repo.ID, paused) } // opSetReleaseVisibility zet inherit, private of public (alleen beheerders). func (s *Server) opSetReleaseVisibility(ctx context.Context, user store.User, repo store.Repo, v string) error { role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID) if err != nil || !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } if err := s.Store.SetReleaseVisibility(ctx, repo.ID, v); err != nil { return fail(400, err) } return nil } func (s *Server) opDeleteRepo(ctx context.Context, user store.User, repo store.Repo, confirm string, force bool) error { role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID) if err != nil || !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } if confirm != repo.Name { return fail(400, i18n.E("err.confirmDelete")) } if prot, _ := s.Store.RunningProtectedJobs(ctx, repo.ID, 0); len(prot) > 0 && !force { return fail(409, i18n.E("err.dniRepoDelete", jobNames(prot))) } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if err := s.Store.DeleteRepo(ctx, repo.ID); err != nil { return fail(400, err) } _ = os.RemoveAll(dir) s.ReadCache().DropRepo(repo.ID) return nil } // opDeleteGroup verwijdert een lege groep. Alleen groepsbeheerders en // admins; confirm is de groepsnaam of het pad. Een groep met repositories // geeft 409 met het aantal; er is geen force. func (s *Server) opDeleteGroup(ctx context.Context, user store.User, g store.Group, confirm string) error { if err := s.manageScope(ctx, user, "group", g.ID); err != nil { return err } if c := strings.TrimSpace(confirm); c == "" || (c != g.Name && c != g.Path) { return fail(400, i18n.E("err.confirmGroupDelete")) } if err := s.Store.DeleteGroup(ctx, g.ID); err != nil { var ne store.ErrGroupNotEmpty if errors.As(err, &ne) { return fail(409, i18n.E("err.groupNotEmpty", ne.Repos)) } return fail(500, err) } return nil } func (s *Server) manageScope(ctx context.Context, user store.User, kind string, id int64) error { if kind == "group" { role, err := s.Store.GroupRole(ctx, id, user.ID) if err != nil || !role.AtLeast(access.RoleMaintainer) { return fail(403, i18n.E("err.forbidden")) } return nil } role, err := s.Store.EffectiveRole(ctx, user.ID, id) if err != nil || !role.CanManageSettings() { return fail(403, i18n.E("err.forbidden")) } return nil } func (s *Server) opSetMember(ctx context.Context, user store.User, kind string, id int64, username, roleName string) error { if err := s.manageScope(ctx, user, kind, id); err != nil { return err } role, err := access.ParseRole(roleName) if err != nil { return fail(400, err) } if err := s.Store.SetMember(ctx, kind, id, username, role); err != nil { return fail(400, err) } return nil } func (s *Server) opRemoveMember(ctx context.Context, user store.User, kind string, id int64, username string) error { if err := s.manageScope(ctx, user, kind, id); err != nil { return err } if err := s.Store.RemoveMember(ctx, kind, id, username); err != nil { return fail(400, err) } return nil } func (s *Server) opPutSecret(ctx context.Context, user store.User, kind string, id int64, name, value string, protected bool) error { if err := s.manageScope(ctx, user, kind, id); err != nil { return err } if err := s.Store.PutSecret(ctx, kind, id, strings.TrimSpace(name), value, protected); err != nil { return fail(400, err) } return nil } func (s *Server) opDeleteSecret(ctx context.Context, user store.User, kind string, id int64, name string) error { if err := s.manageScope(ctx, user, kind, id); err != nil { return err } _ = s.Store.DeleteSecret(ctx, kind, id, name) return nil } type hookIn struct { Name string Preset string Filter string Events []string Fields webhook.Input } func (s *Server) opCreateWebhook(ctx context.Context, user store.User, kind string, id int64, in hookIn) (int64, error) { if err := s.manageScope(ctx, user, kind, id); err != nil { return 0, err } if !webhook.KnownPreset(in.Preset) { return 0, fail(400, i18n.E("err.preset")) } if _, err := webhook.MatchBranch(strings.TrimSpace(in.Filter), "main"); err != nil { return 0, fail(400, err) } if len(in.Events) == 0 { return 0, fail(400, i18n.E("err.pickEvent")) } spec, err := webhook.Prepare(in.Preset, in.Fields) if err != nil { return 0, fail(400, err) } wid, err := s.Store.CreateWebhook(ctx, store.Webhook{ ScopeKind: kind, ScopeID: id, Name: strings.TrimSpace(in.Name), Preset: in.Preset, URLTemplate: spec.URL, Headers: spec.Headers, BodyTemplate: spec.Body, Events: in.Events, BranchFilter: strings.TrimSpace(in.Filter), Method: spec.Method, }) if err != nil { return 0, fail(400, err) } return wid, nil } func (s *Server) opDeleteWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64) error { if err := s.manageScope(ctx, user, kind, scopeID); err != nil { return err } _ = s.Store.DeleteWebhook(ctx, kind, scopeID, id) return nil } func (s *Server) opSaveRepoApproval(ctx context.Context, user store.User, repo store.Repo, pol store.ApprovalPolicy) error { if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil { return err } _, groupPath, err := s.Store.EffectiveApproval(ctx, repo) if err != nil { return fail(400, err) } if groupPath != "" { return fail(400, i18n.E("appr.locked")) } if err := s.Store.SaveApproval(ctx, "repo", repo.ID, pol); err != nil { return fail(400, err) } return nil } func (s *Server) opSaveGroupApproval(ctx context.Context, user store.User, g store.Group, pol store.ApprovalPolicy) error { if err := s.manageScope(ctx, user, "group", g.ID); err != nil { return err } if err := s.Store.SaveApproval(ctx, "group", g.ID, pol); err != nil { return fail(400, err) } return nil } func (s *Server) opProtect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error { if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil { return err } var err error if tag { err = s.Store.AddProtectedTag(ctx, repo.ID, pattern) } else { err = s.Store.AddProtected(ctx, repo.ID, pattern) } if err != nil { return fail(400, err) } return nil } func (s *Server) opUnprotect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error { if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil { return err } if tag { _ = s.Store.RemoveProtectedTag(ctx, repo.ID, pattern) } else { _ = s.Store.RemoveProtected(ctx, repo.ID, pattern) } return nil } func (s *Server) opToggleStar(ctx context.Context, user store.User, repo store.Repo) (bool, error) { role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID) if err != nil { return false, fail(500, err) } if user.ID == 0 || (!role.CanRead() && repo.Visibility != "public") { return false, fail(403, i18n.E("err.forbidden")) } _, mine, err := s.Store.StarInfo(ctx, user.ID, []int64{repo.ID}) if err != nil { return false, fail(400, err) } on := !mine[repo.ID] if err := s.Store.SetStar(ctx, user.ID, repo.ID, on); err != nil { return false, fail(400, err) } return on, nil } func (s *Server) opSetStorage(path string) (state.Info, bool, error) { if s.StateDir == "" { return state.Info{}, false, fail(500, i18n.E("err.storageSave")) } info, err := state.Inspect(path) if err != nil { return state.Info{}, false, fail(400, err) } same, err := samePath(s.StateDir, info.Path) if err != nil { return state.Info{}, false, fail(400, err) } if same { return info, false, fail(400, i18n.E("err.storageSame")) } previous := s.StoragePath() if err := state.Write(s.StateDir, info.Path); err != nil { return state.Info{}, false, fail(500, err) } s.AdoptStorage(info.Path) s.RefreshHooks() return info, previous != "" && previous != info.Path, nil }