Refactor: update officers to use new huh logic

internal/api/handlers/announcement.go

@@ -5,7 +5,6 @@ package handlers
 import (
 	"database/sql"
 	"errors"
-	"fmt"
 	"log"
 	"net/http"
 
@@ -129,9 +128,9 @@ func (h *AnnouncementHandler) CreateAnnouncement(c *gin.Context) {
 		DiscordMessageID: msgID,
 	}
 
-	fmt.Println("DTO ->", params, "\nDBMODEL->", dbParams)
 	// TODO: error out if required fields aren't provided
 	if err := h.announcementService.Create(ctx, dbParams); err != nil {
+		log.Printf("Failed to create announcement: %v\n", err)
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"error": "Failed to create announcement",
 		})

internal/cli/announcements/delete.go

@@ -2,13 +2,13 @@ package announcements
 
 import (
 	"fmt"
-	"io"
 	"net/http"
+	"os"
 
 	"github.com/spf13/cobra"
 
+	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/client"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/config"
-	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/oauth"
 	"github.com/acmcsufoss/api.acmcsuf.com/utils"
 )
 
@@ -31,29 +31,12 @@ func init() {
 func deleteAnnouncement(id string, cfg *config.Config) {
 	deleteUrl := config.GetBaseURL(cfg).JoinPath("v1", "announcements", id)
 
-	// ----- Delete -----
-	request, err := oauth.NewRequestWithAuth(http.MethodDelete, deleteUrl.String(), nil)
-	if err != nil {
-		fmt.Println("Error: failed to construct delete request:", err)
-		return
+	if body, err := client.SendRequestAndReadResponse(deleteUrl, true, http.MethodDelete, nil); err != nil {
+		fmt.Fprintln(os.Stderr, "Error:", err)
+		if body != nil {
+			utils.PrettyPrintJSONErr(body)
+		}
+	} else {
+		utils.PrettyPrintJSON(body)
 	}
-
-	client := http.Client{}
-	response, err := client.Do(request)
-	if err != nil {
-		fmt.Println("Error: failed to send delete request:", err)
-		return
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode != http.StatusOK {
-		fmt.Println("Error: HTTP", response.Status)
-		return
-	}
-	body, err := io.ReadAll(response.Body)
-	if err != nil {
-		fmt.Println("Error: failed to read response body:", err)
-		return
-	}
-	utils.PrettyPrintJSON(body)
 }

internal/cli/announcements/get.go

@@ -2,11 +2,12 @@ package announcements
 
 import (
 	"fmt"
-	"io"
 	"net/http"
+	"os"
 
 	"github.com/spf13/cobra"
 
+	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/client"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/config"
 	"github.com/acmcsufoss/api.acmcsuf.com/utils"
 )
@@ -29,30 +30,12 @@ func init() {
 func getAnnouncement(uuid string, cfg *config.Config) {
 	getUrl := config.GetBaseURL(cfg).JoinPath("v1", "announcements", uuid)
 
-	// ----- Requesting Get -----
-	client := http.Client{}
-	req, err := http.NewRequest(http.MethodGet, getUrl.String(), nil)
-	if err != nil {
-		fmt.Println("error with request:", err)
-		return
+	if body, err := client.SendRequestAndReadResponse(getUrl, false, http.MethodGet, nil); err != nil {
+		fmt.Fprintln(os.Stderr, "Error:", err)
+		if body != nil {
+			utils.PrettyPrintJSONErr(body)
+		}
+	} else {
+		utils.PrettyPrintJSON(body)
 	}
-
-	res, err := client.Do(req)
-	if err != nil {
-		fmt.Println("error getting announcements:", err)
-		return
-	}
-	defer res.Body.Close()
-
-	if res.StatusCode != http.StatusOK {
-		fmt.Println("Error: HTTP", res.Status)
-		return
-	}
-
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		fmt.Println("Error: failed to read response body:", err)
-		return
-	}
-	utils.PrettyPrintJSON(body)
 }

internal/cli/announcements/post.go

@@ -1,18 +1,18 @@
 package announcements
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
-	"io"
 	"net/http"
-	"strings"
+	"os"
 
 	"github.com/charmbracelet/huh"
 	"github.com/spf13/cobra"
 
+	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/client"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/config"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/forms"
-	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/oauth"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/dto"
 	"github.com/acmcsufoss/api.acmcsuf.com/utils"
 )
@@ -27,44 +27,28 @@ var PostAnnouncement = &cobra.Command{
 }
 
 func postAnnouncement(cfg *config.Config) {
-	payload, err := postForm()
-	if err != nil {
-		fmt.Println("Error:", err)
-		return
-	}
-
-	jsonPayload, err := json.Marshal(payload)
-	if err != nil {
-		fmt.Println("Error: could not marshal JSON:", err)
-		return
-	}
+	postUrl := config.GetBaseURL(cfg).JoinPath("v1", "announcements")
 
-	postURL := config.GetBaseURL(cfg).JoinPath("v1", "announcements")
-	client := http.Client{}
-	req, err := oauth.NewRequestWithAuth(http.MethodPost, postURL.String(), strings.NewReader(string(jsonPayload)))
+	payload, err := postForm()
 	if err != nil {
-		fmt.Println("Error: could not create request:", err)
+		fmt.Fprintln(os.Stderr, "Error:", err)
 		return
 	}
-
-	res, err := client.Do(req)
+	b, err := json.Marshal(payload)
 	if err != nil {
-		fmt.Println("Error: could not send request:", err)
+		fmt.Fprintln(os.Stderr, "Error: could not marshal JSON:", err)
 		return
 	}
-	defer res.Body.Close()
 
-	if res.StatusCode != http.StatusOK {
-		fmt.Println("Error: HTTP", res.Status)
-		return
-	}
-
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		fmt.Println("Error: could not read response body:", err)
-		return
+	if body, err := client.SendRequestAndReadResponse(postUrl, true, http.MethodPost,
+		bytes.NewBuffer(b)); err != nil {
+		fmt.Fprintln(os.Stderr, "Error:", err)
+		if body != nil {
+			utils.PrettyPrintJSONErr(body)
+		}
+	} else {
+		utils.PrettyPrintJSON(body)
 	}
-	utils.PrettyPrintJSON(body)
 }
 
 func postForm() (*dto.Announcement, error) {
@@ -111,5 +95,5 @@ func postForm() (*dto.Announcement, error) {
 	payload.DiscordChannelID = &channelIDStr
 	payload.DiscordMessageID = &messageIDStr
 
-	return &payload, err
+	return &payload, nil
 }

internal/cli/announcements/put.go

@@ -4,14 +4,14 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"io"
 	"net/http"
+	"os"
 
 	"github.com/charmbracelet/huh"
 	"github.com/spf13/cobra"
 
+	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/client"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/config"
-	"github.com/acmcsufoss/api.acmcsuf.com/internal/cli/oauth"
 	"github.com/acmcsufoss/api.acmcsuf.com/internal/dto"
 	"github.com/acmcsufoss/api.acmcsuf.com/utils"
 )
@@ -32,81 +32,56 @@ func init() {
 }
 
 func putAnnouncements(id string, cfg *config.Config) {
-	resourceURL := config.GetBaseURL(cfg).JoinPath("v1", "announcements", id)
+	resourceUrl := config.GetBaseURL(cfg).JoinPath("v1", "announcements", id)
 
-	// ----- Get the Announcement We Want to Update -----
-	client := http.Client{}
-	getReq, err := oauth.NewRequestWithAuth(http.MethodGet, resourceURL.String(), nil)
-	if err != nil {
-		fmt.Printf("Error: couldn't retrieve resource %s: %s", id, err)
-		return
-	}
-	getRes, err := client.Do(getReq)
-	if err != nil {
-		fmt.Println("Error: failed to send request:", err)
-		return
-	}
-	defer getRes.Body.Close()
-	if getRes.StatusCode != http.StatusOK {
-		fmt.Println("Error: HTTP", getRes.Status)
-		return
-	}
-	body, err := io.ReadAll(getRes.Body)
-	if err != nil {
-		fmt.Println("Error: failed to read response body:", err)
+	// ----- Get announcement we want to update -----
+	var oldPayload dto.Announcement
+	if body, err := client.SendRequestAndReadResponse(resourceUrl, false, http.MethodGet, nil); err != nil {
+		fmt.Fprintln(os.Stderr, "Error:", err)
+		if body != nil {
+			utils.PrettyPrintJSON(body)
+		}
 		return
+	} else {
+		err = json.Unmarshal(body, &oldPayload)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "Error: failed to unmarshal response body:", err)
+			return
+		}
 	}
 
-	// ----- Update found announceement -----
-	var oldPayload dto.UpdateAnnouncement
-	err = json.Unmarshal(body, &oldPayload)
+	// ----- Update found announcement -----
+	newPayload, err := putForm(&oldPayload)
 	if err != nil {
-		fmt.Println("Error: failed to unmarshal response body:", err)
+		fmt.Fprintln(os.Stderr, "Error:", err)
 		return
 	}
-	newPayload, err := putForm(id)
+	b, err := json.Marshal(newPayload)
 	if err != nil {
-		fmt.Println("Error:", err)
+		fmt.Fprintln(os.Stderr, "Error: failed to marshal data:", err)
 		return
 	}
-	jsonPayload, err := json.Marshal(newPayload)
-	if err != nil {
-		fmt.Println("Error: failed to marshal data:", err)
-		return
-	}
-	putRequest, err := oauth.NewRequestWithAuth(http.MethodPut, resourceURL.String(), bytes.NewBuffer(jsonPayload))
-	if err != nil {
-		fmt.Println("Error: failed to contruct request:", err)
-		return
-	}
-	putResponse, err := client.Do(putRequest)
-	if err != nil {
-		fmt.Println("Error: failed to send request: ", err)
-		return
-	}
-	defer putResponse.Body.Close()
 
-	if putResponse.StatusCode != http.StatusOK {
-		fmt.Println("Error: HTTP", putResponse.Status)
-		return
-	}
-	body, err = io.ReadAll(putResponse.Body)
-	if err != nil {
-		fmt.Println("Error: failed to read response body", err)
-		return
+	// Update remote resource with new data
+	if body, err := client.SendRequestAndReadResponse(resourceUrl, true, http.MethodPut,
+		bytes.NewBuffer(b)); err != nil {
+		fmt.Fprintln(os.Stderr, "Error:", err)
+		if body != nil {
+			utils.PrettyPrintJSONErr(body)
+		}
+	} else {
+		utils.PrettyPrintJSON(body)
 	}
-	utils.PrettyPrintJSON(body)
 }
 
-// TODO: Use DTO models instaad of dbmodels
-func putForm(uuid string) (*dto.UpdateAnnouncement, error) {
+func putForm(oldPayload *dto.Announcement) (*dto.UpdateAnnouncement, error) {
 	var payload dto.UpdateAnnouncement
 	var err error
 	var (
-		visibilityStr string
-		announceAtStr string
-		channelIDStr  string
-		messageIDStr  string
+		visibilityStr string = oldPayload.Visibility
+		announceAtStr string // no default for now bc its stored as a raw timestamp
+		channelIDStr  string = *oldPayload.DiscordChannelID
+		messageIDStr  string = *oldPayload.DiscordMessageID
 	)
 	form := huh.NewForm(
 		huh.NewGroup(
@@ -131,8 +106,7 @@ func putForm(uuid string) (*dto.UpdateAnnouncement, error) {
 		return nil, err
 	}
 
-	payload.Uuid = uuid
-	// HACK: These conversions won't be necessary once we start using DTO models here
+	payload.Uuid = oldPayload.Uuid
 	payload.Visibility = &visibilityStr
 	if announceAtStr != "" {
 		timestamp, err := utils.ByteSlicetoUnix([]byte(announceAtStr))
@@ -141,7 +115,6 @@ func putForm(uuid string) (*dto.UpdateAnnouncement, error) {
 		}
 		payload.AnnounceAt = &timestamp
 	}
-
 	payload.DiscordChannelID = &channelIDStr
 	payload.DiscordMessageID = &messageIDStr