func main() {
client := octokit.NewClient(nil)
userURL := &octokit.UserURL
fmt.Println("Printing GitHub users for the first 5 pages")
for i := 0; i < 5; i++ {
if userURL == nil {
return
}
url, err := userURL.Expand(nil)
if err != nil {
fmt.Printf("error: %s\n", err)
return
}
users, result := client.Users(url).All()
if result.HasError() {
fmt.Println(result)
return
}
for _, user := range users {
fmt.Printf("%v - %s\n", user.ID, user.Login)
}
userURL = result.NextPage
}
}
func (gh *GitHub) octokit() *octokit.Client {
config := gh.Config
config.FetchCredentials()
tokenAuth := octokit.TokenAuth{AccessToken: config.Token}
return octokit.NewClient(tokenAuth)
}
func requestUsers(path string, a ...interface{}) ([]octokit.User, error) {
var users []octokit.User
var result *octokit.Result
uri := fmt.Sprintf(fmt.Sprintf("https://api.github.com%s", path), a...)
api, err := url.Parse(uri)
if err != nil {
log.Println(err)
return []octokit.User{}, err
}
for i := 0; i < maxRetrial; i++ {
token := selectToken()
client := octokit.NewClient(octokit.TokenAuth{token})
users, result = client.Users(api).All()
if !result.HasError() {
return users, nil
}
if IsNotFound(result.Err) {
return []octokit.User{}, result.Err
}
if isBadCredentials(result.Err) {
log.Println(result.Err)
removeToken(token)
}
time.Sleep(5 * time.Second)
}
log.Println(uri)
log.Println(result.Err)
return users, result.Err
}
func NewGitHubRepository(c *config.GitHubConfig) (repository.Repository, error) {
token, err := githubAuthToken(c)
if err != nil {
return nil, err
}
ghClient := octokit.NewClient(&octokit.TokenAuth{AccessToken: token})
owner, name, err := parseRepository(c.Repository)
if err != nil {
return nil, err
}
return &GitHubRepository{Owner: owner, Name: name, client: ghClient}, nil
}
func checkForUpdate(currVer string) *Update {
githubClient := octokit.NewClient(nil)
releaseURL, err := octokit.ReleasesURL.Expand(octokit.M{"owner": "smurfpandey", "repo": "mysqlweb"})
if err != nil {
return nil
}
releases, result := githubClient.Releases(releaseURL).All()
if result.HasError() {
return nil
}
latestRelease := releases[0]
isNew := compareVersion(currVer, latestRelease.TagName)
if isNew == 0 || isNew == -1 {
return nil
}
//We got a new release
//Better inform the user
//But let's make sure its not a Draft
if latestRelease.Draft {
return nil
}
update := Update{
Version: latestRelease.TagName,
ReleaseURL: latestRelease.HTMLURL,
Name: latestRelease.Name,
PreRelease: latestRelease.Prerelease,
PublishedAt: latestRelease.PublishedAt,
Body: latestRelease.Body,
}
return &update
}
func findOrCreateToken(user, password, twoFactorCode string) (token string, err error) {
basicAuth := octokit.BasicAuth{Login: user, Password: password, OneTimePassword: twoFactorCode}
client := octokit.NewClient(basicAuth)
authsService, err := client.Authorizations(nil, nil)
if err != nil {
return
}
auths, result := authsService.GetAll()
if result.HasError() {
err = result.Err
return
}
for _, auth := range auths {
if auth.NoteURL == OAuthAppURL {
token = auth.Token
break
}
}
if token == "" {
authParam := octokit.AuthorizationParams{}
authParam.Scopes = append(authParam.Scopes, "repo")
authParam.Note = "gh"
authParam.NoteURL = OAuthAppURL
auth, result := authsService.Create(authParam)
if result.HasError() {
err = result.Err
return
}
token = auth.Token
}
return
}
func NewGitHubFetcherWithToken(token string) *GitHubFetcher {
client := octokit.NewClient(&octokit.TokenAuth{AccessToken: token})
return &GitHubFetcher{client}
}
func NewGitHubFetcher() *GitHubFetcher {
client := octokit.NewClient(nil)
return &GitHubFetcher{client}
}
