refactor: déplacer fichiers go source vers pkg/ et cmd/

Déplacer public/ et templates/ vers ui/ et ui/public/

Bump projet à v3, API toujours v1

pkg/agecemorg/client.go

@@ -0,0 +1,185 @@
+package agecemorg
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+
+	"codeberg.org/vlbeaudoin/voki/v3"
+	"github.com/spf13/viper"
+)
+
+type API struct {
+	Voki *voki.Voki
+}
+
+// NewAPIClientFromViper returns a pointer to a new API object,
+// provided the configuration options are managed by
+// https://git.agecem.com/agecem/agecem-org/config
+func NewAPIClientFromViper(client *http.Client) (api *API, err error) {
+	var config Config
+	if err = viper.Unmarshal(&config); err != nil {
+		return nil, err
+	}
+
+	return NewAPIClient(client, config.Server.Api.Host, config.Server.Api.Key, config.Server.Api.Port, config.Server.Api.Protocol)
+}
+
+func NewAPIClient(client *http.Client, host, key string, port int, protocol string) (*API, error) {
+	return &API{Voki: voki.New(client, host, key, port, protocol)}, nil
+}
+
+func (a *API) UploadDocuments(bucketName string, fileHeaders ...*multipart.FileHeader) (response CreateDocumentsResponse, err error) {
+	if count := len(fileHeaders); count == 0 {
+		err = fmt.Errorf("api.(*API).UploadDocuments requiert au moins 1 fichier")
+		return
+	}
+
+	endpoint := fmt.Sprintf("%s://%s:%d/v1/bucket/%s/many",
+		a.Voki.Protocol,
+		a.Voki.Host,
+		a.Voki.Port,
+		bucketName,
+	)
+
+	// Create new multipart writer
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	// Add files to the request
+	for i, fileHeader := range fileHeaders {
+		if fileHeader == nil {
+			return response, fmt.Errorf("Fichier %d pointe vers une addresse mémoire nulle", i)
+		}
+
+		file, err := fileHeader.Open()
+		if err != nil {
+			return response, fmt.Errorf("Impossible de lire le contenu du fichier %d '%s': %s", i, fileHeader.Filename, err)
+		}
+		defer file.Close()
+
+		fileName, err := url.QueryUnescape(fileHeader.Filename)
+		if err != nil {
+			return response, fmt.Errorf("Fichier %d '%s' a un nom invalide et impossible à convertir: %s", i, fileHeader.Filename, err)
+		}
+
+		part, err := writer.CreatePart(fileHeader.Header)
+		if err != nil {
+			return response, fmt.Errorf("Impossible d'ajouter %d '%s' au formulaire de téléversement: %s", i, fileName, err)
+		}
+
+		_, err = io.Copy(part, file)
+		if err != nil {
+			return response, fmt.Errorf("Impossible d'ajouter le contenu de %d '%s' au formulaire de téléversement: %s", i, fileName, err)
+		}
+	}
+
+	if err := writer.Close(); err != nil {
+		return response, fmt.Errorf("Impossible de fermer le io.Writer: %s", err)
+	}
+
+	req, err := http.NewRequest(http.MethodPost, endpoint, body)
+	if err != nil {
+		return response, fmt.Errorf("Impossible de produire une requête: %s", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return response, fmt.Errorf("Impossible de parse le formulaire: %s", err)
+	}
+
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+
+	if a.Voki.Key != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", a.Voki.Key))
+	}
+
+	// Send the HTTP request
+	httpResponse, err := a.Voki.Client.Do(req)
+	if err != nil {
+		return response, fmt.Errorf("Impossible d'exécuter la requête http: %s", err)
+	}
+	defer httpResponse.Body.Close()
+
+	return response, json.NewDecoder(httpResponse.Body).Decode(&response)
+}
+
+func (a *API) UploadDocument(bucket string, file_header *multipart.FileHeader) (response CreateDocumentResponse, err error) {
+	endpoint := fmt.Sprintf("%s://%s:%d",
+		a.Voki.Protocol,
+		a.Voki.Host,
+		a.Voki.Port,
+	)
+
+	current_url := fmt.Sprintf("%s/v1/bucket/%s", endpoint, bucket)
+
+	// Create a new multipart writer
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	// Add the file to the request
+	file, err := file_header.Open()
+	if err != nil {
+		return response, fmt.Errorf("UploadDocument#file_header.Open: %s", err)
+	}
+	defer file.Close()
+
+	filename_processed, err := url.QueryUnescape(file_header.Filename)
+	if err != nil {
+		return response, fmt.Errorf("UploadDocument#url.QueryUnescape: %s", err)
+	}
+
+	part, err := writer.CreateFormFile("document", filename_processed)
+	if err != nil {
+		return response, fmt.Errorf("UploadDocument#writer.CreateFormFile: %s", err)
+	}
+
+	_, err = io.Copy(part, file)
+	if err != nil {
+		return response, fmt.Errorf("UploadDocument#io.Copy: %s", err)
+	}
+
+	err = writer.Close()
+	if err != nil {
+		return response, fmt.Errorf("UploadDocument#writer.Close: %s", err)
+	}
+
+	// Create a new HTTP request with the multipart body
+	req, err := http.NewRequest(http.MethodPost, current_url, body)
+	if err != nil {
+		return response, fmt.Errorf("UploadDocument#http.NewRequest: %s", err)
+	}
+
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+
+	if a.Voki.Key != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", a.Voki.Key))
+	}
+
+	// Send the HTTP request
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return response, fmt.Errorf("UploadDocument#client.Do: %s", err)
+	}
+	defer resp.Body.Close()
+
+	err = json.NewDecoder(resp.Body).Decode(&response)
+	return response, err
+}
+
+func (a *API) ListBuckets() (response ListBucketsResponse, err error) {
+	return response, a.Voki.Unmarshal(http.MethodGet, "/v1/bucket", nil, true, &response)
+}
+
+func (a *API) Seed() (response ExecuteSeedResponse, err error) {
+	request, err := NewV1SeedPOST()
+	if err != nil {
+		return
+	}
+
+	return request.Request(a.Voki)
+}

pkg/agecemorg/config.go

@@ -0,0 +1,41 @@
+package agecemorg
+
+/*
+Permet de contenir la configuration obtenue par cobra/viper
+
+Example d'utilisation sans error handling:
+
+```
+var cfg Config
+viper.Unmarshal(&cfg)
+```
+
+`cfg` devrait alors contenir la configuration, et les données peuvent être
+obtenues simplement en utilisant la dot (.) notation
+*/
+type Config struct {
+	Server struct {
+		Admin struct {
+			Auth     bool   `mapstructure:"auth"`
+			Password string `mapstructure:"password"`
+			Username string `mapstructure:"username"`
+		} `mapstructure:"admin"`
+		Api struct {
+			Auth     bool   `mapstructure:"auth"`
+			Host     string `mapstructure:"host"`
+			Key      string `mapstructure:"key"`
+			Port     int    `mapstructure:"port"`
+			Protocol string `mapstructure:"protocol"`
+		} `mapstructure:"api"`
+		Documents struct {
+			AccessKeyId     string            `mapstructure:"access_key_id"`
+			Buckets         map[string]string `mapstructure:"buckets"`
+			Endpoint        string            `mapstructure:"endpoint"`
+			SecretAccessKey string            `mapstructure:"secret_access_key"`
+			UseSSL          bool              `mapstructure:"use_ssl"`
+			KeyId           string            `mapstructure:"keyid"`
+			KeyValue        string            `mapstructure:"keyvalue"`
+		} `mapstructure:"documents"`
+		Port int `mapstructure:"port"`
+	} `mapstructure:"server"`
+}

pkg/agecemorg/entity.go

@@ -0,0 +1,7 @@
+package agecemorg
+
+type Bucket struct {
+	Name        string
+	DisplayName string
+	Documents   []string
+}

pkg/agecemorg/handler.go

@@ -0,0 +1,807 @@
+package agecemorg
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"sort"
+
+	"codeberg.org/vlbeaudoin/pave/v2"
+	"codeberg.org/vlbeaudoin/voki/v3"
+	"github.com/labstack/echo/v4"
+	"github.com/minio/minio-go/v7"
+)
+
+type V1Handler struct {
+	Config      Config
+	MediaClient *MediaClient
+	Pave        *pave.Pave
+}
+
+// API Handlers
+
+// ListRoutes affiche les routes accessibles.
+// Les routes sont triées selon .Path, pour les rendre plus facilement navigables.
+func (h *V1Handler) ListRoutes(c echo.Context) error {
+	routes := c.Echo().Routes()
+	sort.Slice(routes, func(i, j int) bool { return routes[i].Path < routes[j].Path })
+	return c.JSON(http.StatusOK, routes)
+}
+
+// ListBuckets affiche les buckets permis par server.documents.buckets, qui existent.
+func (h *V1Handler) ListBuckets(c echo.Context) error {
+	var request ListBucketsRequest
+	var response ListBucketsResponse
+
+	if !request.Complete() {
+		response.Message = "Incomplete ListBuckets request received"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	var buckets = make(map[string]string)
+
+	for bucket_name, bucket_display_name := range h.Config.Server.Documents.Buckets {
+		exists, err := h.MediaClient.MinioClient.BucketExists(context.Background(), bucket_name)
+		if err != nil {
+			response.Message = "Error during minio#BucketExists"
+			response.SetStatusCode(http.StatusInternalServerError)
+
+			return c.JSON(response.StatusCode(), response)
+		}
+
+		if exists {
+			buckets[bucket_name] = bucket_display_name
+		}
+	}
+
+	response.SetStatusCode(http.StatusOK)
+	response.Message = "Buckets list successful"
+	response.Data.Buckets = buckets
+
+	return c.JSON(response.StatusCode(), response)
+}
+
+func (h *V1Handler) ReadBucket(c echo.Context) error {
+	var request ReadBucketRequest
+	var response ReadBucketResponse
+
+	request.Params.Bucket = c.Param("bucket")
+
+	if !request.Complete() {
+		response.Message = "Incomplete ReadBucket request received"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	allowed := false
+	for bucket_allowed := range h.Config.Server.Documents.Buckets {
+		if request.Params.Bucket == bucket_allowed {
+			allowed = true
+		}
+	}
+
+	if !allowed {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	defer cancel()
+
+	exists, err := h.MediaClient.MinioClient.BucketExists(ctx, request.Params.Bucket)
+	if err != nil {
+		response.Message = "Error during minio#BucketExists"
+		response.SetStatusCode(http.StatusInternalServerError)
+		response.Error = err.Error()
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	if !exists {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	objectCh := h.MediaClient.MinioClient.ListObjects(ctx, request.Params.Bucket, minio.ListObjectsOptions{})
+	for object := range objectCh {
+		if object.Err != nil {
+			response.Message = "Error during minio#ListObjects"
+			response.SetStatusCode(http.StatusInternalServerError)
+			//TODO make sure this is safe
+			//response.Error = object.Err.Error()
+
+			return c.JSON(response.StatusCode(), response)
+		}
+
+		response.Data.Keys = append(response.Data.Keys, object.Key)
+	}
+
+	response.Message = "V1BucketRead ok"
+	response.SetStatusCode(http.StatusOK)
+
+	return c.JSON(response.StatusCode(), response)
+}
+
+/*
+CreateDocuments permet d'ajouter un object dans un bucket, par multipart/form-data
+
+Example:
+
+Téléverser plusieurs fichiers à cette route avec `curl`:
+
+	curl <endpoint> -F 'documents=@example.pdf' -F 'documents=@example.md;type=text/markdown'
+*/
+func (h *V1Handler) CreateDocuments(c echo.Context) (err error) {
+	var request CreateDocumentsRequest
+	var response CreateDocumentsResponse
+
+	request.Params.Bucket = c.Param("bucket")
+
+	var allowed bool
+	for allowedBucket := range h.Config.Server.Documents.Buckets {
+		if request.Params.Bucket == allowedBucket {
+			allowed = true
+		}
+	}
+
+	if !allowed {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	form, err := c.MultipartForm()
+	if err != nil {
+		response.Message = fmt.Sprintf("Téléversement invalide: %s", err)
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+	if form == nil {
+		response.Message = "MultipartForm pointe vers une addresse mémoire nil"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	if len(form.File) == 0 {
+		response.Message = "Veuillez sélectionner au moins 1 document à téléverser"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	for inputName, inputFileHeaders := range form.File {
+		if inputName == "documents" {
+			request.Data.Documents = inputFileHeaders
+		}
+	}
+
+	if request.Data.Documents == nil {
+		response.Message = "Impossible d'obtenir les documents depuis le formulaire"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	if !request.Complete() {
+		response.Message = "Requête CreateDocuments incomplète reçue"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	var code int
+	code, response.Message = h.MediaClient.UploadFormFiles(request.Params.Bucket, request.Data.Documents)
+	response.SetStatusCode(code)
+
+	return c.JSON(response.StatusCode(), response)
+}
+
+// CreateDocument permet d'ajouter un object dans un bucket, par multipart/form-data
+func (h *V1Handler) CreateDocument(c echo.Context) (err error) {
+	var request CreateDocumentRequest
+	var response CreateDocumentResponse
+
+	request.Params.Bucket = c.Param("bucket")
+
+	request.Data.Document, err = c.FormFile("document")
+	if err != nil {
+		response.SetStatusCode(http.StatusBadRequest)
+		response.Message = "Error during CreateDocument's echo#Context.FormFile"
+		response.Error = err.Error()
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	allowed := false
+	for bucket_allowed := range h.Config.Server.Documents.Buckets {
+		if request.Params.Bucket == bucket_allowed {
+			allowed = true
+		}
+	}
+
+	if !allowed {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	if !request.Complete() {
+		response.Message = "Incomplete CreateDocument request received"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	defer cancel()
+
+	src, err := request.Data.Document.Open()
+	if err != nil {
+		response.SetStatusCode(http.StatusBadRequest)
+		response.Message = "Error during form_file.Open()"
+		response.Error = err.Error()
+
+		return c.JSON(response.StatusCode(), response)
+	}
+	defer src.Close()
+
+	info, err := h.MediaClient.MinioClient.PutObject(ctx, request.Params.Bucket, request.Data.Document.Filename, src, request.Data.Document.Size, minio.PutObjectOptions{
+		ContentType: request.Data.Document.Header.Get("Content-Type"),
+	})
+	if err != nil {
+		response.SetStatusCode(http.StatusInternalServerError)
+		response.Message = "Error during minio#PutObject"
+		//response.Error = err.Error()
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	response.SetStatusCode(http.StatusOK)
+	response.Message = "ok"
+	response.Data.Bucket = info.Bucket
+	response.Data.Key = info.Key
+	response.Data.Size = info.Size
+
+	return c.JSON(response.StatusCode(), response)
+}
+
+// ReadDocument permet de lire le contenu d'un fichier et protentiellement de le télécharger
+func (h *V1Handler) ReadDocument(c echo.Context) error {
+	bucket := c.Param("bucket")
+	document := c.Param("document")
+
+	allowed := false
+	for bucket_allowed := range h.Config.Server.Documents.Buckets {
+		if bucket == bucket_allowed {
+			allowed = true
+		}
+	}
+
+	if !allowed {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	defer cancel()
+
+	bucket_exists, err := h.MediaClient.MinioClient.BucketExists(ctx, bucket)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, "Error during minio#BucketExists")
+	}
+
+	if !bucket_exists {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	document_info, err := h.MediaClient.MinioClient.StatObject(ctx, bucket, document, minio.StatObjectOptions{})
+
+	if err != nil {
+		if err.Error() == "The specified key does not exist." {
+
+			response := voki.ResponseNotFound{}
+			return c.JSON(response.StatusCode(), response)
+		}
+
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"message": "Error during minio#StatObject",
+		})
+	}
+
+	_ = document_info
+
+	document_object, err := h.MediaClient.MinioClient.GetObject(ctx, bucket, document, minio.GetObjectOptions{})
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"message": "Error during minio#GetObject",
+		})
+	}
+
+	defer document_object.Close()
+
+	return c.Stream(http.StatusOK, document_info.ContentType, document_object)
+}
+
+// DeleteDocument permet de supprimer un object
+func (h *V1Handler) DeleteDocument(c echo.Context) error {
+	var request DeleteDocumentRequest
+	var response DeleteDocumentResponse
+
+	request.Params.Bucket = c.Param("bucket")
+	request.Params.Document = c.Param("document")
+
+	allowed := false
+	for bucket_allowed := range h.Config.Server.Documents.Buckets {
+		if request.Params.Bucket == bucket_allowed {
+			allowed = true
+		}
+	}
+
+	if !allowed {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	if !request.Complete() {
+		response.Message = "Incomplete DeleteDocument request received"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	defer cancel()
+
+	bucket_exists, err := h.MediaClient.MinioClient.BucketExists(ctx, request.Params.Bucket)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, "Error during minio#BucketExists")
+	}
+
+	if !bucket_exists {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	document_info, err := h.MediaClient.MinioClient.StatObject(ctx, request.Params.Bucket, request.Params.Document, minio.StatObjectOptions{})
+	if err != nil {
+		if err.Error() == "The specified key does not exist." {
+
+			response := voki.ResponseNotFound{}
+			return c.JSON(response.StatusCode(), response)
+		}
+
+		//response.Error = err.Error()
+		response.Message = "Error during minio#StatObject"
+		response.SetStatusCode(http.StatusInternalServerError)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	//TODO Add error validation
+	_ = document_info
+
+	err = h.MediaClient.MinioClient.RemoveObject(ctx, request.Params.Bucket, request.Params.Document, minio.RemoveObjectOptions{})
+	if err != nil {
+		//response.Error = err.Error()
+		response.Message = "Error during minio#RemoveObject"
+		response.SetStatusCode(http.StatusInternalServerError)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	response.Message = "Document deleted"
+	response.SetStatusCode(http.StatusOK)
+
+	return c.JSON(response.StatusCode(), response)
+}
+
+// UpdateDocumentKey
+func (h *V1Handler) UpdateDocumentKey(c echo.Context) (err error) {
+	var request UpdateDocumentKeyRequest
+	var response UpdateDocumentKeyResponse
+
+	request.Params.Bucket = c.Param("bucket")
+	request.Params.Document = c.Param("document")
+
+	var newKey string
+	err = c.Bind(&newKey)
+	if err != nil {
+		response.SetStatusCode(http.StatusBadRequest)
+		response.Message = err.Error()
+
+		return c.JSON(response.StatusCode(), response)
+	}
+	request.Data.NewKey = newKey
+
+	if !request.Complete() {
+		response.SetStatusCode(http.StatusBadRequest)
+		response.Message = "Incomplete UpdateDocumentKey request received"
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	var allowed bool
+	for bucketAllowed := range h.Config.Server.Documents.Buckets {
+		if request.Params.Bucket == bucketAllowed {
+			allowed = true
+		}
+	}
+
+	if !allowed {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	bucketExists, err := h.MediaClient.MinioClient.BucketExists(ctx, request.Params.Bucket)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, "Could not validate bucket exists")
+	}
+
+	if !bucketExists {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	// Check source object exists
+
+	if _, err := h.MediaClient.MinioClient.StatObject(ctx, request.Params.Bucket, request.Params.Document, minio.StatObjectOptions{}); err != nil {
+		if err.Error() == "The specified key does not exist." {
+
+			response := voki.ResponseNotFound{}
+			return c.JSON(response.StatusCode(), response)
+		}
+
+		response.Message = fmt.Sprintf("Could not obtain information on %s/%s", request.Params.Bucket, request.Params.Document)
+		response.SetStatusCode(http.StatusInternalServerError)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	// Copy object to newKey
+
+	if _, err := h.MediaClient.MinioClient.CopyObject(ctx,
+		minio.CopyDestOptions{Bucket: request.Params.Bucket, Object: request.Data.NewKey},
+		minio.CopySrcOptions{Bucket: request.Params.Bucket, Object: request.Params.Document},
+	); err != nil {
+		response.SetStatusCode(http.StatusInternalServerError)
+		response.Message = "Impossible de copier un document pour le renommer"
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	// Verify copy was successful
+	if _, err := h.MediaClient.MinioClient.StatObject(ctx,
+		request.Params.Bucket, request.Data.NewKey, minio.GetObjectOptions{}); err != nil {
+		response.SetStatusCode(http.StatusInternalServerError)
+		response.Message = "Copie de document ne semble pas avoir fonctionnée"
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	// Delete old file
+	if err := h.MediaClient.MinioClient.RemoveObject(ctx,
+		request.Params.Bucket, request.Params.Document, minio.RemoveObjectOptions{}); err != nil {
+		response.SetStatusCode(http.StatusInternalServerError)
+		response.Message = "Erreur pendant tentative de supprimer document source"
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	//TODO cleanup
+
+	// Return result
+	response.SetStatusCode(http.StatusOK)
+	response.Message = "Document renommé avec succès"
+	response.Data.Bucket = request.Params.Bucket
+	response.Data.Key = request.Data.NewKey
+	return c.JSON(response.StatusCode(), response)
+
+}
+
+// ExecuteSeed créé des buckets dans minio selon la liste de buckets dans server.documents.buckets
+// Les buckets sont créés avec paramètres par défaut, et sont ensuite visible dans /v1/bucket.
+func (h *V1Handler) ExecuteSeed(c echo.Context) error {
+	//var request ExecuteSeedRequest
+	var response ExecuteSeedResponse
+
+	new_buckets, err := h.MediaClient.Seed()
+	response.Data.Buckets = new_buckets
+	if err != nil {
+		response.SetStatusCode(http.StatusInternalServerError)
+		response.Message = "Error during mediaClient.Seed()"
+		response.Error = err.Error()
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	if len(new_buckets) == 0 {
+		response.Message = "All buckets already exist"
+
+	} else {
+		response.Message = "Buckets successfully created"
+	}
+
+	response.SetStatusCode(http.StatusOK)
+
+	return c.JSON(response.StatusCode(), response)
+}
+
+const DescriptionV1SpecGET string = "Afficher le API spec en format pave"
+
+func (h *V1Handler) ReadSpec(c echo.Context) error {
+	var request ReadSpecRequest
+	var response ReadSpecResponse
+
+	if !request.Complete() {
+		response.Message = "Incomplete ReadSpec request received"
+		response.SetStatusCode(http.StatusBadRequest)
+
+		return c.JSON(response.StatusCode(), response)
+	}
+
+	response.Data.Spec = fmt.Sprintf("# pave spec for agecem-org %s\n", Version())
+
+	for _, route := range h.Pave.SortedRouteStrings() {
+		response.Data.Spec = fmt.Sprintf("%s%s", response.Data.Spec, route)
+	}
+
+	response.Message = "ok"
+	response.SetStatusCode(http.StatusOK)
+
+	return c.JSON(response.StatusCode(), response)
+}
+
+type WebHandler struct {
+	ApiClient *API
+}
+
+func HandleIndex(c echo.Context) error {
+	return c.Render(http.StatusOK, "index-html", nil)
+}
+
+/*
+func HandleAPropos(c echo.Context) error {
+	return c.Render(http.StatusOK, "a-propos-html", nil)
+}
+*/
+
+/*
+func HandleActualite(c echo.Context) error {
+	return c.Render(http.StatusOK, "actualite-html", nil)
+}
+*/
+
+/*
+func HandleActualiteArticle(c echo.Context) error {
+	article := c.Param("article")
+	return c.String(http.StatusOK, fmt.Sprintf("Article: %s", article))
+}
+*/
+
+func HandleVieEtudiante(c echo.Context) error {
+	return c.Render(http.StatusOK, "vie-etudiante-html", nil)
+}
+
+func HandleVieEtudianteOrganisme(c echo.Context) error {
+	organisme := c.Param("organisme")
+	return c.String(http.StatusOK, fmt.Sprintf("Organisme: %s", organisme))
+}
+
+func (h *WebHandler) HandleDocumentation(c echo.Context) error {
+	var response HandleDocumentationResponse
+
+	v1BucketsGET, err := h.ApiClient.ListBuckets()
+	if err != nil {
+		response.Error = err.Error()
+		response.Message = v1BucketsGET.Message
+		response.SetStatusCode(v1BucketsGET.StatusCode())
+
+		return c.Render(response.StatusCode(), "documentation-html", response)
+	}
+
+	//TODO check v1BucketsGET StatusCode and Error
+
+	for bucket, displayName := range v1BucketsGET.Data.Buckets {
+		// TODO move call to dedicated API client method
+		var v1BucketReadResponse ReadBucketResponse
+
+		if err = h.ApiClient.Voki.Unmarshal(http.MethodGet, fmt.Sprintf("/v1/bucket/%s", bucket), nil, true, &v1BucketReadResponse); err != nil {
+			response.Error = err.Error()
+			response.Message = "Error during json.Unmarshal /v1/bucket/:bucket"
+			response.SetStatusCode(http.StatusInternalServerError)
+
+			return c.Render(http.StatusOK, "documentation-html", response)
+		}
+
+		response.Data.Buckets = append(response.Data.Buckets, Bucket{
+			Name:        bucket,
+			DisplayName: displayName,
+			Documents:   v1BucketReadResponse.Data.Keys,
+		})
+	}
+
+	sort.SliceStable(response.Data.Buckets, func(i, j int) bool { return response.Data.Buckets[i].Name < response.Data.Buckets[j].Name })
+
+	response.SetStatusCode(http.StatusOK)
+	//response.Message = "HandleDocumentation ok"
+
+	// TODO render .Message
+	return c.Render(http.StatusOK, "documentation-html", response)
+	//return c.Render(response.StatusCode(), "documentation-html", response.Data.Buckets)
+}
+
+func HandleFormulaires(c echo.Context) error {
+	return c.Render(http.StatusOK, "formulaires-html", nil)
+}
+
+func (h *WebHandler) HandlePublicDocumentation(c echo.Context) error {
+	bucket := c.Param("bucket")
+	document := c.Param("document")
+
+	unescaped, err := url.QueryUnescape(fmt.Sprintf("/v1/bucket/%s/%s", bucket, document))
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{"message": "Bad Request"})
+	}
+
+	response, err := h.ApiClient.Voki.Call(http.MethodGet, unescaped, nil, true)
+	if err != nil {
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	}
+	defer response.Body.Close()
+
+	switch response.StatusCode {
+	case http.StatusNotFound:
+		response := voki.ResponseNotFound{}
+		return c.JSON(response.StatusCode(), response)
+	case http.StatusInternalServerError:
+		return c.JSON(http.StatusInternalServerError, map[string]string{"message": "Internal Server Error"})
+	}
+
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"message": "Internal Server Error"})
+	}
+
+	return c.Blob(http.StatusOK, "application/octet-stream", body)
+}
+
+func HandleAdmin(c echo.Context) error {
+	return c.Render(http.StatusOK, "admin-html", nil)
+}
+
+func HandlePageProcesVerbaux() echo.HandlerFunc {
+	return func(c echo.Context) error {
+		return c.Render(http.StatusOK, "procesverbaux-html", nil)
+	}
+}
+
+func (h *WebHandler) HandleAdminDocumentsUpload(c echo.Context) error {
+	var response HandleAdminDocumentsUploadResponse
+
+	v1BucketsGET, err := h.ApiClient.ListBuckets()
+	if err != nil {
+		response.SetStatusCode(v1BucketsGET.StatusCode())
+		response.Error = err.Error()
+		response.Message = v1BucketsGET.Message
+
+		return c.Render(response.StatusCode(), "admin-upload-html", nil)
+	}
+
+	for bucketName, displayName := range v1BucketsGET.Data.Buckets {
+		response.Data.Buckets = append(response.Data.Buckets, Bucket{
+			Name:        bucketName,
+			DisplayName: displayName,
+		})
+	}
+	response.SetStatusCode(http.StatusOK)
+
+	return c.Render(response.StatusCode(), "admin-upload-html", response)
+}
+
+func (h *WebHandler) HandleAdminDocumentsUploadPOST(c echo.Context) error {
+	var request CreateDocumentsRequest
+	var response HandleAdminDocumentsUploadResponse
+
+	v1BucketsGET, err := h.ApiClient.ListBuckets()
+	if err != nil {
+		response.SetStatusCode(v1BucketsGET.StatusCode())
+		response.Message = v1BucketsGET.Message
+		response.Error = err.Error()
+
+		return c.Render(response.StatusCode(), "admin-upload-html", response)
+	}
+
+	for bucketName, displayName := range v1BucketsGET.Data.Buckets {
+		response.Data.Buckets = append(response.Data.Buckets, Bucket{
+			Name:        bucketName,
+			DisplayName: displayName,
+		})
+	}
+
+	request.Params.Bucket = c.FormValue("bucket")
+
+	form, err := c.MultipartForm()
+	if err != nil {
+		response.SetStatusCode(http.StatusBadRequest)
+		response.Message = "Impossible de téléverser"
+		response.Error = err.Error()
+
+		return c.Render(response.StatusCode(), "admin-upload-html", response)
+	}
+	if form == nil {
+		response.SetStatusCode(http.StatusInternalServerError)
+		response.Message = "Formulaire pointe vers une addresse mémoire nulle"
+		response.Error = "Formulaire pointe vers une addresse mémoire nulle"
+
+		return c.Render(response.StatusCode(), "admin-upload-html", response)
+	}
+
+	if len(form.File) == 0 {
+		response.SetStatusCode(http.StatusBadRequest)
+		response.Message = "Veuillez sélectionner au moins 1 fichier à téléverser"
+		response.Error = "Input 'documents' ne contient aucun fichier"
+
+		return c.Render(response.StatusCode(), "admin-upload-html", response)
+	}
+
+	for inputName, inputFileHeaders := range form.File {
+		if inputName == "documents" {
+			request.Data.Documents = inputFileHeaders
+			break
+		}
+	}
+
+	if request.Data.Documents == nil {
+		response.SetStatusCode(http.StatusBadRequest)
+		response.Message = "Impossible d'obtenir les documents depuis le formulaire"
+		response.Error = "Impossible d'obtenir les documents depuis le formulaire"
+
+		return c.Render(response.StatusCode(), "admin-upload-html", response)
+	}
+
+	uploadDocumentsResponse, err := h.ApiClient.UploadDocuments(request.Params.Bucket, request.Data.Documents...)
+	if err != nil {
+		//TODO figure out pourquoi `err` n'est jamais `nil`
+		response.SetStatusCode(uploadDocumentsResponse.StatusCode())
+		response.Message = uploadDocumentsResponse.Message
+		response.Error = fmt.Sprintf("%s. Détails: %s", err.Error(), uploadDocumentsResponse.Error)
+		/*
+			response.SetStatusCode(http.StatusInternalServerError)
+			response.Message = fmt.Sprintf("api.(*API).UploadDocuments: %s", err)
+			response.Error = err.Error()
+		*/
+
+		return c.Render(response.StatusCode(), "admin-upload-html", response)
+	}
+
+	//TODO figure out pourquoi on se rend jamais ici
+
+	// Format response
+	var info, status string
+
+	for i, document := range uploadDocumentsResponse.Data.Documents {
+		info = fmt.Sprintf("%s[%d] /public/documentation/%s/%s (%dk) ok\n",
+			info, i, uploadDocumentsResponse.Data.Bucket, document.Key, document.Size)
+	}
+
+	status = uploadDocumentsResponse.Message
+	if errMsg := uploadDocumentsResponse.Error; errMsg != "" {
+		status = fmt.Sprintf("%s. Erreur: %s", status, errMsg)
+	}
+
+	response.SetStatusCode(http.StatusOK)
+	response.Message = fmt.Sprintf("%s \n %s", status, info)
+
+	return c.Render(response.StatusCode(), "admin-upload-html", response)
+}

pkg/agecemorg/media.go

@@ -0,0 +1,184 @@
+package agecemorg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"mime"
+	"mime/multipart"
+	"net/http"
+
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	"github.com/spf13/viper"
+)
+
+func NewMediaClient(endpoint, accessKeyId, secretAccessKey string, useSSL bool) (*MediaClient, error) {
+	if accessKeyId == "" {
+		return nil, errors.New("accessKeyId was found empty, but cannot be")
+	}
+
+	if secretAccessKey == "" {
+		return nil, errors.New("secretAccessKey was found empty, but cannot be")
+	}
+
+	var mediaClient MediaClient
+	minioClient, err := minio.New(endpoint, &minio.Options{
+		Creds:  credentials.NewStaticV4(accessKeyId, secretAccessKey, ""),
+		Secure: useSSL,
+	})
+	if err != nil {
+		return &mediaClient, err
+	}
+
+	mediaClient.MinioClient = *minioClient
+	return &mediaClient, nil
+}
+
+func NewMediaClientFromViper() (*MediaClient, error) {
+	var cfg Config
+	if err := viper.Unmarshal(&cfg); err != nil {
+		return nil, err
+	}
+
+	mediaClient, err := NewMediaClient(cfg.Server.Documents.Endpoint, cfg.Server.Documents.AccessKeyId, cfg.Server.Documents.SecretAccessKey, cfg.Server.Documents.UseSSL)
+	if err != nil {
+		return mediaClient, err
+	}
+
+	return mediaClient, nil
+}
+
+type MediaClient struct {
+	MinioClient minio.Client
+}
+
+func (m *MediaClient) Seed() ([]string, error) {
+	var cfg Config
+	if err := viper.Unmarshal(&cfg); err != nil {
+		return nil, err
+	}
+
+	var new_buckets []string
+
+	for bucket := range cfg.Server.Documents.Buckets {
+		exists, err := m.MinioClient.BucketExists(context.Background(), bucket)
+		if err != nil {
+			return new_buckets, err
+		}
+
+		if exists {
+			continue
+		}
+
+		if err = m.MinioClient.MakeBucket(context.Background(), bucket, minio.MakeBucketOptions{}); err != nil {
+			return new_buckets, err
+		}
+		new_buckets = append(new_buckets, bucket)
+	}
+
+	return new_buckets, nil
+}
+
+func (m *MediaClient) UploadFormFiles(bucketName string, fileHeaders []*multipart.FileHeader) (statusCode int, result string) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	ok, err := m.MinioClient.BucketExists(ctx, bucketName)
+	if err != nil {
+		return http.StatusInternalServerError, fmt.Sprintf("Erreur lors de vérification d'existence de bucket '%s': %s", bucketName, err)
+	}
+	if !ok {
+		return http.StatusBadRequest, fmt.Sprintf("Bucket '%s' n'existe pas", bucketName)
+	}
+
+	switch count := len(fileHeaders); count {
+	case 0:
+		return http.StatusBadRequest, "Veuillez sélectionner au moins 1 document à téléverser"
+	case 1:
+		result = "Téléversement de 1 fichier\n"
+	default:
+		result = fmt.Sprintf("Téléversement de %d fichiers\n", count)
+	}
+
+	var allowedMediaTypes = []string{"application/pdf", "text/markdown", "text/plain"}
+
+	var fileNames []string
+	for _, fileHeader := range fileHeaders {
+		fileNames = append(fileNames, fileHeader.Filename)
+	}
+
+	var validFileHeaders []*multipart.FileHeader
+
+	for i, fileHeader := range fileHeaders {
+		// Check for conflicting file names in upload
+		for j, fileName := range fileNames {
+			if fileName == fileHeader.Filename && i != j {
+				return http.StatusBadRequest, fmt.Sprintf("Doublon de nom de fichier '%s' trouvé, les noms de fichiers doivent être uniques", fileName)
+			}
+		}
+
+		// Check media type
+		mediaType, _, err := mime.ParseMediaType(fileHeader.Header.Get("Content-Type"))
+		if err != nil {
+			return http.StatusBadRequest, fmt.Sprintf("Impossible de déterminer le type de fichier pour %d '%s'.\nPlus de détails: %s", i, fileHeader.Filename, err.Error())
+		}
+
+		var isAllowedMediaType bool
+
+		for _, allowedMediaType := range allowedMediaTypes {
+			if allowedMediaType == mediaType {
+				isAllowedMediaType = true
+			}
+		}
+
+		if !isAllowedMediaType {
+			return http.StatusUnsupportedMediaType, fmt.Sprintf("Type de fichier interdit '%s' pour '%s'.\nTypes de fichiers permis: %s", mediaType, fileHeader.Filename, allowedMediaTypes)
+		}
+
+		// Check for conflicting fileNames with existing files
+		objectInfo, err := m.MinioClient.StatObject(ctx, bucketName, fileHeader.Filename, minio.StatObjectOptions{})
+		if err == nil && objectInfo.Key == fileHeader.Filename {
+			return http.StatusConflict, fmt.Sprintf("Un document au nom '%s' de catégorie '%s' existe déjà et ne peut pas être inséré de cette façon.", fileHeader.Filename, bucketName)
+		}
+
+		switch msg := err.Error(); msg {
+		case "The specified key does not exist.":
+		default:
+			return http.StatusInternalServerError, fmt.Sprintf("Erreur inattendue lors de vérification de conflit de nom de fichier avec la base de données: %s", err)
+		}
+
+		validFileHeaders = append(validFileHeaders, fileHeader)
+	}
+
+	if len(validFileHeaders) == 0 {
+		return http.StatusOK, "Aucun fichier valide envoyé au serveur, rien à faire."
+	}
+
+	for i, fileHeader := range validFileHeaders {
+		mediaType, _, err := mime.ParseMediaType(fileHeader.Header.Get("Content-Type"))
+		if err != nil {
+			return http.StatusBadRequest, fmt.Sprintf("Impossible de déterminer le type de fichier pour %d '%s'.\nPlus de détails: %s", i, fileHeader.Filename, err.Error())
+		}
+
+		// Get file content
+		fileContent, err := fileHeader.Open()
+		if err != nil {
+			return http.StatusBadRequest, fmt.Sprintf("Impossible de lire le contenu de '%s': %s", fileHeader.Filename, err)
+		}
+		defer fileContent.Close()
+
+		// Upload file
+		info, err := m.MinioClient.PutObject(ctx, bucketName, fileHeader.Filename, fileContent, fileHeader.Size, minio.PutObjectOptions{
+			ContentType: mediaType,
+		})
+		if err != nil {
+			return http.StatusInternalServerError, fmt.Sprintf("Impossible d'ajouter '%s' à la base de donnée: %s", fileHeader.Filename, err)
+		}
+
+		result = fmt.Sprintf("%sDocument %d '%s' de type '%s' et de taille '%d' téléversé à '%s' avec succès\n",
+			result, i, info.Key, mediaType, info.Size, info.Bucket)
+	}
+
+	return http.StatusCreated, result
+}

pkg/agecemorg/request.go

@@ -0,0 +1,306 @@
+/*
+File request.go contains the JSON request types for HTTP endpoints.
+
+Le fichier request.go contient les types de requêtes pour les endpoints HTTP.
+*/
+package agecemorg
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"mime/multipart"
+	"net/http"
+
+	"codeberg.org/vlbeaudoin/voki/v3"
+)
+
+var _ voki.Requester[ListBucketsResponse] = ListBucketsRequest{}
+
+type ListBucketsRequest struct{}
+
+func NewV1BucketsGET() (request ListBucketsRequest, err error) {
+	return
+}
+
+func (request ListBucketsRequest) Complete() bool { return true }
+
+func (request ListBucketsRequest) Request(v *voki.Voki) (response ListBucketsResponse, err error) {
+	if !request.Complete() {
+		err = fmt.Errorf("Incomplete V1BucketsGET request")
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodGet, "/v1/bucket", nil, true, &response)
+}
+
+var _ voki.Requester[ReadBucketResponse] = ReadBucketRequest{}
+
+type ReadBucketRequest struct {
+	Params struct {
+		Bucket string `json:"bucket"`
+	}
+}
+
+func NewV1BucketGET(bucket string) (request ReadBucketRequest, err error) {
+	if bucket == "" {
+		err = fmt.Errorf("NewV1BucketGET requires non-nil bucket name")
+	}
+
+	request.Params.Bucket = bucket
+
+	return
+}
+
+func (request ReadBucketRequest) Complete() bool { return request.Params.Bucket != "" }
+
+func (request ReadBucketRequest) Request(v *voki.Voki) (response ReadBucketResponse, err error) {
+	if !request.Complete() {
+		err = fmt.Errorf("Incomplete V1BucketGET request")
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodGet, fmt.Sprintf("/v1/bucket/%s", request.Params.Bucket), nil, true, &response)
+}
+
+var _ voki.Requester[CreateDocumentsResponse] = CreateDocumentsRequest{}
+
+type CreateDocumentsRequest struct {
+	Data struct {
+		Documents []*multipart.FileHeader `json:"documents"`
+	}
+	Params struct {
+		Bucket string `json:"bucket"`
+	}
+}
+
+func NewV1DocumentsPOST(bucket string, documents ...*multipart.FileHeader) (request CreateDocumentsRequest, err error) {
+	if bucket == "" {
+		err = fmt.Errorf("NewV1DocumentsPOST requires non-nil bucket name")
+		return
+	}
+
+	request.Params.Bucket = bucket
+
+	if documents == nil {
+		err = fmt.Errorf("NewV1DocumentsPOST requires non-nil documents")
+		return
+	}
+
+	for _, document := range documents {
+		if document == nil {
+			err = fmt.Errorf("NewV1DocumentsPOST requires non-nil documents")
+			return
+		}
+	}
+
+	request.Data.Documents = documents
+
+	return
+}
+
+func (request CreateDocumentsRequest) Complete() bool {
+	if request.Data.Documents == nil {
+		return false
+	}
+	for _, document := range request.Data.Documents {
+		if document == nil {
+			return false
+		}
+	}
+
+	return request.Params.Bucket != ""
+}
+
+func (request CreateDocumentsRequest) Request(v *voki.Voki) (response CreateDocumentsResponse, err error) {
+	if !request.Complete() {
+		err = fmt.Errorf("Incomplete V1DocumentsPOST request")
+		return
+	}
+
+	var buf bytes.Buffer
+	if err = json.NewEncoder(&buf).Encode(request.Data); err != nil {
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodPost, fmt.Sprintf("/v1/bucket/%s/many", request.Params.Bucket), &buf, true, &response)
+}
+
+var _ voki.Requester[CreateDocumentResponse] = CreateDocumentRequest{}
+
+type CreateDocumentRequest struct {
+	Data struct {
+		Document *multipart.FileHeader `json:"document"`
+	}
+	Params struct {
+		Bucket string `json:"bucket"`
+	}
+}
+
+func NewV1DocumentPOST(bucket string, document *multipart.FileHeader) (request CreateDocumentRequest, err error) {
+	if bucket == "" {
+		err = fmt.Errorf("NewV1DocumentPOST requires non-nil bucket name")
+		return
+	}
+
+	request.Params.Bucket = bucket
+
+	if document == nil {
+		err = fmt.Errorf("NewV1DocumentPOST requires non-nil document")
+		return
+	}
+
+	request.Data.Document = document
+
+	return
+}
+
+func (request CreateDocumentRequest) Complete() bool {
+	return request.Params.Bucket != "" && request.Data.Document != nil
+}
+
+func (request CreateDocumentRequest) Request(v *voki.Voki) (response CreateDocumentResponse, err error) {
+	if !request.Complete() {
+		err = fmt.Errorf("Incomplete V1DocumentPOST request")
+		return
+	}
+
+	var buf bytes.Buffer
+	if err = json.NewEncoder(&buf).Encode(request.Data); err != nil {
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodPost, fmt.Sprintf("/v1/bucket/%s", request.Params.Bucket), &buf, true, &response)
+}
+
+var _ voki.Requester[DeleteDocumentResponse] = DeleteDocumentRequest{}
+
+type DeleteDocumentRequest struct {
+	Params struct {
+		Bucket   string `json:"bucket"`
+		Document string `json:"document"`
+	}
+}
+
+func NewV1DocumentDELETE(bucket, document string) (request DeleteDocumentRequest, err error) {
+	if bucket == "" {
+		err = fmt.Errorf("NewV1DocumentDELETE requires non-nil bucket name")
+		return
+	}
+
+	request.Params.Bucket = bucket
+
+	if document == "" {
+		err = fmt.Errorf("NewV1DocumentDELETE requires non-nil document name")
+		return
+	}
+
+	request.Params.Document = document
+
+	return
+}
+
+func (request DeleteDocumentRequest) Complete() bool {
+	return request.Params.Bucket != "" && request.Params.Document != ""
+}
+
+func (request DeleteDocumentRequest) Request(v *voki.Voki) (response DeleteDocumentResponse, err error) {
+	if !request.Complete() {
+		err = fmt.Errorf("Incomplete V1DocumentDELETE request")
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodDelete, fmt.Sprintf("/v1/bucket/%s/%s", request.Params.Bucket, request.Params.Document), nil, true, &response)
+}
+
+var _ voki.Requester[UpdateDocumentKeyResponse] = UpdateDocumentKeyRequest{}
+
+type UpdateDocumentKeyRequest struct {
+	Data struct {
+		NewKey string `json:"newKey"`
+	}
+	Params struct {
+		Bucket   string `json:"bucket"`
+		Document string `json:"document"`
+	}
+}
+
+func NewV1DocumentKeyPUT(bucket, document, newKey string) (request UpdateDocumentKeyRequest, err error) {
+	if bucket == "" {
+		err = fmt.Errorf("NewV1DocumentKeyPUT requires non-nil bucket name")
+		return
+	}
+
+	request.Params.Bucket = bucket
+
+	if document == "" {
+		err = fmt.Errorf("NewV1DocumentKeyPUT requires non-nil src document name")
+		return
+	}
+
+	request.Params.Document = document
+
+	if newKey == "" {
+		err = fmt.Errorf("NewV1DocumentKeyPUT requires non-nil dst document name")
+	}
+
+	request.Data.NewKey = newKey
+
+	return
+}
+
+func (request UpdateDocumentKeyRequest) Complete() bool {
+	return request.Params.Bucket != "" && request.Params.Document != "" && request.Data.NewKey != ""
+}
+
+func (request UpdateDocumentKeyRequest) Request(v *voki.Voki) (response UpdateDocumentKeyResponse, err error) {
+	if !request.Complete() {
+		err = fmt.Errorf("Incomplete V1DocumentKeyPUT request")
+		return
+	}
+
+	var buf bytes.Buffer
+	if err = json.NewEncoder(&buf).Encode(request.Data); err != nil {
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodPut, fmt.Sprintf("/v1/bucket/%s/%s", request.Params.Bucket, request.Params.Document), &buf, true, &response)
+}
+
+var _ voki.Requester[ExecuteSeedResponse] = ExecuteSeedRequest{}
+
+type ExecuteSeedRequest struct{}
+
+func NewV1SeedPOST() (request ExecuteSeedRequest, err error) {
+	return
+}
+
+func (r ExecuteSeedRequest) Complete() bool { return true }
+
+func (r ExecuteSeedRequest) Request(v *voki.Voki) (response ExecuteSeedResponse, err error) {
+	if !r.Complete() {
+		err = fmt.Errorf("Incomplete V1SeedPOST")
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodPost, "/v1/seed", nil, true, &response)
+}
+
+var _ voki.Requester[ReadSpecResponse] = ReadSpecRequest{}
+
+type ReadSpecRequest struct{}
+
+func NewV1SpecGET() (request ReadSpecRequest, err error) {
+	return
+}
+
+func (request ReadSpecRequest) Complete() bool { return true }
+
+func (request ReadSpecRequest) Request(v *voki.Voki) (response ReadSpecResponse, err error) {
+	if !request.Complete() {
+		err = fmt.Errorf("Incomplete V1SpecGET")
+		return
+	}
+
+	return response, v.UnmarshalIfComplete(http.MethodGet, "/v1/spec", nil, true, &response)
+}

pkg/agecemorg/response.go

@@ -0,0 +1,110 @@
+/*
+File response.go contains the JSON and HTML response types for HTTP endpoints.
+
+Le fichier response.go contient les types de réponses JSON et HTML pour les endpoints HTTP.
+*/
+package agecemorg
+
+import (
+	"codeberg.org/vlbeaudoin/voki/v3"
+)
+
+type APIResponse struct {
+	voki.MessageResponse
+	statusCode int
+	Error      string
+}
+
+func (R APIResponse) StatusCode() int {
+	return R.statusCode
+}
+
+func (R *APIResponse) SetStatusCode(code int) {
+	R.statusCode = code
+}
+
+type ListBucketsResponse struct {
+	APIResponse
+	Data struct {
+		Buckets map[string]string
+	}
+}
+
+type ReadBucketResponse struct {
+	APIResponse
+	Data struct {
+		Keys []string
+	}
+}
+
+type DataDocument struct {
+	Key  string
+	Size int64
+}
+
+type CreateDocumentsResponse struct {
+	APIResponse
+	Data struct {
+		Bucket    string
+		Documents []DataDocument
+	}
+}
+
+type CreateDocumentResponse struct {
+	APIResponse
+	Data struct {
+		Bucket string
+		DataDocument
+	}
+}
+
+type DeleteDocumentResponse struct {
+	APIResponse
+}
+
+type UpdateDocumentKeyResponse struct {
+	APIResponse
+	Data struct {
+		Bucket string
+		Key    string
+	}
+}
+
+type ExecuteSeedResponse struct {
+	APIResponse
+	Data struct {
+		Buckets []string
+	}
+}
+
+type ReadSpecResponse struct {
+	APIResponse
+	Data struct {
+		Spec string
+	}
+}
+
+type HandleAdminDocumentsUploadResponse struct {
+	APIResponse
+	Data struct {
+		Buckets []Bucket
+	}
+}
+
+type HandleDocumentationResponse struct {
+	APIResponse
+	Data struct {
+		Buckets []Bucket
+	}
+}
+
+type UploadDocumentAPIResponse struct {
+	APIResponse
+	Data UploadDocumentResponseData
+}
+
+type UploadDocumentResponseData struct {
+	Bucket string
+	Object string
+	Size   float64
+}

pkg/agecemorg/routes.go

@@ -0,0 +1,185 @@
+package agecemorg
+
+import (
+	"crypto/subtle"
+	"fmt"
+	"log"
+	"net/http"
+
+	"codeberg.org/vlbeaudoin/pave/v2"
+	"git.agecem.com/agecem/agecem-org/v3/ui"
+	"git.agecem.com/agecem/agecem-org/v3/ui/public"
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+)
+
+func RunServer(cfg Config) {
+	e := echo.New()
+
+	e.Renderer = ui.NewRenderer()
+
+	e.Pre(middleware.RemoveTrailingSlash())
+
+	groupStatic := e.Group("/public/*")
+	groupStatic.Use(middleware.StaticWithConfig(middleware.StaticConfig{
+		Root:       "/",
+		Filesystem: http.FS(public.GetPublicFS()),
+		//TODO
+		//Browse:     true,
+	}))
+
+	groupV1 := e.Group("/v1")
+
+	groupV1.Use(middleware.AddTrailingSlash())
+
+	if cfg.Server.Api.Auth {
+		if len(cfg.Server.Api.Key) < 10 {
+			log.Fatal("server.api.auth is enabled, but server.api.key is too small (needs at least 10 characters)")
+		}
+
+		groupV1.Use(middleware.KeyAuth(func(key string, c echo.Context) (bool, error) {
+			return subtle.ConstantTimeCompare([]byte(key), []byte(cfg.Server.Api.Key)) == 1, nil
+		}))
+
+		log.Println("Key auth for /v1 activated")
+	}
+
+	groupAdmin := e.Group("/admin")
+
+	groupAdmin.Use(middleware.AddTrailingSlash())
+
+	if cfg.Server.Admin.Auth {
+		if len(cfg.Server.Admin.Username) < 5 {
+			log.Fatal("server.admin.auth is enabled, but server.admin.username is too small (needs at least 5 characters)")
+		}
+
+		if len(cfg.Server.Admin.Password) < 10 {
+			log.Fatal("server.admin.auth is enabled, but server.admin.password is too small (needs at least 10 characters)")
+		}
+
+		groupAdmin.Use(middleware.BasicAuth(func(username_entered, password_entered string, c echo.Context) (bool, error) {
+			// Be careful to use constant time comparison to prevent timing attacks
+			if subtle.ConstantTimeCompare([]byte(username_entered), []byte(cfg.Server.Admin.Username)) == 1 &&
+				subtle.ConstantTimeCompare([]byte(password_entered), []byte(cfg.Server.Admin.Password)) == 1 {
+				return true, nil
+			}
+			return false, nil
+		}))
+
+		log.Println("Basic auth for /admin activated")
+	}
+
+	// API Routes
+	mediaClient, err := NewMediaClientFromViper()
+	if err != nil {
+		log.Fatal("Error during NewMediaClientFromViper for API handlers")
+	}
+
+	p := pave.New()
+
+	v1Handler := V1Handler{
+		Config:      cfg,
+		MediaClient: mediaClient,
+		Pave:        &p,
+	}
+
+	groupV1.GET("", v1Handler.ListRoutes)
+
+	if err := pave.EchoRegister[
+		ExecuteSeedRequest,
+		ExecuteSeedResponse](groupV1, &p, "/v1", http.MethodPost, "/seed", "Créer buckets manquants définis dans `server.documents.buckets`", "ExecuteSeed", v1Handler.ExecuteSeed); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := pave.EchoRegister[
+		UpdateDocumentKeyRequest,
+		UpdateDocumentKeyResponse](groupV1, &p, "/v1", http.MethodPut, "/bucket/:bucket/:document/key", "Renommer un document", "UpdateDocumentKey", v1Handler.UpdateDocumentKey); err != nil {
+
+		log.Fatal(err)
+	}
+
+	if err := pave.EchoRegister[
+		ReadSpecRequest,
+		ReadSpecResponse](groupV1, &p, "/v1", http.MethodGet, "/spec", DescriptionV1SpecGET, "SpecRead", v1Handler.ReadSpec); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := pave.EchoRegister[
+		ListBucketsRequest,
+		ListBucketsResponse](groupV1, &p, "/v1", http.MethodGet, "/bucket", "List buckets", "ListBuckets", v1Handler.ListBuckets); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := pave.EchoRegister[
+		ReadBucketRequest,
+		ReadBucketResponse](groupV1, &p, "/v1", http.MethodGet, "/bucket/:bucket", "Read bucket content", "ReadBucket", v1Handler.ReadBucket); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := pave.EchoRegister[
+		CreateDocumentsRequest,
+		CreateDocumentsResponse](groupV1, &p, "/v1", http.MethodPost, "/bucket/:bucket/many", "Upload documents to specified bucket", "CreateDocuments", v1Handler.CreateDocuments); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := pave.EchoRegister[
+		CreateDocumentRequest,
+		CreateDocumentResponse](groupV1, &p, "/v1", http.MethodPost, "/bucket/:bucket", "Upload document to specified bucket", "CreateDocument", v1Handler.CreateDocument); err != nil {
+		log.Fatal(err)
+	}
+
+	// Do not move to pave, uses echo.Stream instead of echo.JSON
+	groupV1.GET("/bucket/:bucket/:document", v1Handler.ReadDocument)
+
+	if err := pave.EchoRegister[
+		DeleteDocumentRequest,
+		DeleteDocumentResponse](groupV1, &p, "/v1", http.MethodDelete, "/bucket/:bucket/:document", "Delete document in specified bucket", "DeleteDocument", v1Handler.DeleteDocument); err != nil {
+		log.Fatal(err)
+	}
+
+	// HTML Routes
+	client := http.DefaultClient
+	defer client.CloseIdleConnections()
+
+	apiClient, err := NewAPIClientFromViper(client)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	webHandler := WebHandler{
+		ApiClient: apiClient,
+	}
+
+	e.GET("/", HandleIndex)
+
+	//e.GET("/a-propos", HandleAPropos)
+
+	//e.GET("/actualite", HandleActualite)
+
+	//e.GET("/actualite/:article", HandleActualiteArticle)
+
+	e.GET("/vie-etudiante", HandleVieEtudiante)
+
+	e.GET("/vie-etudiante/:organisme", HandleVieEtudianteOrganisme)
+
+	e.GET("/documentation", webHandler.HandleDocumentation)
+
+	e.GET("/proces-verbaux", HandlePageProcesVerbaux())
+
+	e.GET("/formulaires", HandleFormulaires)
+
+	// Public Routes
+
+	e.GET("/public/documentation/:bucket/:document", webHandler.HandlePublicDocumentation)
+
+	// Admin Routes
+
+	groupAdmin.GET("", HandleAdmin)
+
+	groupAdmin.GET("/documents/upload", webHandler.HandleAdminDocumentsUpload)
+
+	groupAdmin.POST("/documents/upload", webHandler.HandleAdminDocumentsUploadPOST)
+
+	e.Logger.Fatal(e.Start(
+		fmt.Sprintf(":%d", cfg.Server.Port)))
+}

pkg/agecemorg/version.go

@@ -0,0 +1,19 @@
+package agecemorg
+
+// Filled by build flag
+var version string
+
+/*
+Version returns the application version
+
+Example command to use the output of `git describe` for version number at build time:
+
+	$ go build -ldflags="-X 'git.agecem.com/agecem/agecem-org/pkg/agecemorg/version.version=`git describe`'" .
+*/
+func Version() string {
+	if version == "" {
+		return "version unknown"
+	}
+
+	return version
+}