app.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
)

// App struct
type App struct {
	ctx context.Context
}

// NewApp creates a new App application struct
func NewApp() *App {
	return &App{}
}

// startup is called when the app starts. The context is saved
// so we can call the runtime methods
func (a *App) startup(ctx context.Context) {
	a.ctx = ctx
}

// Greet returns a greeting for the given name
func (a *App) Greet(name string) string {
	return fmt.Sprintf("Hello %s, It's show time!", name)
}

type APIResponse []interface{}
type Gist struct {
	Description string      `json:"description"`
	Public      bool        `json:"public"`
	Files       interface{} `json:"files"`
}

const BaseUrl = "https://api.github.com"

var githubResponse APIResponse

// Retrieves a list of public repositories from the GitHub API via a GET request.
// Since this route does not require authentication, an empty string is passed as the token.
func (a *App) GetPublicRepositories() (APIResponse, error) {
	url := fmt.Sprintf("%s/repositories", BaseUrl)
	response, err := MakeGetRequest(url, "")

	if err != nil {
		return nil, err
	}

	json.Unmarshal(response, &githubResponse)
	return githubResponse, nil
}

// Retrieves a list of public Gists from the GitHub API via a GET request.
// Authentication is also not required, hence an empty string is passed as the token.
func (a *App) GetPublicGists() (APIResponse, error) {
	url := fmt.Sprintf("%s/gists/public", BaseUrl)
	response, err := MakeGetRequest(url, "")

	if err != nil {
		return nil, err
	}

	json.Unmarshal(response, &githubResponse)
	return githubResponse, nil
}

// Used to get a list of the authenticated user’s private repositories.
// This function takes the token as a parameter.
func (a *App) GetRepositoriesForAuthenticatedUser(token string) (APIResponse, error) {
	url := fmt.Sprintf("%s/user/repos?type=private", BaseUrl)
	response, err := MakeGetRequest(url, token)

	if err != nil {
		return nil, err
	}

	json.Unmarshal(response, &githubResponse)
	return githubResponse, nil
}

// Used to retrieve the authenticated user’s Gists.
// This function also takes a token as a parameter.
func (a *App) GetGistsForAuthenticatedUser(token string) (APIResponse, error) {
	url := fmt.Sprintf("%s/gists", BaseUrl)
	response, err := MakeGetRequest(url, token)

	if err != nil {
		return nil, err
	}

	json.Unmarshal(response, &githubResponse)
	return githubResponse, nil
}

// Used to get more information on a repository. This information could be the commit history,
// list of contributors, or list of users who have starred the repository. It takes two
// parameters, the url to be called and the authentication token. For public repositories,
// the token will be an empty string.
func (a *App) GetMoreInformationFromURL(url, token string) (APIResponse, error) {
	response, err := MakeGetRequest(url, token)

	if err != nil {
		return nil, err
	}

	json.Unmarshal(response, &githubResponse)
	return githubResponse, nil
}

// Used to get the content of a Gist. This function takes the URL for the Gist’s raw content
// and an authentication token (an empty string for public Gists). It returns a string
// corresponding to the content of the Gist.
func (a *App) GetGistContent(url, token string) (string, error) {
	githubResponse, err := MakeGetRequest(url, token)

	if err != nil {
		return "", err
	}

	return string(githubResponse), nil
}

// Used to create a new Gist for the authenticated user. This function takes two parameters,
// the Gist to be created as well as the authentication token for the user.
func (a *App) CreateNewGist(gist Gist, token string) (interface{}, error) {
	var githubResponse interface{}

	requestBody, _ := json.Marshal(gist)
	url := fmt.Sprintf("%s/gists", BaseUrl)
	response, err := MakePostRequest(url, token, requestBody)

	if err != nil {
		return nil, err
	}
	json.Unmarshal(response, &githubResponse)
	return githubResponse, nil
}