395 lines
11 KiB
Go
395 lines
11 KiB
Go
package github
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"log/slog"
|
|
"net/http"
|
|
"strconv"
|
|
|
|
"forge.cadoles.com/wpetit/clearcase/internal/core/model"
|
|
"forge.cadoles.com/wpetit/clearcase/internal/core/port"
|
|
"forge.cadoles.com/wpetit/clearcase/internal/core/service"
|
|
"github.com/google/go-github/v69/github"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
type Forge struct {
|
|
client *github.Client
|
|
}
|
|
|
|
// UpdatePullRequest implements port.Forge.
|
|
func (f *Forge) UpdatePullRequest(ctx context.Context, rawProjectID string, rawPullRequestID string, title string, body string) (string, error) {
|
|
repo, err := f.getRepository(ctx, rawProjectID)
|
|
if err != nil {
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
pullRequestID, err := strconv.ParseInt(rawPullRequestID, 10, 64)
|
|
if err != nil {
|
|
return "", errors.Wrapf(err, "could not parse pull request id '%v'", rawPullRequestID)
|
|
}
|
|
|
|
pr, res, err := f.client.PullRequests.Edit(ctx, *repo.Owner.Login, *repo.Name, int(pullRequestID), &github.PullRequest{
|
|
Title: &title,
|
|
Body: &body,
|
|
})
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not edit pull request", slog.Any("error", errors.WithStack(err)))
|
|
return "", errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
return *pr.HTMLURL, nil
|
|
}
|
|
|
|
// GetPullRequestTemplate implements port.Forge.
|
|
func (f *Forge) GetPullRequestTemplate(ctx context.Context, projectID string) (string, error) {
|
|
data, err := f.GetFile(ctx, projectID, ".github/PULL_REQUEST_TEMPLATE/pull_request_template.md")
|
|
if err != nil {
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
return string(data), nil
|
|
}
|
|
|
|
// GetPullRequestDiff implements port.Forge.
|
|
func (f *Forge) GetPullRequests(ctx context.Context, projectID string, pullRequestIDs ...string) ([]*model.PullRequest, error) {
|
|
repo, err := f.getRepository(ctx, projectID)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
pullRequests := make([]*model.PullRequest, 0)
|
|
for _, rawID := range pullRequestIDs {
|
|
id, err := strconv.ParseInt(rawID, 10, 64)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "could not parse pull request id '%v'", rawID)
|
|
}
|
|
|
|
pr, res, err := f.client.PullRequests.Get(ctx, *repo.Owner.Login, *repo.Name, int(id))
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not retrieve repository pull requests", slog.Any("error", errors.WithStack(err)))
|
|
return nil, errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
var body string
|
|
if pr.Body != nil {
|
|
body = *pr.Body
|
|
}
|
|
|
|
var title string
|
|
if pr.Title != nil {
|
|
title = *pr.Title
|
|
}
|
|
|
|
pullRequests = append(pullRequests, &model.PullRequest{
|
|
ID: strconv.FormatInt(*pr.ID, 10),
|
|
Title: title,
|
|
Body: body,
|
|
})
|
|
}
|
|
|
|
return pullRequests, nil
|
|
}
|
|
|
|
// GetPullRequestDiff implements port.Forge.
|
|
func (f *Forge) GetPullRequestDiff(ctx context.Context, projectID string, rawPullRequestID string) (string, error) {
|
|
repo, err := f.getRepository(ctx, projectID)
|
|
if err != nil {
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
pullRequestID, err := strconv.ParseInt(rawPullRequestID, 10, 64)
|
|
if err != nil {
|
|
return "", errors.Wrapf(err, "could not parse pull request id '%v'", pullRequestID)
|
|
}
|
|
|
|
diff, res, err := f.client.PullRequests.GetRaw(ctx, *repo.Owner.Login, *repo.Name, int(pullRequestID), github.RawOptions{
|
|
Type: github.Diff,
|
|
})
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not retrieve pull request diff", slog.Any("error", errors.WithStack(err)))
|
|
return "", errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
return diff, nil
|
|
}
|
|
|
|
// ListOpenedPullRequests implements port.Forge.
|
|
func (f *Forge) ListOpenedPullRequests(ctx context.Context, projectID string) ([]*model.PullRequest, error) {
|
|
repo, err := f.getRepository(ctx, projectID)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
pullRequests := make([]*model.PullRequest, 0)
|
|
|
|
page := 1
|
|
for {
|
|
repoPullRequests, res, err := f.client.PullRequests.List(ctx, *repo.Owner.Login, *repo.Name, &github.PullRequestListOptions{
|
|
State: "opened",
|
|
ListOptions: github.ListOptions{
|
|
Page: page,
|
|
PerPage: 100,
|
|
},
|
|
})
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not retrieve repository pull requests", slog.Any("error", errors.WithStack(err)))
|
|
return nil, errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
for _, pr := range repoPullRequests {
|
|
var body string
|
|
if pr.Body != nil {
|
|
body = *pr.Body
|
|
}
|
|
|
|
var title string
|
|
if pr.Title != nil {
|
|
title = *pr.Title
|
|
}
|
|
|
|
pullRequests = append(pullRequests, &model.PullRequest{
|
|
ID: strconv.FormatInt(*pr.ID, 10),
|
|
Title: title,
|
|
Body: body,
|
|
})
|
|
}
|
|
|
|
if res.NextPage == 0 {
|
|
return pullRequests, nil
|
|
}
|
|
|
|
page = res.NextPage
|
|
}
|
|
}
|
|
|
|
// CreateIssue implements port.Forge.
|
|
func (f *Forge) CreateIssue(ctx context.Context, projectID string, title string, body string) (string, error) {
|
|
repo, err := f.getRepository(ctx, projectID)
|
|
if err != nil {
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
issue, res, err := f.client.Issues.Create(ctx, *repo.Owner.Login, *repo.Name, &github.IssueRequest{
|
|
Title: &title,
|
|
Body: &body,
|
|
})
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not create issue", slog.Any("error", errors.WithStack(err)))
|
|
return "", errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
return *issue.HTMLURL, nil
|
|
}
|
|
|
|
// ListProjects implements port.Forge.
|
|
func (f *Forge) ListProjects(ctx context.Context) ([]*model.Project, error) {
|
|
projects := make([]*model.Project, 0)
|
|
|
|
page := 1
|
|
for {
|
|
repos, res, err := f.client.Repositories.ListByAuthenticatedUser(ctx, &github.RepositoryListByAuthenticatedUserOptions{
|
|
Type: "all",
|
|
ListOptions: github.ListOptions{
|
|
Page: page,
|
|
PerPage: 100,
|
|
},
|
|
})
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not retrieve user repositories", slog.Any("error", errors.WithStack(err)))
|
|
return nil, errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
for _, r := range repos {
|
|
if r.ID == nil || r.FullName == nil {
|
|
continue
|
|
}
|
|
|
|
var projectDescription string
|
|
if r.Description != nil {
|
|
projectDescription = *r.Description
|
|
}
|
|
|
|
projects = append(projects, &model.Project{
|
|
ID: strconv.FormatInt(*r.ID, 10),
|
|
Name: *r.FullName,
|
|
Description: projectDescription,
|
|
})
|
|
|
|
}
|
|
|
|
if res.NextPage == 0 {
|
|
return projects, nil
|
|
}
|
|
|
|
page = res.NextPage
|
|
}
|
|
}
|
|
|
|
// GetFile implements port.Forge.
|
|
func (f *Forge) GetFile(ctx context.Context, rawProjectID string, path string) ([]byte, error) {
|
|
repo, err := f.getRepository(ctx, rawProjectID)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
fileContent, _, res, err := f.client.Repositories.GetContents(ctx, *repo.Owner.Login, *repo.Name, path, nil)
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not retrieve file content", slog.Any("error", errors.WithStack(err)))
|
|
return nil, errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
if res.StatusCode == http.StatusNotFound {
|
|
return nil, errors.WithStack(port.ErrFileNotFound)
|
|
}
|
|
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
decoded, err := base64.StdEncoding.DecodeString(*fileContent.Content)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
return decoded, nil
|
|
}
|
|
|
|
// GetIssueTemplate implements port.Forge.
|
|
func (f *Forge) GetIssueTemplate(ctx context.Context, projectID string) (string, error) {
|
|
data, err := f.GetFile(ctx, projectID, ".github/ISSUE_TEMPLATE/bug_report.md")
|
|
if err != nil {
|
|
return "", errors.WithStack(err)
|
|
}
|
|
|
|
return string(data), nil
|
|
}
|
|
|
|
// GetIssues implements port.Forge.
|
|
func (f *Forge) GetIssues(ctx context.Context, projectID string, issueIDs ...string) ([]*model.Issue, error) {
|
|
repo, err := f.getRepository(ctx, projectID)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
issues := make([]*model.Issue, 0)
|
|
for _, rawIssueID := range issueIDs {
|
|
issueID, err := strconv.ParseInt(rawIssueID, 10, 64)
|
|
if err != nil {
|
|
slog.ErrorContext(ctx, "could not parse issue id", slog.Any("error", errors.WithStack(err)))
|
|
issues = append(issues, nil)
|
|
continue
|
|
}
|
|
|
|
issue, _, err := f.client.Issues.Get(ctx, *repo.Owner.Login, *repo.Name, int(issueID))
|
|
if err != nil {
|
|
slog.ErrorContext(ctx, "could not parse retrieve issue", slog.Int("issueID", int(issueID)), slog.String("repository", *repo.FullName), slog.Any("error", errors.WithStack(err)))
|
|
issues = append(issues, nil)
|
|
continue
|
|
}
|
|
|
|
issues = append(issues, &model.Issue{
|
|
ID: strconv.FormatInt(*issue.ID, 10),
|
|
Title: *issue.Title,
|
|
Body: *issue.Body,
|
|
})
|
|
}
|
|
|
|
return issues, nil
|
|
}
|
|
|
|
// GetProject implements port.Forge.
|
|
func (f *Forge) GetProject(ctx context.Context, rawProjectID string) (*model.Project, error) {
|
|
repo, err := f.getRepository(ctx, rawProjectID)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
var projectDescription string
|
|
if repo.Description != nil {
|
|
projectDescription = *repo.Description
|
|
}
|
|
|
|
return &model.Project{
|
|
ID: strconv.FormatInt(*repo.ID, 10),
|
|
Name: *repo.Name,
|
|
Description: projectDescription,
|
|
}, nil
|
|
}
|
|
|
|
// GetProjectLanguages implements port.Forge.
|
|
func (f *Forge) GetProjectLanguages(ctx context.Context, rawProjectID string) ([]string, error) {
|
|
repo, err := f.getRepository(ctx, rawProjectID)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
mappedLanguages, res, err := f.client.Repositories.ListLanguages(ctx, *repo.Owner.Login, *repo.Name)
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not retrieve repository languages", slog.Any("error", errors.WithStack(err)))
|
|
return nil, errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
languages := make([]string, 0, len(mappedLanguages))
|
|
|
|
for l := range mappedLanguages {
|
|
languages = append(languages, l)
|
|
}
|
|
|
|
return languages, nil
|
|
}
|
|
|
|
func (f *Forge) getRepository(ctx context.Context, rawProjectID string) (*github.Repository, error) {
|
|
projectID, err := strconv.ParseInt(rawProjectID, 10, 64)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
repo, res, err := f.client.Repositories.GetByID(ctx, projectID)
|
|
if err != nil {
|
|
if res != nil && (res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized) {
|
|
slog.ErrorContext(ctx, "could not retrieve repository", slog.Any("error", errors.WithStack(err)))
|
|
return nil, errors.WithStack(service.ErrForgeNotAvailable)
|
|
}
|
|
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
return repo, nil
|
|
}
|
|
|
|
func NewForge(client *github.Client) *Forge {
|
|
return &Forge{client: client}
|
|
}
|
|
|
|
var _ port.Forge = &Forge{}
|