diff --git a/backend/controllers/github.go b/backend/controllers/github.go index c0f2508d..d98150e7 100644 --- a/backend/controllers/github.go +++ b/backend/controllers/github.go @@ -100,6 +100,13 @@ func (d DiggerController) GithubAppWebHook(c *gin.Context) { return } } + case *github.PushEvent: + slog.Info("Processing PushEvent", + "action", *event.Action, + "repo", *event.Repo.FullName, + ) + + go handlePushEvent(gh, event, appId64) case *github.IssueCommentEvent: slog.Info("Processing IssueCommentEvent", @@ -383,6 +390,33 @@ func handleInstallationDeletedEvent(installation *github.InstallationEvent, appI return nil } +func handlePushEvent(gh utils.GithubClientProvider, payload *github.PushEvent, appId int64) error { + slog.Debug("Handling push event", "appId", appId, "payload", payload) + defer func() { + if r := recover(); r != nil { + stack := string(debug.Stack()) + slog.Error("Recovered from panic in handlePushEvent", "error", r, slog.Group("stack", slog.String("trace", stack))) + } + }() + + installationId := *payload.Installation.ID + repoName := *payload.Repo.Name + repoOwner := *payload.Repo.Owner.Login + repoFullName := *payload.Repo.FullName + cloneURL := *payload.Repo.CloneURL + ref := *payload.Ref + defaultBranch := *payload.Repo.DefaultBranch + + if strings.HasSuffix(ref, defaultBranch) { + err := services.LoadProjectsFromGithubRepo(gh, strconv.FormatInt(installationId, 10), repoFullName, repoOwner, repoName, cloneURL, defaultBranch) + if err != nil { + slog.Error("Failed to load projects from GitHub repo", "error", err) + } + } + + return nil +} + func handlePullRequestEvent(gh utils.GithubClientProvider, payload *github.PullRequestEvent, ciBackendProvider ci_backends.CiBackendProvider, appId int64) error { defer func() { if r := recover(); r != nil { diff --git a/backend/controllers/github_test.go b/backend/controllers/github_test.go index 9133e47c..7aa4dc1b 100644 --- a/backend/controllers/github_test.go +++ b/backend/controllers/github_test.go @@ -614,7 +614,7 @@ func setupSuite(tb testing.TB) (func(tb testing.TB), *models.Database) { // create test project projectName := "test project" - _, err = database.CreateProject(projectName, org, repo, false, false) + _, err = database.CreateProject(projectName, org, repo.RepoFullName, false, false) if err != nil { panic(err) } diff --git a/backend/controllers/policies.go b/backend/controllers/policies.go index f59ac327..fed19a45 100644 --- a/backend/controllers/policies.go +++ b/backend/controllers/policies.go @@ -249,7 +249,7 @@ func upsertPolicyForRepoAndProject(c *gin.Context, policyType string) { if projectResult.RowsAffected == 0 { projectModel = models.Project{ OrganisationID: orgID.(uint), - RepoID: repoModel.ID, + RepoFullName: repoModel.RepoFullName, Name: projectName, } err := models.DB.GormDB.Create(&projectModel).Error diff --git a/backend/controllers/projects.go b/backend/controllers/projects.go index 920827f2..59d97414 100644 --- a/backend/controllers/projects.go +++ b/backend/controllers/projects.go @@ -251,7 +251,7 @@ func ProjectDetails(c *gin.Context) { slog.Info("Successfully retrieved project details", "projectId", projectId, "projectName", project.Name, - "repoName", project.Repo.Name, + "repoFullName", project.RepoFullName, ) c.JSON(http.StatusOK, project.MapToJsonStruct()) @@ -355,9 +355,8 @@ func ReportProjectsForRepo(c *gin.Context) { project := models.Project{ Name: request.Name, ConfigurationYaml: request.ConfigurationYaml, - RepoID: repo.ID, OrganisationID: org.ID, - Repo: &repo, + RepoFullName: repo.RepoFullName, Organisation: org, } diff --git a/backend/controllers/runs.go b/backend/controllers/runs.go index 96300d08..92237828 100644 --- a/backend/controllers/runs.go +++ b/backend/controllers/runs.go @@ -57,6 +57,13 @@ func RunsForProject(c *gin.Context) { return } + repo, err := models.DB.GetRepoByFullName(org.ID, project.RepoFullName) + if err != nil { + slog.Error("Could not fetch repo", "projectId", projectId, "repoFullName", project.RepoFullName, "error", err) + c.String(http.StatusInternalServerError, "Could not fetch repo") + return + } + if project.OrganisationID != org.ID { slog.Warn("Forbidden access: not allowed to access project", "projectOrgId", project.OrganisationID, @@ -66,9 +73,9 @@ func RunsForProject(c *gin.Context) { return } - runs, err := models.DB.ListDiggerRunsForProject(project.Name, project.Repo.ID) + runs, err := models.DB.ListDiggerRunsForProject(project.Name, repo.ID) if err != nil { - slog.Error("Could not fetch runs", "projectId", projectId, "repoId", project.Repo.ID, "error", err) + slog.Error("Could not fetch runs", "projectId", projectId, "repoId", repo.ID, "error", err) c.String(http.StatusInternalServerError, "Could not fetch runs") return } @@ -87,7 +94,7 @@ func RunsForProject(c *gin.Context) { slog.Info("Successfully fetched runs for project", "projectId", projectId, "projectName", project.Name, - "repoId", project.Repo.ID, + "repoId", repo.ID, "runCount", len(runs)) response := make(map[string]interface{}) diff --git a/backend/migrations/20250530015921.sql b/backend/migrations/20250530015921.sql new file mode 100644 index 00000000..395ead6d --- /dev/null +++ b/backend/migrations/20250530015921.sql @@ -0,0 +1,5 @@ +-- Modify "projects" table +ALTER TABLE "public"."projects" DROP COLUMN "repo_id", ADD COLUMN "repo_full_name" text NULL; +-- Create index "idx_project_org" to table: "projects" +DROP INDEX IF EXISTS "idx_project"; +CREATE UNIQUE INDEX "idx_project_org" ON "public"."projects" ("name", "organisation_id", "repo_full_name"); diff --git a/backend/migrations/atlas.sum b/backend/migrations/atlas.sum index e21c3e34..da97b48c 100644 --- a/backend/migrations/atlas.sum +++ b/backend/migrations/atlas.sum @@ -1,4 +1,4 @@ -h1:7qYia+JfrMJUdNvsjR8hZosttT36aVdOje5TP3ekX4w= +h1:IeQ6uHSz71Ox7tBqG6sy05KmaRMpYqhr0SeipkVSEbM= 20231227132525.sql h1:43xn7XC0GoJsCnXIMczGXWis9d504FAWi4F1gViTIcw= 20240115170600.sql h1:IW8fF/8vc40+eWqP/xDK+R4K9jHJ9QBSGO6rN9LtfSA= 20240116123649.sql h1:R1JlUIgxxF6Cyob9HdtMqiKmx/BfnsctTl5rvOqssQw= @@ -49,3 +49,4 @@ h1:7qYia+JfrMJUdNvsjR8hZosttT36aVdOje5TP3ekX4w= 20250416152705.sql h1:yeszz4c/BlyVgUUIk7aTUz/DUNMC40+9fe1Q8Ya4TVI= 20250512172515.sql h1:iIZIhFq3TTyjTzsxNWv3k4FcIkXfOCdHtmHNmYqjBMM= 20250512213729.sql h1:n8bYIXWko9xOUs+FPcG7lS3GXMVQBSygXX7Hpj20eVs= +20250530015921.sql h1:FidRW+0ur3mCDBPgP7V/sqr2jjfmi/CFJPRpNxTmqGs= diff --git a/backend/models/orgs.go b/backend/models/orgs.go index e0597118..d64e3d52 100644 --- a/backend/models/orgs.go +++ b/backend/models/orgs.go @@ -55,8 +55,6 @@ func (p *ProjectRun) MapToJsonStruct() interface{} { Id: p.ID, ProjectID: p.ProjectID, ProjectName: p.Project.Name, - RepoUrl: p.Project.Repo.RepoUrl, - RepoFullName: p.Project.Repo.RepoFullName, StartedAt: time.UnixMilli(p.StartedAt), EndedAt: time.UnixMilli(p.EndedAt), Status: p.Status, @@ -75,11 +73,10 @@ const ( type Project struct { gorm.Model - Name string `gorm:"uniqueIndex:idx_project"` - OrganisationID uint `gorm:"uniqueIndex:idx_project"` + Name string `gorm:"uniqueIndex:idx_project_org"` + OrganisationID uint `gorm:"uniqueIndex:idx_project_org"` Organisation *Organisation - RepoID uint `gorm:"uniqueIndex:idx_project"` - Repo *Repo + RepoFullName string `gorm:"uniqueIndex:idx_project_org"` ConfigurationYaml string // TODO: probably needs to be deleted Status ProjectStatus IsGenerated bool @@ -112,12 +109,8 @@ func (p *Project) MapToJsonStruct() interface{} { Id: p.ID, Name: p.Name, OrganisationID: p.OrganisationID, - RepoID: p.RepoID, OrganisationName: p.Organisation.Name, - RepoFullName: p.Repo.RepoFullName, - RepoName: p.Repo.RepoName, - RepoOrg: p.Repo.RepoOrganisation, - RepoUrl: p.Repo.RepoUrl, + RepoFullName: p.RepoFullName, LastActivityTimestamp: p.UpdatedAt.String(), LastActivityAuthor: "unknown", LastActivityStatus: string(status), diff --git a/backend/models/scheduler_test.go b/backend/models/scheduler_test.go index ae1f1d84..6d08010e 100644 --- a/backend/models/scheduler_test.go +++ b/backend/models/scheduler_test.go @@ -54,7 +54,7 @@ func setupSuiteScheduler(tb testing.TB) (func(tb testing.TB), *Database) { } projectName := "test project" - _, err = database.CreateProject(projectName, org, repo, false, false) + _, err = database.CreateProject(projectName, org, repo.RepoFullName, false, false) if err != nil { panic(err) } diff --git a/backend/models/storage.go b/backend/models/storage.go index d063c2ec..d7357ff1 100644 --- a/backend/models/storage.go +++ b/backend/models/storage.go @@ -215,34 +215,33 @@ func (db *Database) GetProject(projectId uint) (*Project, error) { // GetProjectByName return project for specified org and repo // if record doesn't exist return nil -func (db *Database) GetProjectByName(orgId any, repo *Repo, name string) (*Project, error) { +func (db *Database) GetProjectByName(orgId any, repoFullName string, name string) (*Project, error) { slog.Info("getting project by name", slog.Group("project", "orgId", orgId, - "repoId", repo.ID, + "repoFullName", repoFullName, "name", name)) var project Project - err := db.GormDB.Preload("Organisation").Preload("Repo"). - Joins("INNER JOIN repos ON projects.repo_id = repos.id"). + err := db.GormDB.Preload("Organisation"). Joins("INNER JOIN organisations ON projects.organisation_id = organisations.id"). Where("projects.organisation_id = ?", orgId). - Where("repos.id = ?", repo.ID). + Where("repo_full_name = ?", repoFullName). Where("projects.name = ?", name).First(&project).Error if err != nil { if errors.Is(err, gorm.ErrRecordNotFound) { slog.Debug("project not found", "orgId", orgId, - "repoId", repo.ID, + "repoFullName", repoFullName, "name", name) return nil, nil } slog.Error("error fetching project from database", "error", err, "orgId", orgId, - "repoId", repo.ID, + "repoFullname", repoFullName, "name", name) return nil, err } @@ -378,6 +377,38 @@ func (db *Database) GetRepo(orgIdKey any, repoName string) (*Repo, error) { return &repo, nil } +func (db *Database) GetRepoByFullName(orgIdKey any, repoFullName string) (*Repo, error) { + slog.Info("getting repo by name", + "orgId", orgIdKey, + "repoName", repoFullName) + + var repo Repo + + err := db.GormDB.Preload("Organisation"). + Joins("INNER JOIN organisations ON repos.organisation_id = organisations.id"). + Where("organisations.id = ? AND repos.repo_full_name=?", orgIdKey, repoFullName).First(&repo).Error + + if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + slog.Debug("repo not found", + "orgId", orgIdKey, + "repoFullName", repoFullName) + return nil, fmt.Errorf("repo not found %v", repoFullName) + } + slog.Error("failed to find digger repo", + "error", err, + "orgId", orgIdKey, + "repoFullName", repoFullName) + return nil, err + } + + slog.Debug("found repo", + "repoId", repo.ID, + "orgId", orgIdKey, + "repoName", repoFullName) + return &repo, nil +} + // GetRepoById returns digger repo by organisationId and repo name (diggerhq-digger) func (db *Database) GetRepoById(orgIdKey any, repoId any) (*Repo, error) { var repo Repo @@ -834,7 +865,7 @@ func (db *Database) ListDiggerRunsForProject(projectName string, repoId uint) ([ var runs []DiggerRun err := db.GormDB.Preload("PlanStage").Preload("ApplyStage"). - Where("project_name = ? AND repo_id= ?", projectName, repoId).Order("created_at desc").Find(&runs).Error + Where("project_name = ? AND repo_id = ?", projectName, repoId).Order("created_at desc").Find(&runs).Error if err != nil { slog.Error("error fetching digger runs for project", @@ -1371,11 +1402,11 @@ func (db *Database) CreateOrganisation(name string, externalSource string, tenan return org, nil } -func (db *Database) CreateProject(name string, org *Organisation, repo *Repo, isGenerated bool, isInMainBranch bool) (*Project, error) { +func (db *Database) CreateProject(name string, org *Organisation, repoFullName string, isGenerated bool, isInMainBranch bool) (*Project, error) { project := &Project{ Name: name, Organisation: org, - Repo: repo, + RepoFullName: repoFullName, Status: ProjectActive, IsGenerated: isGenerated, IsInMainBranch: isInMainBranch, @@ -1385,7 +1416,7 @@ func (db *Database) CreateProject(name string, org *Organisation, repo *Repo, is slog.Error("failed to create project", "name", name, "orgId", org.ID, - "repoId", repo.ID, + "repoFullName", repoFullName, "error", result.Error) return nil, result.Error } @@ -1394,7 +1425,7 @@ func (db *Database) CreateProject(name string, org *Organisation, repo *Repo, is "id", project.ID, "name", name, "orgId", org.ID, - "repoId", repo.ID, + "repoFullName", repoFullName, "isGenerated", isGenerated, "isInMainBranch", isInMainBranch)) return project, nil @@ -1600,105 +1631,34 @@ func validateDiggerConfigYaml(configYaml string) (*configuration.DiggerConfig, e return diggerConfig, nil } -func (db *Database) UpdateRepoDiggerConfig(orgId any, config configuration.DiggerConfigYaml, repo *Repo, isMainBranch bool) error { - slog.Info("updating repo digger config", - "repoId", repo.ID, - "repoName", repo.Name, - "orgId", orgId, - "isMainBranch", isMainBranch) +func (db *Database) RefreshProjectsFromRepo(orgId string, config configuration.DiggerConfigYaml, repoFullName string) error { + slog.Debug("UpdateRepoDiggerConfig, repo", "repoFullName", repoFullName) org, err := db.GetOrganisationById(orgId) if err != nil { - slog.Error("failed to get organisation", - "orgId", orgId, - "error", err) - return err + return fmt.Errorf("error retrieving org by name: %v", err) } err = db.GormDB.Transaction(func(tx *gorm.DB) error { - if isMainBranch { - // we reset all projects already in main branch to create new projects - repoProjects, err := db.GetProjectByRepo(orgId, repo) - if err != nil { - slog.Error("could not get repo projects", - "repoId", repo.ID, - "orgId", orgId, - "error", err) - return fmt.Errorf("could not get repo projects: %v", err) - } - - slog.Info("resetting main branch flag for existing projects", - "projectCount", len(repoProjects), - "repoId", repo.ID) - - for _, rp := range repoProjects { - rp.IsInMainBranch = false - err = db.UpdateProject(&rp) - if err != nil { - slog.Error("could not update existing main branch project", - "projectId", rp.ID, - "error", err) - return fmt.Errorf("could not update existing main branch projects: %v", err) - } - } - } - - slog.Info("processing projects from config", - "projectCount", len(config.Projects), - "repoId", repo.ID) - for _, dc := range config.Projects { projectName := dc.Name - p, err := db.GetProjectByName(orgId, repo, projectName) + p, err := db.GetProjectByName(orgId, repoFullName, projectName) if err != nil { - slog.Error("error retrieving project by name", - "projectName", projectName, - "repoId", repo.ID, - "error", err) return fmt.Errorf("error retrieving project by name: %v", err) } - if p == nil { - slog.Info("creating new project", - "projectName", projectName, - "repoId", repo.ID, - "isGenerated", dc.Generated, - "isMainBranch", isMainBranch) - - _, err := db.CreateProject(projectName, org, repo, dc.Generated, isMainBranch) + _, err := db.CreateProject(projectName, org, repoFullName, false, true) if err != nil { - slog.Error("could not create project", - "projectName", projectName, - "error", err) return fmt.Errorf("could not create project: %v", err) } - } else { - slog.Info("updating existing project", - "projectId", p.ID, - "projectName", projectName, - "isGenerated", dc.Generated, - "isMainBranch", isMainBranch) - - if isMainBranch == true { - p.IsInMainBranch = isMainBranch - } - p.IsGenerated = dc.Generated - db.UpdateProject(p) } } return nil }) if err != nil { - slog.Error("error while updating projects from config", - "repoId", repo.ID, - "error", err) return fmt.Errorf("error while updating projects from config: %v", err) } - - slog.Info("successfully updated repo digger config", - "repoId", repo.ID, - "projectCount", len(config.Projects)) return nil } diff --git a/backend/services/repos.go b/backend/services/repos.go new file mode 100644 index 00000000..ce16108a --- /dev/null +++ b/backend/services/repos.go @@ -0,0 +1,59 @@ +package services + +import ( + "fmt" + "github.com/diggerhq/digger/backend/models" + utils3 "github.com/diggerhq/digger/backend/utils" + "github.com/diggerhq/digger/ee/drift/utils" + dg_configuration "github.com/diggerhq/digger/libs/digger_config" + utils2 "github.com/diggerhq/digger/next/utils" + "log/slog" + "strconv" + "strings" +) + +func LoadProjectsFromGithubRepo(gh utils2.GithubClientProvider, installationId string, repoFullName string, repoOwner string, repoName string, cloneUrl string, branch string) error { + installationId64, err := strconv.ParseInt(installationId, 10, 64) + if err != nil { + slog.Error("failed to convert installation id %v to int64", "insallationId", installationId) + return fmt.Errorf("failed to convert installation id to int64") + } + link, err := models.DB.GetGithubAppInstallationLink(installationId64) + if err != nil { + slog.Error("getting GetGithubAppInstallationLink: %v", "installationId", installationId, "error", err) + return fmt.Errorf("error getting github app link") + } + + orgId := link.OrganisationId + diggerRepoName := strings.ReplaceAll(repoFullName, "/", "-") + repo, err := models.DB.GetRepo(orgId, diggerRepoName) + if err != nil { + slog.Error("getting Repo", "repoName", diggerRepoName, "error", err) + return fmt.Errorf("error getting github app link") + } + if repo == nil { + slog.Error("Repo not found", "orgId", orgId, "repoName", diggerRepoName, "error", err) + return fmt.Errorf("repo not found: Org: %v | repo: %v", orgId, diggerRepoName) + } + + _, token, err := utils.GetGithubService(gh, installationId64, repoFullName, repoOwner, repoName) + if err != nil { + slog.Error("getting github service", "error", err) + return fmt.Errorf("error getting github service") + } + + err = utils3.CloneGitRepoAndDoAction(cloneUrl, branch, "", *token, "", func(dir string) error { + config, err := dg_configuration.LoadDiggerConfigYaml(dir, true, nil) + if err != nil { + slog.Error("failed to load digger.yml: %v", "error", err) + return fmt.Errorf("error loading digger.yml %v", err) + } + models.DB.RefreshProjectsFromRepo(strconv.Itoa(int(link.OrganisationId)), *config, repoFullName) + return nil + }) + if err != nil { + return fmt.Errorf("error while cloning repo: %v", err) + } + + return nil +} diff --git a/backend/tasks/runs_test.go b/backend/tasks/runs_test.go index eafaec17..9f74d313 100644 --- a/backend/tasks/runs_test.go +++ b/backend/tasks/runs_test.go @@ -74,7 +74,7 @@ func setupSuite(tb testing.TB) (func(tb testing.TB), *models.Database) { // create test project projectName := "test project" - _, err = database.CreateProject(projectName, org, repo, false, false) + _, err = database.CreateProject(projectName, org, repo.RepoFullName, false, false) if err != nil { panic(err) } @@ -140,7 +140,7 @@ func TestThatRunQueueItemMovesFromQueuedToPlanningAfterPickup(t *testing.T) { for i, testParam := range testParameters { ciService := github2.MockCiService{} batch, _ := models.DB.CreateDiggerBatch(models.DiggerVCSGithub, 123, "", "", "", 22, "", "", "", nil, 0, "", false, true, nil) - project, _ := models.DB.CreateProject(fmt.Sprintf("test%v", i), nil, nil, false, false) + project, _ := models.DB.CreateProject(fmt.Sprintf("test%v", i), nil, "", false, false) planStage, _ := models.DB.CreateDiggerRunStage(batch.ID.String()) applyStage, _ := models.DB.CreateDiggerRunStage(batch.ID.String()) diggerRun, _ := models.DB.CreateDiggerRun("", 1, testParam.InitialStatus, "sha", "", 123, 1, project.Name, "apply", &planStage.ID, &applyStage.ID) diff --git a/ee/backend/controllers/gitlab.go b/ee/backend/controllers/gitlab.go index fec5ed4e..8cd099a9 100644 --- a/ee/backend/controllers/gitlab.go +++ b/ee/backend/controllers/gitlab.go @@ -94,14 +94,7 @@ func (d DiggerEEController) GitlabWebHookHandler(c *gin.Context) { c.String(http.StatusInternalServerError, err.Error()) return } - case *gitlab.PushEvent: - log.Printf("Got push event for %v %v", event.Project.URL, event.Ref) - err := handlePushEvent(d.GitlabProvider, event, organisationId) - if err != nil { - log.Printf("handlePushEvent error: %v", err) - c.String(http.StatusInternalServerError, err.Error()) - return - } + default: log.Printf("Unhandled event, event type %v", reflect.TypeOf(event)) } @@ -109,71 +102,6 @@ func (d DiggerEEController) GitlabWebHookHandler(c *gin.Context) { c.JSON(200, "ok") } -func handlePushEvent(gh utils.GitlabProvider, payload *gitlab.PushEvent, organisationId uint) error { - //projectId := payload.Project.ID - repoFullName := payload.Project.PathWithNamespace - repoOwner, repoName, _ := strings.Cut(repoFullName, "/") - cloneURL := payload.Project.GitHTTPURL - webURL := payload.Project.WebURL - ref := payload.Ref - defaultBranch := payload.Project.DefaultBranch - - pushBranch := "" - if strings.HasPrefix(ref, "refs/heads/") { - pushBranch = strings.TrimPrefix(ref, "refs/heads/") - } else { - log.Printf("push was not to a branch, ignoring %v", ref) - return nil - } - - diggerRepoName := strings.ReplaceAll(repoFullName, "/", "-") - //repo, err := models.DB.GetRepo(organisationId, diggerRepoName) - //if err != nil { - // log.Printf("Error getting Repo: %v", err) - // return fmt.Errorf("error getting github app link") - //} - // create repo if not exists - org, err := models.DB.GetOrganisationById(organisationId) - if err != nil { - log.Printf("Error: could not get organisation: %v", err) - return nil - } - - repo, err := models.DB.CreateRepo(diggerRepoName, repoFullName, repoOwner, repoName, webURL, org, "") - if err != nil { - log.Printf("Error: could not create repo: %v", err) - return nil - } - - token := os.Getenv("DIGGER_GITLAB_ACCESS_TOKEN") - if token == "" { - log.Printf("could not find gitlab token: %v", err) - return fmt.Errorf("could not find gitlab token") - } - - var isMainBranch bool - if strings.HasSuffix(ref, defaultBranch) { - isMainBranch = true - } else { - isMainBranch = false - } - - err = utils.CloneGitRepoAndDoAction(cloneURL, pushBranch, "", token, "", func(dir string) error { - config, err := dg_configuration.LoadDiggerConfigYaml(dir, true, nil) - if err != nil { - log.Printf("ERROR load digger.yml: %v", err) - return fmt.Errorf("error loading digger.yml %v", err) - } - models.DB.UpdateRepoDiggerConfig(organisationId, *config, repo, isMainBranch) - return nil - }) - if err != nil { - return fmt.Errorf("error while cloning repo: %v", err) - } - - return nil -} - func GetGitlabRepoUrl(event interface{}) string { var repoUrl = "" switch event := event.(type) { diff --git a/ee/backend/controllers/web.go b/ee/backend/controllers/web.go index 4da55bb9..bda53f63 100644 --- a/ee/backend/controllers/web.go +++ b/ee/backend/controllers/web.go @@ -95,7 +95,10 @@ func (web *WebController) PoliciesPage(c *gin.Context) { } func (web *WebController) AddPolicyPage(c *gin.Context) { + orgId := c.GetHeader(middleware.ORGANISATION_ID_KEY) + if c.Request.Method == "GET" { + message := "" projects, done := models.DB.GetProjectsFromContext(c, middleware.ORGANISATION_ID_KEY) if !done { @@ -138,9 +141,17 @@ func (web *WebController) AddPolicyPage(c *gin.Context) { c.HTML(http.StatusOK, "policy_add.tmpl", pageContext) } - log.Printf("repo: %v\n", project.Repo) + log.Printf("repo: %v\n", project.RepoFullName) - policy := models.Policy{Project: project, Policy: policyText, Type: policyType, Organisation: project.Organisation, Repo: project.Repo} + repo, err := models.DB.GetRepoByFullName(orgId, project.RepoFullName) + if err != nil { + log.Printf("Failed to fetch repo by name: %v, %v\n", project.RepoFullName, err) + message := "Failed to create a policy" + services.AddError(c, message) + pageContext := services.GetMessages(c) + c.HTML(http.StatusOK, "policy_add.tmpl", pageContext) + } + policy := models.Policy{Project: project, Policy: policyText, Type: policyType, Organisation: project.Organisation, Repo: repo} err = models.DB.GormDB.Create(&policy).Error if err != nil {