From bd4133c25e31845e8636529540b6ac5673a0e50c Mon Sep 17 00:00:00 2001
From: Roman Zipp <ich@ich.wtf>
Date: Sun, 23 Jan 2022 18:19:10 +0100
Subject: [PATCH] Add image upload endpoint

---
 README.md    |  2 +-
 main.go      | 77 +++++++++++++++++++++++++++++++++++++++++++++++++---
 main_test.go | 60 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 134 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 7101b4e..b7db386 100644
--- a/README.md
+++ b/README.md
@@ -76,7 +76,7 @@ Authorization: Bearer <Token>
 }
 ```
 
-### `GET` `/{pipeline}`
+### `GET` `/pipelines/{pipeline}`
 
 Show pipeline information.
 
diff --git a/main.go b/main.go
index 2f7df81..67f8a20 100644
--- a/main.go
+++ b/main.go
@@ -1,15 +1,17 @@
 package main
 
 import (
+	"bytes"
 	"encoding/json"
-	"net/http"
-
 	"github.com/geplauder/lithium/auth"
 	"github.com/geplauder/lithium/pipelines"
 	"github.com/geplauder/lithium/settings"
 	"github.com/geplauder/lithium/storage"
 	"github.com/gorilla/mux"
 	"github.com/spf13/afero"
+	"io"
+	"net/http"
+	"strings"
 )
 
 const Name string = "Lithium"
@@ -36,8 +38,75 @@ func IndexHandler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func writeError(w http.ResponseWriter, status int, errStr string) {
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(struct {
+		Error string `json:"error"`
+	}{errStr})
+}
+
+func UploadHandler(w http.ResponseWriter, r *http.Request, pipes []pipelines.IPipeline, storageProvider storage.IStorageProvider) {
+	// open file handler
+	formFile, handler, err := r.FormFile("file")
+	if err != nil {
+		writeError(w, http.StatusUnprocessableEntity, err.Error())
+		return
+	}
+
+	defer formFile.Close()
+
+	// check pipelines form param
+	formPipelines := strings.Split(r.FormValue("pipelines"), ",")
+	if len(formPipelines) == 0 {
+		writeError(w, http.StatusUnprocessableEntity, "pipeline parameter missing")
+		return
+	}
+
+	bucket := r.FormValue("bucket")
+	if bucket == "" {
+		writeError(w, http.StatusUnprocessableEntity, "bucket parameter missing")
+		return
+	}
+
+	// open file
+	file, err := handler.Open()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "error reading uploaded file")
+		return
+	}
+
+	defer file.Close()
+
+	// read file to buffer
+	buf := bytes.NewBuffer(nil)
+	_, err = io.Copy(buf, file)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "error reading file from buffer")
+		return
+	}
+
+	// store uploaded file
+	_, err = storageProvider.StoreRaw(bucket, "source.jpg", buf.Bytes())
+	if err != nil {
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+
+	err = json.NewEncoder(w).Encode(struct {
+		Message string `json:"message"`
+	}{"ok"})
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+}
+
 func RegisterRoutes(r *mux.Router, pipelines []pipelines.IPipeline, storageProvider storage.IStorageProvider) {
-	r.HandleFunc("/", IndexHandler)
+	r.HandleFunc("/", IndexHandler).Methods("GET")
+	r.HandleFunc("/upload", func(w http.ResponseWriter, r *http.Request) {
+		UploadHandler(w, r, pipelines, storageProvider)
+	}).Methods("POST")
 	r.HandleFunc("/pipelines/{pipeline}", func(w http.ResponseWriter, r *http.Request) {
 		for _, pipeline := range pipelines {
 			if pipeline.GetSlug() == mux.Vars(r)["pipeline"] {
@@ -47,7 +116,7 @@ func RegisterRoutes(r *mux.Router, pipelines []pipelines.IPipeline, storageProvi
 		}
 
 		w.WriteHeader(404)
-	})
+	}).Methods("GET")
 }
 
 func main() {
diff --git a/main_test.go b/main_test.go
index e97f4ef..bcc73f4 100644
--- a/main_test.go
+++ b/main_test.go
@@ -1,7 +1,9 @@
 package main
 
 import (
+	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -57,3 +59,61 @@ func TestEndpointRoute(t *testing.T) {
 		assert.Equal(t, 404, responseRecorder.Code)
 	})
 }
+
+func TestUploadRoute(t *testing.T) {
+	t.Run("Test uploads missing multipart boundary", func(t *testing.T) {
+		router := mux.NewRouter()
+		fs := storage.GetMemoryStorageProvider()
+
+		RegisterRoutes(router, []pipelines.IPipeline{pipelines.Pipeline{
+			Name:           "",
+			Slug:           "",
+			Type:           0,
+			RemoveMetadata: false,
+			Steps:          []pipelines.Step{},
+			Output: struct {
+				Format  string `json:"format"`
+				Quality int    `json:"quality"`
+			}{"jpeg", 10},
+		}}, fs)
+
+		request, _ := http.NewRequest("POST", "/upload", nil)
+		request.Header["Content-Type"] = []string{"multipart/form-data"}
+		responseRecorder := httptest.NewRecorder()
+
+		router.ServeHTTP(responseRecorder, request)
+
+		assert.Equal(t, 0x1A6, responseRecorder.Code)
+		str, _ := base64.StdEncoding.DecodeString("eyJlcnJvciI6Im5" +
+			"vIG11bHRpcGFydCBib3VuZGFyeSBwYXJhbSBpbiBDb250ZW50LVR5cGUifQ==")
+		assert.JSONEq(t, string(str), responseRecorder.Body.String())
+	})
+
+	t.Run("Test uploads missing multipart boundary", func(t *testing.T) {
+		router := mux.NewRouter()
+		fs := storage.GetMemoryStorageProvider()
+
+		RegisterRoutes(router, []pipelines.IPipeline{pipelines.Pipeline{
+			Name:           "",
+			Slug:           "",
+			Type:           0,
+			RemoveMetadata: false,
+			Steps:          []pipelines.Step{},
+			Output: struct {
+				Format  string `json:"format"`
+				Quality int    `json:"quality"`
+			}{"jpeg", 10},
+		}}, fs)
+
+		request, _ := http.NewRequest("POST", "/upload", nil)
+		request.Header["Content-Type"] = []string{"multipart/form-data", "boundary=X-INSOMNIA-BOUNDARY"}
+		responseRecorder := httptest.NewRecorder()
+
+		router.ServeHTTP(responseRecorder, request)
+
+		assert.Equal(t, 0x1A6, responseRecorder.Code)
+		str, _ := base64.StdEncoding.DecodeString("eyJlcnJvciI6Im5vIG11bHRpcGFydCBib3VuZGFyeSBwYXJhbSBpbiBDb250ZW50LVR5cGUifQ==")
+		assert.JSONEq(t, string(str), responseRecorder.Body.String())
+		fmt.Println(responseRecorder.Body.String())
+	})
+}