provider_user.go

package gitproviders

import (
	"context"
	"errors"
	"fmt"

	"github.com/fluxcd/go-git-providers/gitprovider"
)

type userGitProvider struct {
	domain   string
	provider gitprovider.Client
}

var _ GitProvider = userGitProvider{}

func (p userGitProvider) RepositoryExists(ctx context.Context, repoUrl RepoURL) (bool, error) {
	userRepoRef := gitprovider.UserRepositoryRef{
		UserRef:        gitprovider.UserRef{Domain: p.domain, UserLogin: repoUrl.Owner()},
		RepositoryName: repoUrl.RepositoryName(),
	}
	if _, err := p.provider.UserRepositories().Get(ctx, userRepoRef); err != nil {
		if errors.Is(err, gitprovider.ErrNotFound) {
			return false, nil
		}

		return false, fmt.Errorf("could not get verify repository exists  %w", err)
	}

	return true, nil
}

func (p userGitProvider) DeployKeyExists(ctx context.Context, repoUrl RepoURL) (bool, error) {
	userRepo, err := p.getUserRepo(ctx, repoUrl)
	if err != nil {
		return false, fmt.Errorf("error getting user repo reference for owner %s, repo %s, %w", repoUrl.Owner(), repoUrl.RepositoryName(), err)
	}

	return deployKeyExists(ctx, userRepo)
}

func (p userGitProvider) UploadDeployKey(ctx context.Context, repoUrl RepoURL, deployKey []byte) error {
	userRepo, err := p.getUserRepo(ctx, repoUrl)
	if err != nil {
		return fmt.Errorf("error getting user repo reference for owner %s, repo %s, %w", repoUrl.Owner(), repoUrl.RepositoryName(), err)
	}

	fmt.Println("uploading deploy key")

	deployKeyInfo := gitprovider.DeployKeyInfo{
		Name:     deployKeyName,
		Key:      deployKey,
		ReadOnly: gitprovider.BoolVar(false),
	}

	return uploadDeployKey(ctx, userRepo, deployKeyInfo)
}

func (p userGitProvider) GetDefaultBranch(ctx context.Context, repoUrl RepoURL) (string, error) {
	repoInfoRef, err := p.getRepoInfoFromUrl(ctx, repoUrl)
	if err != nil {
		return "main", err
	}

	return *repoInfoRef.DefaultBranch, nil
}

func (p userGitProvider) GetRepoVisibility(ctx context.Context, repoUrl RepoURL) (*gitprovider.RepositoryVisibility, error) {
	repoInfoRef, err := p.getRepoInfoFromUrl(ctx, repoUrl)
	if err != nil {
		return nil, err
	}

	return repoInfoRef.Visibility, nil
}

func (p userGitProvider) getRepoInfoFromUrl(ctx context.Context, repoUrl RepoURL) (*gitprovider.RepositoryInfo, error) {
	repo, err := p.getUserRepo(ctx, repoUrl)
	if err != nil {
		return nil, err
	}

	repoInfo := repo.Get()

	return &repoInfo, nil
}

func (p userGitProvider) getUserRepo(ctx context.Context, repoUrl RepoURL) (gitprovider.UserRepository, error) {
	repo, err := p.provider.UserRepositories().Get(ctx, newUserRepositoryRef(p.domain, repoUrl.Owner(), repoUrl.RepositoryName()))
	if err != nil {
		return nil, fmt.Errorf("error getting user repository %w", err)
	}

	return repo, nil
}

func (p userGitProvider) CreatePullRequest(ctx context.Context, repoUrl RepoURL, prInfo PullRequestInfo) (gitprovider.PullRequest, error) {
	userRepo, err := p.getUserRepo(ctx, repoUrl)
	if err != nil {
		return nil, fmt.Errorf("error getting user repo for owner %s, repo %s, %w", repoUrl.Owner(), repoUrl.RepositoryName(), err)
	}

	return createPullRequest(ctx, userRepo, prInfo)
}

func (p userGitProvider) GetCommits(ctx context.Context, repoUrl RepoURL, targetBranch string, pageSize int, pageToken int) ([]gitprovider.Commit, error) {
	userRepo, err := p.getUserRepo(ctx, repoUrl)
	if err != nil {
		return nil, fmt.Errorf("error getting repo for owner %s, repo %s, %w", repoUrl.Owner(), repoUrl.RepositoryName(), err)
	}

	return getCommits(ctx, userRepo, targetBranch, pageSize, pageToken)
}

func (p userGitProvider) GetProviderDomain() string {
	return getProviderDomain(p.provider.ProviderID())
}