copilot-extensions · Jan 13, 2025 · Jan 13, 2025 · Jan 13, 2025 · Jan 13, 2025 · Jan 13, 2025
Showing with 255 additions and 152 deletions.

+0 −33 handlers/commit_message.go

+102 −0 handlers/is_supported_or_eol.go

+62 −0 handlers/latest_version.go

+0 −116 handlers/loripsum.go

+88 −0 handlers/supported_versions.go

+3 −3 main.go
diff --git a/handlers/commit_message.go b/handlers/commit_message.go
diff --git a/handlers/is_supported_or_eol.go b/handlers/is_supported_or_eol.go
@@ -0,0 +1,102 @@
+package handlers
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+type ReleaseInfo struct {
+	ReleaseDate       string      `json:"releaseDate"`
+	EOL               interface{} `json:"eol"` // Can be a string or false
+	Latest            string      `json:"latest"`
+	LatestReleaseDate string      `json:"latestReleaseDate"`
+	LTS               bool        `json:"lts"`
+}
+
+func IsSupportedOrEOL(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("EOL check called")
+
+	params := &struct {
+		GoVersionOrRelease string `json:"go_version_or_release"`
+	}{}
+
+	err := json.NewDecoder(r.Body).Decode(&params)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	// Regular expression to match only numbers and periods
+	validPattern := regexp.MustCompile(`^\d+(\.\d+)*$`)
+
+	var url_path string
+	// Check if GoVersionOrRelease is not empty and matches the pattern
+	if params.GoVersionOrRelease != "" && validPattern.MatchString(params.GoVersionOrRelease) {
+		url_path = fmt.Sprintf("https://endoflife.date/api/go/%s.json", params.GoVersionOrRelease)
+	} else {
+		http.Error(w, "Invalid version specified", http.StatusNotFound)
+	}
+
+	req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, url_path, nil)
+	if err != nil {
+		http.Error(w, "Failed to create request", http.StatusInternalServerError)
+		return
+	}
+
+	resp, err := (&http.Client{}).Do(req)
+	if err != nil {
+		fmt.Println(err)
+		http.Error(w, "Failed to fetch data", http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusNotFound {
+		fmt.Fprintf(w, "No versions found matching %s.\n", params.GoVersionOrRelease)
+		return
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		http.Error(w, fmt.Sprintf("Unexpected status code: %d", resp.StatusCode), http.StatusInternalServerError)
+		return
+	}
+
+	// Buffer the response body for decoding
+	var bodyBuffer bytes.Buffer
+	tee := io.TeeReader(resp.Body, &bodyBuffer)
+
+	// Drain the tee to ensure we can parse the body later
+	if _, err := io.Copy(io.Discard, tee); err != nil {
+		http.Error(w, "Failed to process response body", http.StatusInternalServerError)
+		return
+	}
+
+	// Create a Decoder
+	decoder := json.NewDecoder(strings.NewReader(bodyBuffer.String()))
+
+	// Decode JSON into the struct
+	var releaseInfo ReleaseInfo
+	if err := decoder.Decode(&releaseInfo); err != nil {
+		fmt.Println("Error decoding JSON:", err)
+		return
+	}
+
+	// Handle the "eol" field based on its type
+	if eolDate, ok := releaseInfo.EOL.(string); ok {
+		fmt.Fprintf(w, "Version %s is EOL as of %s. The latest release was %s on %s.\n",
+			params.GoVersionOrRelease, eolDate, releaseInfo.Latest, releaseInfo.LatestReleaseDate)
+		return
+	} else if eolBool, ok := releaseInfo.EOL.(bool); ok && !eolBool {
+		fmt.Fprintf(w, "Version %s is not EOL.\n", params.GoVersionOrRelease)
+		return
+	} else {
+		fmt.Println("EOL: unknown type")
+	}
+
+	http.Error(w, "An unexpected error occurred", http.StatusInternalServerError)
+}
diff --git a/handlers/latest_version.go b/handlers/latest_version.go
@@ -0,0 +1,62 @@
+package handlers
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+)
+
+type GoVersion struct {
+	Version string `json:"version"`
+}
+
+func LatestVersionGo(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("Latest Go Version Called")
+	req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, "https://go.dev/dl/?mode=json", nil)
+	if err != nil {
+		http.Error(w, "Failed to create request", http.StatusInternalServerError)
+		return
+	}
+
+	resp, err := (&http.Client{}).Do(req)
+	if err != nil {
+		http.Error(w, "Failed to fetch data", http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		http.Error(w, fmt.Sprintf("Unexpected status code: %d", resp.StatusCode), http.StatusInternalServerError)
+		return
+	}
+
+	// Buffer the response body for decoding
+	var bodyBuffer bytes.Buffer
+	tee := io.TeeReader(resp.Body, &bodyBuffer)
+
+	// Drain the tee to ensure we can parse the body later
+	if _, err := io.Copy(io.Discard, tee); err != nil {
+		http.Error(w, "Failed to process response body", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse the JSON response
+	var versions []GoVersion
+	if err := json.NewDecoder(&bodyBuffer).Decode(&versions); err != nil {
+		http.Error(w, "Failed to parse JSON response", http.StatusInternalServerError)
+		fmt.Printf("Failed to decode JSON: %v\n", err)
+		return
+	}
+
+	// The latest version is the first item in the array
+	if len(versions) > 0 {
+		trimmedVersion := strings.TrimPrefix(versions[0].Version, "go")
+		fmt.Fprintf(w, "%s", trimmedVersion) // Write the version to the HTTP response
+		return
+	}
+
+	http.Error(w, "No versions found", http.StatusNotFound)
+}
diff --git a/handlers/loripsum.go b/handlers/loripsum.go
diff --git a/handlers/supported_versions.go b/handlers/supported_versions.go
@@ -0,0 +1,88 @@
+package handlers
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+)
+
+type VersionInfo struct {
+	Cycle       string      `json:"cycle"`
+	ReleaseDate string      `json:"releaseDate"`
+	EOL         interface{} `json:"eol"`
+}
+
+func SupportedVersionsGo(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("Supported Go Versions Called")
+	req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, "https://endoflife.date/api/go.json", nil)
+	if err != nil {
+		http.Error(w, "Failed to create request", http.StatusInternalServerError)
+		return
+	}
+
+	resp, err := (&http.Client{}).Do(req)
+	if err != nil {
+		http.Error(w, "Failed to fetch data", http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		http.Error(w, fmt.Sprintf("Unexpected status code: %d", resp.StatusCode), http.StatusInternalServerError)
+		return
+	}
+
+	// Buffer the response body for decoding
+	var bodyBuffer bytes.Buffer
+	tee := io.TeeReader(resp.Body, &bodyBuffer)
+
+	// Drain the tee to ensure we can parse the body later
+	if _, err := io.Copy(io.Discard, tee); err != nil {
+		http.Error(w, "Failed to process response body", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse the JSON into a slice of VersionInfo
+	var versions []VersionInfo
+	if err := json.NewDecoder(&bodyBuffer).Decode(&versions); err != nil {
+		http.Error(w, "Failed to parse JSON response", http.StatusInternalServerError)
+		fmt.Printf("Failed to decode JSON: %v\n", err)
+		return
+	}
+
+	// Filter versions with eol == false and collect the results
+	result := make([]struct {
+		Cycle       string `json:"cycle"`
+		ReleaseDate string `json:"releaseDate"`
+	}, 0)
+
+	for _, v := range versions {
+		// Check if EOL is a boolean and is false
+		if eolBool, ok := v.EOL.(bool); ok && !eolBool {
+			result = append(result, struct {
+				Cycle       string `json:"cycle"`
+				ReleaseDate string `json:"releaseDate"`
+			}{
+				Cycle:       v.Cycle,
+				ReleaseDate: v.ReleaseDate,
+			})
+		}
+	}
+
+	// Convert the result to a single string
+	var builder strings.Builder
+	for _, r := range result {
+		builder.WriteString(fmt.Sprintf("Version: %s, Release Date: %s\n", r.Cycle, r.ReleaseDate))
+	}
+
+	// The latest version is the first item in the array
+	if len(builder.String()) > 0 {
+		fmt.Fprintf(w, "%s", builder.String()) // Write the list of supported versions to the HTTP response
+		return
+	}
+
+	http.Error(w, "No versions found", http.StatusNotFound)
+}
diff --git a/main.go b/main.go
@@ -16,9 +16,9 @@ func main() {
 }
 
 func run() error {
-	http.HandleFunc("/random-commit-message", handlers.CommitMessage)
-	http.HandleFunc("/random-lorem-ipsum", handlers.Loripsum)
-	http.HandleFunc("/random-user", handlers.User)
+	http.HandleFunc("/latest-version-go", handlers.LatestVersionGo)
+	http.HandleFunc("/supported-versions-go", handlers.SupportedVersionsGo)
+	http.HandleFunc("/is-supported-or-eol", handlers.IsSupportedOrEOL)
 	http.HandleFunc("/_ping", func(w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte("OK"))
 	})