github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/requests.go

package controllers

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"mime"
	"mime/multipart"
	"net/http"
	"strconv"

	"github.com/benoitkugler/goACVE/logs"
	"github.com/benoitkugler/goACVE/server/core/apiserver"
)

// QueryParams est envoyé via l'url et non encodé en JSON
type QueryParams map[string]string

func IdAsParams(id int64) QueryParams {
	s := strconv.Itoa(int(id))
	return QueryParams{"id": s}
}

func (params QueryParams) setRequest(req *http.Request) {
	query := req.URL.Query()
	for k, v := range params {
		query.Add(k, v)
	}
	req.URL.RawQuery = query.Encode()
}

func newJsonRequete(method, url string, params interface{}) (*http.Request, error) {
	buf := new(bytes.Buffer)
	err := json.NewEncoder(buf).Encode(params)
	if err != nil {
		return nil, fmt.Errorf("Impossible de formatter les arguments de la requête : %s", err)
	}
	req, err := http.NewRequest(method, url, buf)
	if err != nil {
		return nil, fmt.Errorf("Impossible de formatter les arguments de la requête : %s", err)
	}
	req.Header.Set("Content-Type", "application/json")
	return req, nil
}

func newParamsRequete(method, url string, params QueryParams) (*http.Request, error) {
	req, err := http.NewRequest(method, url, nil)
	if err != nil {
		return nil, fmt.Errorf("Impossible de formatter les arguments de la requête : %s", err)
	}
	params.setRequest(req)
	return req, nil
}

func doRequete(endpoint, method string, params interface{}) (*http.Response, error) {
	if Server.ApiURL("") == "" {
		return nil, errors.New("Les requêtes au serveur sont désactivés. Veuillez redémarrer pour les activer.")
	}
	url := Server.ApiURL(endpoint)

	var (
		req *http.Request
		err error
	)
	switch params := params.(type) {
	case QueryParams:
		req, err = newParamsRequete(method, url, params)
	default:
		req, err = newJsonRequete(method, url, params)
	}

	if err != nil {
		return nil, err
	}

	req.SetBasicAuth(apiserver.BasicAuthUsername, logs.APIKEY)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("Erreur pendant l'envoi de la requête : %s", err)
	}
	if err := checkStatusCode(resp); err != nil {
		return nil, err
	}
	return resp, nil
}

type errorRep struct {
	Message string `json:"message"`
}

func checkStatusCode(resp *http.Response) error {
	if resp.StatusCode != 200 {
		defer resp.Body.Close()
		b, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return fmt.Errorf("Réponse du serveur invalide (code %d) : %s", resp.StatusCode, err)
		}
		var rep errorRep
		if err = json.Unmarshal(b, &rep); err != nil {
			return fmt.Errorf("Erreur du serveur, détails inconnu : %s", err)
		}
		return fmt.Errorf("Erreur du serveur : <br/> <i>%s</i>", rep.Message)
	}
	return nil
}

// requete envoie les arguments au format JSON (ou Query), et décode le retour JSON.
func requete(endpoint, method string, params interface{}, out interface{}) error {
	resp, err := doRequete(endpoint, method, params)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	err = json.NewDecoder(resp.Body).Decode(out)
	if err != nil {
		return fmt.Errorf("Réponse du serveur non décodable: %s", err)
	}
	return nil
}

// BinaryRequete envoie les arguments au format JSON (ou Query), sans décoder le retour.
//func BinaryRequete(endpoint, method string, params interface{}, out io.Writer) error {
//	resp, err := doRequete(endpoint, method, params)
//	if err != nil {
//		return err
//	}
//	defer resp.Body.Close()
//	_, err = io.Copy(out, resp.Body)
//	if err != nil {
//		return fmt.Errorf("Réponse du serveur illisible : %s", err)
//	}
//	return nil
//}

// ------------------------------------------------------------------------------
// ------------------------------ Monitor progress ------------------------------
// ------------------------------------------------------------------------------

// requestMonitor émet une requête et stream la réponse
// Les paramètres sont JSONisés (ou Query).
func requestMonitor(endpoint string, method string, params interface{},
	out io.Writer) error {
	resp, err := doRequete(endpoint, method, params)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if _, err = io.Copy(out, resp.Body); err != nil {
		return err
	}
	return nil
}

// writeCounter counts the number of bytes written to it
// `callback` will be passed the download percentage
type writeCounter struct {
	max      uint64
	current  uint64
	callback func(uint8)
}

func (wc *writeCounter) Write(p []byte) (int, error) {
	n := len(p)
	wc.current += uint64(n)
	wc.callback(uint8(wc.current * 100 / wc.max))
	return n, nil
}

// requestDownload télécharge un contenu binaire et appelle `callback`
// pour suivre l'évolution du téléchargement.
// Les paramètres sont JSONisés (ou Query).
func requestDownload(endpoint string, method string, params interface{},
	callback func(uint8), out io.Writer) error {
	resp, err := doRequete(endpoint, method, params)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	max, err := strconv.Atoi(resp.Header.Get("Content-Length"))
	if err != nil {
		return fmt.Errorf("Réponse du serveur invalide : %s", err)
	}

	// Create our progress reporter and pass it to be used alongside our writer
	counter := &writeCounter{max: uint64(max), callback: callback}
	_, err = io.Copy(out, io.TeeReader(resp.Body, counter))
	if err != nil {
		return err
	}
	return nil
}

type fileUpload struct {
	name    string
	content io.ReadCloser
}

type urlModifer interface {
	url() string
	setRequest(*http.Request)
}

func requeteUploadWithMeta(file fileUpload, meta interface{}, method string, url urlModifer, callback func(uint8), out interface{}) error {
	defer file.content.Close()
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)

	// content
	part, err := writer.CreateFormFile("file", file.name)
	if err != nil {
		return err
	}
	if _, err = io.Copy(part, file.content); err != nil {
		return err
	}

	// meta
	metaJson, err := json.Marshal(meta)
	if err != nil {
		return err
	}
	err = writer.WriteField("meta", string(metaJson))
	if err != nil {
		return err
	}

	if err = writer.Close(); err != nil {
		return err
	}

	counter := &writeCounter{max: uint64(len(body.Bytes())), callback: callback}
	customReader := io.TeeReader(body, counter)

	req, err := http.NewRequest(method, url.url(), customReader)
	if err != nil {
		return err
	}

	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.SetBasicAuth(apiserver.BasicAuthUsername, logs.APIKEY)
	url.setRequest(req)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	if err := checkStatusCode(resp); err != nil {
		return err
	}
	defer resp.Body.Close()
	err = json.NewDecoder(resp.Body).Decode(out)
	if err != nil {
		return fmt.Errorf("Réponse du serveur non décodable: %s", err)
	}
	return nil
}

type urlDocumentWithIdParam int64

func (urlDocumentWithIdParam) url() string { return Server.ApiURL(apiserver.UrlDocumentsTransfert) }

func (id urlDocumentWithIdParam) setRequest(req *http.Request) {
	IdAsParams(int64(id)).setRequest(req)
}

type urlBasique string

func (u urlBasique) url() string { return string(u) }

func (urlBasique) setRequest(req *http.Request) {} // no-op

// requeteUpload émet une requête multipart, appelle callback pendant l'upload,
// et unmarshal la réponse dans out
func requeteUpload(params apiserver.ParamsUploadDocument, callback func(uint8), out interface{}) error {
	return requeteUploadWithMeta(fileUpload{name: params.Filename, content: params.Content}, nil, http.MethodPost, urlDocumentWithIdParam(params.Id), callback, out)
}

type ParamsNewDocument struct {
	fileUpload
	Meta apiserver.CreateDocumentIn
}

// requeteCreateDocument émet une requête multipart et appelle callback pendant l'upload
func requeteCreateDocument(params ParamsNewDocument, callback func(uint8)) (apiserver.CreateDocumentIn, error) {
	var out apiserver.CreateDocumentIn // le server renvoie les mêmes objets, mis à jour
	url := Server.ApiURL(apiserver.UrlDocuments)
	err := requeteUploadWithMeta(params.fileUpload, params.Meta, http.MethodPut, urlBasique(url), callback, &out)
	return out, err
}

// requeteResponseMultipart envoie une requete JSON (ou Query) et recois une réponse multipart.
func requeteResponseMultipart(endpoint, method string, params interface{}) (map[string][]byte, error) {
	resp, err := doRequete(endpoint, method, params)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	_, ct, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
	if err != nil {
		return nil, err
	}
	mr := multipart.NewReader(resp.Body, ct["boundary"])
	out := map[string][]byte{}
	for {
		p, err := mr.NextPart()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		partContent, err := ioutil.ReadAll(p)
		if err != nil {
			return nil, err
		}
		key := p.FormName()
		out[key] = partContent

	}
	return out, nil
}