snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/compose/automation/attachment_handler.go

@@ -0,0 +1,227 @@
+package automation
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/cortezaproject/corteza/server/compose/types"
+)
+
+type (
+	attachmentService interface {
+		FindByID(ctx context.Context, namespaceID, attachmentID uint64) (*types.Attachment, error)
+		CreateRecordAttachment(ctx context.Context, namespaceID uint64, name string, size int64, fh io.ReadSeeker, moduleID, recordID uint64, fieldName string) (att *types.Attachment, err error)
+		DeleteByID(ctx context.Context, namespaceID uint64, attachmentID uint64) error
+		OpenOriginal(att *types.Attachment) (io.ReadSeekCloser, error)
+		OpenPreview(att *types.Attachment) (io.ReadSeekCloser, error)
+	}
+
+	attachmentHandler struct {
+		reg modulesHandlerRegistry
+		svc attachmentService
+	}
+
+	attachmentLookup interface {
+		GetAttachment() (bool, uint64, *types.Attachment)
+	}
+)
+
+func AttachmentHandler(reg modulesHandlerRegistry, svc attachmentService) *attachmentHandler {
+	h := &attachmentHandler{
+		reg: reg,
+		svc: svc,
+	}
+
+	h.register()
+	return h
+}
+
+func (h attachmentHandler) lookup(ctx context.Context, args *attachmentLookupArgs) (results *attachmentLookupResults, err error) {
+	results = &attachmentLookupResults{}
+	results.Attachment, err = h.svc.FindByID(ctx, 0, args.Attachment)
+	return
+}
+
+func (h attachmentHandler) delete(ctx context.Context, args *attachmentDeleteArgs) error {
+	return h.svc.DeleteByID(ctx, 0, args.Attachment)
+}
+
+func (h attachmentHandler) openOriginal(ctx context.Context, args *attachmentOpenOriginalArgs) (*attachmentOpenOriginalResults, error) {
+	att, err := lookupAttachment(ctx, h.svc, args)
+	if err != nil {
+		return nil, err
+	}
+
+	r := &attachmentOpenOriginalResults{}
+	r.Content, err = h.svc.OpenOriginal(att)
+	if err != nil {
+		return nil, err
+	}
+
+	// @todo we need to call Close() when file is read (or at the end of the workflow)
+	//       some kind of workflow-cleanup facility is needed
+
+	return r, nil
+}
+
+func (h attachmentHandler) openPreview(ctx context.Context, args *attachmentOpenPreviewArgs) (*attachmentOpenPreviewResults, error) {
+	att, err := lookupAttachment(ctx, h.svc, args)
+	if err != nil {
+		return nil, err
+	}
+
+	r := &attachmentOpenPreviewResults{}
+	r.Content, err = h.svc.OpenOriginal(att)
+	if err != nil {
+		return nil, err
+	}
+
+	// @todo we need to call Close() when file is read (or at the end of the workflow)
+	//       some kind of workflow-cleanup facility is needed
+
+	return r, nil
+}
+
+func (h attachmentHandler) create(ctx context.Context, args *attachmentCreateArgs) (*attachmentCreateResults, error) {
+	var (
+		err error
+		att *types.Attachment
+
+		fh   io.ReadSeeker
+		size int64
+	)
+
+	switch {
+	case len(args.contentBytes) > 0:
+		size = int64(len(args.contentBytes))
+		fh = bytes.NewReader(args.contentBytes)
+
+	case args.contentStream != nil:
+		if rs, is := args.contentStream.(io.ReadSeeker); is {
+			_, err = rs.Seek(0, 0)
+			if err != nil {
+				return nil, err
+			}
+
+			size, err = getReaderSize(rs)
+			if err != nil {
+				return nil, err
+			}
+
+			_, err = rs.Seek(0, 0)
+			if err != nil {
+				return nil, err
+			}
+
+			fh = rs
+		} else {
+			// In case we only got a reader...
+			//
+			// For future proofing, for handling larger attachment, we create a temp.
+			// file which we then use as a reader
+
+			// Preparations
+			tmpf, err := ioutil.TempFile("", "reader")
+			if err != nil {
+				return nil, err
+			}
+			defer tmpf.Close()
+			defer os.Remove(tmpf.Name())
+
+			// Writing content to file
+			w := bufio.NewWriter(tmpf)
+			r := args.contentStream
+			buf := make([]byte, 1024)
+			for {
+				// read
+				n, err := r.Read(buf)
+				if err != nil && err != io.EOF {
+					return nil, err
+				}
+				if n == 0 {
+					break
+				}
+
+				// on-the-fly size calculation
+				size += int64(n)
+
+				// write
+				if _, err := w.Write(buf[:n]); err != nil {
+					return nil, err
+				}
+			}
+			if err = w.Flush(); err != nil {
+				return nil, err
+			}
+
+			_, err = tmpf.Seek(0, 0)
+			if err != nil {
+				return nil, err
+			}
+			fh = tmpf
+		}
+
+	default:
+		fh = strings.NewReader(args.contentString)
+		size = int64(len(args.contentString))
+	}
+
+	switch {
+	case args.Resource != nil:
+		att, err = h.svc.CreateRecordAttachment(
+			ctx,
+			args.Resource.NamespaceID,
+			args.Name,
+			size,
+			fh,
+			args.Resource.ModuleID,
+			args.Resource.ID,
+			args.FieldName,
+		)
+	default:
+		return nil, fmt.Errorf("unknown resource")
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &attachmentCreateResults{att}, nil
+}
+
+func lookupAttachment(ctx context.Context, svc attachmentService, args attachmentLookup) (*types.Attachment, error) {
+	_, ID, attachment := args.GetAttachment()
+
+	switch {
+	case attachment != nil:
+		return attachment, nil
+	case ID > 0:
+		return svc.FindByID(ctx, 0, ID)
+	}
+
+	return nil, fmt.Errorf("empty attachment lookup params")
+}
+
+func getReaderSize(r io.Reader) (size int64, err error) {
+	buf := make([]byte, 1024)
+	var n int
+	for {
+		// read a chunk
+		n, err = r.Read(buf)
+		if err != nil && err != io.EOF {
+			return 0, err
+		}
+		if n == 0 {
+			break
+		}
+		size += int64(n)
+	}
+
+	return size, nil
+}