Merge pull request #1 from etilite/dev

feat: add initial version of builder

Author: etilite

.gitignore

@@ -0,0 +1,2 @@
+## dev
+/.idea/

Makefile

@@ -0,0 +1,19 @@
+.PHONY: dev-up dev-down run test test-race clean
+
+dev-up:
+	docker-compose --file ./build/docker-compose.yml up -d --build --remove-orphans
+
+dev-down:
+	docker-compose --file ./build/docker-compose.yml down --rmi all -v
+
+run:
+	CGO_ENABLED=0 go build -ldflags='-w -s' -o app ./main.go && HTTP_ADDR=:8080 ./app
+
+test:
+	go test -v -shuffle=on -count=2 -short -cover ./...
+
+test-race:
+	go test -race ./...
+
+clean:
+	rm app

README.md

@@ -1 +1,41 @@
-# Init
+# Xlsx builder
+## Usage
+`make dev-up`
+
+`POST http://localhost:8080/invoice/`
+
+```JSON
+{
+    "id": "1234",
+    "date": "2023-07-29",
+    "amount": "10",
+    "client": {
+        "fullName": "John Smith",
+        "accountId": "US0001",
+        "email": "[email protected]"
+    },
+    "header": [
+        "date",
+        "id",
+        "price"
+    ],
+    "data": [
+        [
+            "01.01.2023",
+            "1",
+            "10"
+        ],
+        [
+            "02.01.2023",
+            "2",
+            "20"
+        ],
+        [
+            "03.01.2023",
+            "3",
+            "33"
+        ]
+    ]
+}
+```
+service responses with `.xlsx` file

build/Dockerfile

@@ -0,0 +1,33 @@
+ARG GO_VERSION=1.20.2
+ARG DISTROLESS_IMAGE=gcr.io/distroless/static:nonroot
+############################
+# STEP 1 build executable binary
+############################
+FROM golang:${GO_VERSION} as builder
+
+# Ensure ca-certficates are up to date
+RUN update-ca-certificates
+
+WORKDIR /app/
+
+# use modules
+COPY go.mod go.sum ./
+
+ENV GO111MODULE=on
+RUN go mod download && go mod verify
+
+COPY . .
+
+# Build the static binary
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
+      -ldflags='-w -s -extldflags "-static"' -a \
+      -o app .
+
+############################
+# STEP 2 build a small image
+############################
+FROM ${DISTROLESS_IMAGE}
+
+COPY --from=builder --chown=nonroot:nonroot /app/app /app
+
+ENTRYPOINT ["/app"]

build/docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3.8'
+
+services:
+  xlsx-builder:
+    build:
+      context: ./../
+      dockerfile: ./build/Dockerfile
+    container_name: xlsx-builder
+    ports:
+      - "8080:8080"
+    environment:
+      - HTTP_ADDR=:8080

builder/builder.go

@@ -0,0 +1,47 @@
+package builder
+
+import (
+	"bytes"
+	"github.com/xuri/excelize/v2"
+	"log"
+)
+
+type Builder struct{}
+
+func NewBuilder() *Builder {
+	return &Builder{}
+}
+
+func (b *Builder) Build(rows [][]string) (*bytes.Buffer, error) {
+	f := excelize.NewFile()
+	defer func() {
+		if err := f.Close(); err != nil {
+			log.Print(err)
+		}
+	}()
+	err := fillRows(rows, f)
+	if err != nil {
+		return nil, err
+	}
+
+	buf, err := f.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+func fillRows(rows [][]string, f *excelize.File) error {
+	for i, r := range rows {
+		cell, err := excelize.CoordinatesToCellName(1, i+1)
+		if err != nil {
+			return err
+		}
+		err = f.SetSheetRow("Sheet1", cell, &r)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

builder/builder_test.go

@@ -0,0 +1,44 @@
+package builder
+
+import (
+	"github.com/xuri/excelize/v2"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestBuild(t *testing.T) {
+	tests := map[string]struct {
+		rows [][]string
+	}{
+		"empty table": {rows: [][]string{}},
+		"2x2 table":   {rows: [][]string{{"a", "b"}, {"c", "d"}}},
+	}
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			tc := tc
+			t.Parallel()
+
+			b := NewBuilder()
+
+			buf, err := b.Build(tc.rows)
+			if err != nil {
+				t.Error(err)
+			}
+
+			f, err := excelize.OpenReader(strings.NewReader(buf.String()))
+			if err != nil {
+				t.Error(err)
+			}
+
+			rows, err := f.GetRows("Sheet1")
+			if err != nil {
+				t.Error("got error getting rows")
+			}
+
+			if !reflect.DeepEqual(rows, tc.rows) {
+				t.Errorf("result mismatch in test %s: want %s, got %s", name, tc.rows, rows)
+			}
+		})
+	}
+}

delivery/http/builder.go

@@ -0,0 +1,9 @@
+package http
+
+import (
+	"bytes"
+)
+
+type Builder interface {
+	Build(rows [][]string) (*bytes.Buffer, error)
+}

delivery/http/handler.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"strconv"
+)
+
+type XlsxHandler struct {
+	builder Builder
+}
+
+func NewXlsxHandler(b Builder) *XlsxHandler {
+	return &XlsxHandler{builder: b}
+}
+
+func (h *XlsxHandler) handleSheet(newSheet func() Sheet) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		sheet := newSheet()
+		//fmt.Printf("sheet: %T, &sheet: %T\n", sheet, &sheet)
+		err := json.NewDecoder(r.Body).Decode(&sheet)
+		//fmt.Printf("sheet: %v, &sheet: %v\n", sheet, &sheet)
+		if err != nil {
+			err = fmt.Errorf("failed to decode JSON: %w", err)
+			log.Print(err)
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		buf, err := h.builder.Build(sheet.Rows())
+		if err != nil {
+			log.Print(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		h.setHeaders(w, int64(buf.Len()))
+		_, err = buf.WriteTo(w)
+		if err != nil {
+			log.Print(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+}
+
+func (h *XlsxHandler) setHeaders(w http.ResponseWriter, length int64) {
+	w.Header().Set("Content-Type", "application/octet-stream")
+	//w.Header().Set("Data-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	w.Header().Set("Content-Disposition", "attachment; filename=sheet.xlsx")
+	w.Header().Set("Content-Transfer-Encoding", "binary")
+	w.Header().Set("Expires", "0")
+	w.Header().Set("Content-Length", strconv.FormatInt(length, 10))
+}

delivery/http/handler_test.go

@@ -0,0 +1,96 @@
+package http
+
+import (
+	"bytes"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	. "xlsx-builder/internal/testing"
+)
+
+type mockBuilder struct {
+	buf *bytes.Buffer
+	err error
+}
+
+func (b *mockBuilder) Build([][]string) (*bytes.Buffer, error) {
+	return b.buf, b.err
+}
+
+type mockSheet struct {
+	rows [][]string
+}
+
+func (s mockSheet) Rows() [][]string {
+	return s.rows
+}
+
+func TestCreateInvoiceXlsx(t *testing.T) {
+	mockFactory := func() Sheet {
+		return &mockSheet{}
+	}
+	t.Run("success", func(t *testing.T) {
+		t.Parallel()
+
+		buf := &bytes.Buffer{}
+		buf.Write([]byte("body-file-contents"))
+		builder := &mockBuilder{buf: buf}
+		server := NewXlsxHandler(builder)
+		handleFunc := server.handleSheet(mockFactory)
+
+		requestBody := strings.NewReader("{}")
+		request, _ := http.NewRequest(http.MethodPost, "/invoice/", requestBody)
+		response := httptest.NewRecorder()
+
+		handleFunc(response, request)
+
+		AssertStatusCode(t, response, http.StatusOK)
+		AssertBody(t, response, "body-file-contents")
+		assertHeaders(t, response)
+	})
+
+	t.Run("bad request", func(t *testing.T) {
+		t.Parallel()
+
+		builder := &mockBuilder{}
+		server := NewXlsxHandler(builder)
+		handleFunc := server.handleSheet(mockFactory)
+
+		requestBody := strings.NewReader("")
+		request, _ := http.NewRequest(http.MethodPost, "/invoice/", requestBody)
+		response := httptest.NewRecorder()
+
+		handleFunc(response, request)
+
+		AssertStatusCode(t, response, http.StatusBadRequest)
+		AssertBody(t, response, "failed to decode JSON: EOF\n")
+	})
+
+	t.Run("internal server error", func(t *testing.T) {
+		t.Parallel()
+
+		builder := &mockBuilder{err: errors.New("internal server error")}
+		server := NewXlsxHandler(builder)
+		handleFunc := server.handleSheet(mockFactory)
+
+		requestBody := strings.NewReader("{}")
+		request, _ := http.NewRequest(http.MethodPost, "/invoice/", requestBody)
+		response := httptest.NewRecorder()
+
+		handleFunc(response, request)
+
+		AssertStatusCode(t, response, http.StatusInternalServerError)
+		AssertBody(t, response, "internal server error\n")
+	})
+}
+
+func assertHeaders(t *testing.T, response *httptest.ResponseRecorder) {
+	AssertHeader(t, response, "Content-Disposition", "attachment; filename=sheet.xlsx")
+	AssertHeader(t, response, "Content-Type", "application/octet-stream")
+	//AssertHeader(t, response, "Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	AssertHeader(t, response, "Content-Transfer-Encoding", "binary")
+	AssertHeader(t, response, "Expires", "0")
+	AssertHeader(t, response, "Content-Length", "18")
+}