Error Handling

rajatasusual · rajatasusual · commit f3bc8fa4a477 · 2024-11-02T17:23:45.000Z
1. 429 now prompts for entering a new API Token
2. Handling panic exits for user not available and nil pointer errors
diff --git a/cmd/handlers.go b/cmd/handlers.go
@@ -3,6 +3,7 @@ package cmd
 import (
 	"context"
 	"fmt"
+	"go-github/helper"
 	"go-github/service"
 	"go-github/views"
 
@@ -25,7 +26,7 @@ func handleMainPage(ctx *gin.Context) {
 	if strings.TrimSpace(ctx.Query("username")) == "" {
 		getIndexHandler(ctx)
 	} else {
-		getUserHandler(ctx)
+		getUserHandler(ctx, false)
 	}
 }
 
@@ -39,26 +40,33 @@ func getIndexHandler(ctx *gin.Context) {
 	render(ctx, http.StatusOK, views.Index(emptyUser))
 }
 
-func getUserHandler(ctx *gin.Context) {
-	_, cancel := context.WithTimeout(context.Background(), appTimeout)
-	username := ctx.Query("username")
-	username = strings.TrimSpace(username)
-
-	defer cancel()
-
+func getUser(ctx *gin.Context, username string, force bool) {
 	user, err := service.FetchEntryFromXata(username)
 
 	if err != nil {
 		fmt.Println(err)
-		user, _ = service.FetchGitHubProfile(username)
-		if user == nil {
-			user = &views.GitHubUser{
-				Name: "User not found",
+		var err error
+		user, err = service.FetchGitHubProfile(username, force)
+
+		fmt.Println(err)
+		if err != nil {
+			if strings.Contains(err.Error(), "404") {
+				user = &views.GitHubUser{
+					Name: "User not found",
+				}
+				ctx.JSON(http.StatusNotFound, user)
+			} else if strings.Contains(err.Error(), "429") {
+				ctx.JSON(http.StatusTooManyRequests, gin.H{
+					"error": err.Error(),
+				})
+			} else {
+				ctx.JSON(http.StatusInternalServerError, gin.H{
+					"error": err.Error(),
+				})
 			}
-			ctx.JSON(http.StatusNotFound, user)
 			return
 		}
-		_, err := service.CreateNewEntry(user)
+		_, err = service.CreateNewEntry(user)
 		if err != nil {
 			fmt.Println(err)
 		}
@@ -67,3 +75,54 @@ func getUserHandler(ctx *gin.Context) {
 	//serve user as JSON
 	ctx.JSON(http.StatusOK, user)
 }
+
+func getUserHandler(ctx *gin.Context, force bool) {
+	_, cancel := context.WithTimeout(context.Background(), appTimeout)
+	username := ctx.Query("username")
+	username = strings.TrimSpace(username)
+
+	defer cancel()
+
+	if username == "" {
+		ctx.JSON(http.StatusBadRequest, gin.H{
+			"error": "username is required",
+		})
+		return
+	}
+
+	getUser(ctx, username, force)
+
+}
+
+func postTokenHandler(ctx *gin.Context) {
+	// get token
+
+	type TokenRequest struct {
+		Token    string `json:"token"`
+		Username string `json:"username"`
+	}
+
+	request := TokenRequest{}
+	if err := ctx.ShouldBindJSON(&request); err != nil {
+		ctx.JSON(http.StatusBadRequest, gin.H{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	token := request.Token
+	username := request.Username
+
+	if strings.TrimSpace(token) != "" {
+		err := helper.SetEnvVariable("GITHUB_TOKEN", token)
+
+		if err != nil {
+			ctx.JSON(http.StatusBadRequest, gin.H{
+				"error": err.Error(),
+			})
+			return
+		}
+
+		getUser(ctx, username, true)
+	}
+}
diff --git a/cmd/routes.go b/cmd/routes.go
@@ -20,6 +20,8 @@ func (app *Config) Routes() {
 		})
 	})
 
+	app.Router.POST("/token", postTokenHandler)
+
 	app.Router.NoRoute(func(ctx *gin.Context) {
 		ctx.Status(http.StatusNotFound)
 	})
diff --git a/helper/github-helper.go b/helper/github-helper.go
@@ -8,51 +8,57 @@ import (
 	"golang.org/x/oauth2"
 )
 
-var githubAPIKey = GetEnvVariable("GITHUB_TOKEN")
-
 type GithubClientSingleton struct {
 	GithubClient *github.Client
-	apiKey       string
 }
 
 var githubInstance *GithubClientSingleton
 
-func GetGithubClientInstance() *GithubClientSingleton {
-	if githubInstance == nil {
+func GetGithubClientInstance(force bool) *GithubClientSingleton {
+
+	if force {
 		lock.Lock()
+		createGithubClient()
 		defer lock.Unlock()
-		if githubInstance == nil {
-			fmt.Println("Creating single instance now.")
-			githubInstance = &GithubClientSingleton{
-				apiKey: xataAPIKey,
-			}
-
-			githubInstance.GithubClient, _ = createGithubClient()
+	}
 
+	if githubInstance == nil {
+		lock.Lock()
+		if githubInstance == nil || githubInstance.GithubClient == nil {
+			err := createGithubClient()
+			if err != nil {
+				fmt.Println(err)
+			}
 		}
+		defer lock.Unlock()
 	}
 
 	return githubInstance
 }
 
-func createGithubClient() (*github.Client, error) {
-	ctx := context.Background()
+func createGithubClient() error {
+	fmt.Println("Creating github instance now.")
+	githubInstance = &GithubClientSingleton{}
 
+	ctx := context.Background()
+	githubAPIKey := GetEnvVariable("GITHUB_TOKEN")
 	if githubAPIKey != "" {
 		ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: githubAPIKey})
 		tc := oauth2.NewClient(ctx, ts)
-		return github.NewClient(tc), nil
+		githubInstance.GithubClient = github.NewClient(tc)
 	} else {
-		return github.NewClient(nil), nil
+		githubInstance.GithubClient = github.NewClient(nil)
 	}
+
+	return nil
 }
 
-func GetGithubUser(ctx context.Context, username string) (*github.User, error) {
+func GetGithubUser(ctx context.Context, username string, force bool) (*github.User, error) {
 	// Fetch user profile
-	user, _, err := GetGithubClientInstance().GithubClient.Users.Get(ctx, username)
+	user, _, err := GetGithubClientInstance(force).GithubClient.Users.Get(ctx, username)
 	if err != nil {
 		if rateLimitErr, ok := err.(*github.RateLimitError); ok {
-			return nil, fmt.Errorf("GitHub API rate limit exceeded: %v", rateLimitErr.Message)
+			return nil, fmt.Errorf("429: %v", rateLimitErr.Message)
 		}
 		return nil, err
 	}
@@ -61,19 +67,19 @@ func GetGithubUser(ctx context.Context, username string) (*github.User, error) {
 
 func GetRepos(ctx context.Context, username string) ([]*github.Repository, error) {
 	// Fetch repositories contributed to by the user
-	repos, _, err := GetGithubClientInstance().GithubClient.Repositories.List(ctx, username, &github.RepositoryListOptions{
+	repos, _, err := GetGithubClientInstance(false).GithubClient.Repositories.List(ctx, username, &github.RepositoryListOptions{
 		Sort: "updated",
 	})
 	if err != nil {
-		return nil, fmt.Errorf("failed to fetch repositories: %v", err)
+		return nil, err
 	}
 	return repos, nil
 }
 
 func GetCommits(ctx context.Context, repo *github.Repository, opts *github.CommitsListOptions) ([]*github.RepositoryCommit, *github.Response, error) {
-	commits, resp, err := GetGithubClientInstance().GithubClient.Repositories.ListCommits(ctx, *repo.Owner.Login, *repo.Name, opts)
+	commits, resp, err := GetGithubClientInstance(false).GithubClient.Repositories.ListCommits(ctx, *repo.Owner.Login, *repo.Name, opts)
 	if err != nil {
-		return nil, resp, fmt.Errorf("failed to fetch commits: %v", err)
+		return nil, resp, err
 	}
 	return commits, resp, nil
 }
diff --git a/helper/helper.go b/helper/helper.go
@@ -23,6 +23,28 @@ func GetEnvVariable(key string) string {
 	return os.Getenv(key)
 }
 
+func SetEnvVariable(key string, value string) error {
+	err := godotenv.Load()
+	if err != nil {
+		log.Fatal("Error loading .env file")
+	}
+	return os.Setenv(key, value)
+}
+
+func GetStringValue(s *string) string {
+	if s != nil {
+		return *s
+	}
+	return ""
+}
+
+func GetIntValue(i *int) int {
+	if i != nil {
+		return *i
+	}
+	return 0
+}
+
 func PopulateGitHubUser(recordRetrieved *xata.Record) (*views.GitHubUser, error) {
 	user := &views.GitHubUser{}
 	userValue := reflect.ValueOf(user).Elem()
diff --git a/helper/xata-helper.go b/helper/xata-helper.go
@@ -24,28 +24,28 @@ type RecordsClientSingleton struct {
 	url           string
 }
 
-var singleInstance *RecordsClientSingleton
+var recordsClientInstance *RecordsClientSingleton
 var lock = &sync.Mutex{}
 
 func GetRecordsClientInstance() *RecordsClientSingleton {
-	if singleInstance == nil {
+	if recordsClientInstance == nil {
 		lock.Lock()
 		defer lock.Unlock()
-		if singleInstance == nil {
-			fmt.Println("Creating single instance now.")
-			singleInstance = &RecordsClientSingleton{
+		if recordsClientInstance == nil {
+			fmt.Println("Creating xata instance now.")
+			recordsClientInstance = &RecordsClientSingleton{
 				apiKey:       xataAPIKey,
 				DatabaseName: databaseName,
 				TableName:    tableName,
 				url:          xataURL,
 			}
 
-			singleInstance.RecordsClient, _ = createRecordsClient()
+			recordsClientInstance.RecordsClient, _ = createRecordsClient()
 
 		}
 	}
 
-	return singleInstance
+	return recordsClientInstance
 }
 
 func createRecordsClient() (xata.RecordsClient, error) {
@@ -64,15 +64,28 @@ func GetRecordFromXata(ctx context.Context, id string) (*xata.Record, error) {
 		},
 		RecordID: id,
 	}
-	return GetRecordsClientInstance().RecordsClient.Get(ctx, getRecordRequest)
+
+	recordClient := GetRecordsClientInstance().RecordsClient
+	if recordClient == nil {
+		return nil, fmt.Errorf("RecordsClient instance is nil")
+	}
+	record, err := recordClient.Get(ctx, getRecordRequest)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get record: %v", err)
+	}
+	return record, nil
 }
 
 func SetRecordInXata(ctx context.Context, record *views.GitHubUser) (xata.Record, error) {
 
 	insertRecordRequest := GenerateInsertRecordRequest(record)
 	insertRecordRequest.Body["CommitHistory"] = ToXataValue(record.CommitHistory) // Add CommitHistory to request
 
-	createdRecord, err := GetRecordsClientInstance().RecordsClient.InsertWithID(ctx, insertRecordRequest)
+	recordClient := GetRecordsClientInstance().RecordsClient
+	if recordClient == nil {
+		return xata.Record{}, fmt.Errorf("RecordsClient instance is nil")
+	}
+	createdRecord, err := recordClient.InsertWithID(ctx, insertRecordRequest)
 
 	if err != nil {
 		return *createdRecord, fmt.Errorf("failed to insert record: %v", err)
diff --git a/service/github-service.go b/service/github-service.go
diff --git a/views/index.templ b/views/index.templ
