gitwarrior/internal/gitea/comment.go

package gitea

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"strings"
	"time"
)

type Comment struct {
	Id                 uint      `json:"id"`
	Body               string    `json:"body"`
	Issue_url          string    `json:"issue_url"`
	Assets             []string  `json:"assets"`
	Html_url           string    `json:"html_url"`
	User               User      `json:"user"`
	Original_author    string    `json:"original_author"`
	Original_author_id uint      `json:"original_author_id"`
	Pull_request_url   string    `json:"pull_request_url"`
	Created_at         time.Time `json:"created_at"`
	Updated_at         time.Time `json:"updated_at"`
}

func (gitea *Gitea) GetComments(repo Repository) ([]Comment, error) {
	client := &http.Client{}
	url := fmt.Sprintf("%s/repos/%s/issues/comments", gitea.Url(), repo.Full_name)
	request, err := http.NewRequest(http.MethodGet, url, nil)
	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
	response, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()
	var data []Comment
	decoder := json.NewDecoder(response.Body)
	if err = decoder.Decode(&data); err != nil {
		return nil, err
	}
	for _, comment := range data {
		comment.Body = strings.ReplaceAll(comment.Body, "\r\n", "\n")
	}
	return data, nil
}

func (gitea *Gitea) GetComment(repo Repository, id uint) (Comment, error) {
	client := &http.Client{}
	url := fmt.Sprintf("%s/repos/%s/issues/comments/%d", gitea.Url(), repo.Full_name, id)
	request, err := http.NewRequest(http.MethodGet, url, nil)
	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
	response, err := client.Do(request)
	var comment Comment
	if err != nil {
		return comment, err
	}
	defer response.Body.Close()
	decoder := json.NewDecoder(response.Body)
	if err = decoder.Decode(&comment); err != nil {
		return comment, err
	}
	comment.Body = strings.ReplaceAll(comment.Body, "\r\n", "\n")
	return comment, err
}

func (gitea *Gitea) UpdateComment(repo Repository, comment Comment) error {
	url := fmt.Sprintf("%s/repos/%s/issues/comments/%d", gitea.Url(), repo.Full_name, comment.Id)
	json, err := json.Marshal(&map[string]interface{}{
		"body": comment.Body,
	})
	if err != nil {
		return err
	}
	client := &http.Client{}
	request, err := http.NewRequest(http.MethodPatch, url, bytes.NewBuffer(json))
	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
	request.Header.Set("content-type", "application/json")
	if err != nil {
		return err
	}
	result, err := client.Do(request)
	if err != nil {
		return err
	}
	defer result.Body.Close()
	if result.StatusCode != 200 && result.StatusCode != 204 {
		return errors.New(fmt.Sprintf("\tRequest returned status: %s\n", result.Status))
	}
	return nil
}

func (gitea *Gitea) NewComment(repo Repository, issue Issue, comment Comment) (Comment, error) {
	url := fmt.Sprintf("%s/repos/%s/issues/%d/comments", gitea.Url(), repo.Full_name, issue.Number)
	payload, err := json.Marshal(&map[string]interface{}{
		"body": comment.Body,
	})
	var res Comment
	if err != nil {
		return res, err
	}
	client := &http.Client{}
	request, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(payload))
	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
	request.Header.Set("content-type", "application/json")
	if err != nil {
		return res, nil
	}
	result, err := client.Do(request)
	if err != nil {
		return res, err
	}
	defer result.Body.Close()
	if result.StatusCode != 201 {
		return res, errors.New(fmt.Sprintf("\tRequest returned status: %s\n", result.Status))
	}
	decoder := json.NewDecoder(result.Body)
	if err = decoder.Decode(&res); err != nil {
		return res, err
	}
	return res, nil
}

func (gitea *Gitea) DeleteComment(repo Repository, comment_id uint) error {
	url := fmt.Sprintf("%s/repos/%s/issues/comments/%d", gitea.Url(), repo.Full_name, comment_id)
	client := &http.Client{}
	request, err := http.NewRequest(http.MethodDelete, url, nil)
	request.SetBasicAuth(gitea.User_name, gitea.Access_code)
	request.Header.Set("content-type", "application/json")
	if err != nil {
		return nil
	}
	result, err := client.Do(request)
	if err != nil {
		return err
	}
	defer result.Body.Close()
	if result.StatusCode != 204 {
		return errors.New(fmt.Sprintf("\tRequest returned status: %s\n", result.Status))
	}
	return nil
}