move api/server to api/edge/bff

api/edge/bff/internal/server/paymentapiimp/documents.go

@@ -0,0 +1,172 @@
+package paymentapiimp
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/tech/sendico/pkg/api/http/response"
+	"github.com/tech/sendico/pkg/discovery"
+	"github.com/tech/sendico/pkg/merrors"
+	"github.com/tech/sendico/pkg/mlogger"
+	"github.com/tech/sendico/pkg/model"
+	"github.com/tech/sendico/pkg/mservice"
+	"github.com/tech/sendico/pkg/mutil/mzap"
+	documentsv1 "github.com/tech/sendico/pkg/proto/billing/documents/v1"
+	"github.com/tech/sendico/server/interface/api/sresponse"
+	mutil "github.com/tech/sendico/server/internal/mutil/param"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/status"
+)
+
+const (
+	documentsServiceName  = "BILLING_DOCUMENTS"
+	documentsOperationGet = discovery.OperationDocumentsGet
+	documentsDialTimeout  = 5 * time.Second
+	documentsCallTimeout  = 10 * time.Second
+)
+
+func (a *PaymentAPI) getActDocument(r *http.Request, account *model.Account, _ *sresponse.TokenData) http.HandlerFunc {
+	orgRef, err := a.oph.GetRef(r)
+	if err != nil {
+		a.logger.Warn("Failed to parse organization reference for document request", zap.Error(err), mutil.PLog(a.oph, r))
+		return response.BadReference(a.logger, a.Name(), a.oph.Name(), a.oph.GetID(r), err)
+	}
+
+	ctx := r.Context()
+	allowed, err := a.enf.Enforce(ctx, a.permissionRef, account.ID, orgRef, bson.NilObjectID, model.ActionRead)
+	if err != nil {
+		a.logger.Warn("Failed to check payments access permissions", zap.Error(err), mutil.PLog(a.oph, r))
+		return response.Auto(a.logger, a.Name(), err)
+	}
+	if !allowed {
+		a.logger.Debug("Access denied when downloading act", mutil.PLog(a.oph, r))
+		return response.AccessDenied(a.logger, a.Name(), "payments read permission denied")
+	}
+
+	paymentRef := strings.TrimSpace(r.URL.Query().Get("payment_ref"))
+	if paymentRef == "" {
+		paymentRef = strings.TrimSpace(r.URL.Query().Get("paymentRef"))
+	}
+	if paymentRef == "" {
+		return response.BadRequest(a.logger, a.Name(), "missing_parameter", "payment_ref is required")
+	}
+
+	if a.discovery == nil {
+		return response.Error(a.logger, a.Name(), http.StatusServiceUnavailable, "service_unavailable", "discovery client is not configured")
+	}
+
+	lookupCtx, cancel := context.WithTimeout(ctx, discoveryLookupTimeout)
+	defer cancel()
+
+	lookupResp, err := a.discovery.Lookup(lookupCtx)
+	if err != nil {
+		a.logger.Warn("Failed to lookup discovery registry", zap.Error(err))
+		return response.Auto(a.logger, a.Name(), err)
+	}
+
+	service := findDocumentsService(lookupResp.Services)
+	if service == nil {
+		return response.Error(a.logger, a.Name(), http.StatusServiceUnavailable, "service_unavailable", "billing documents service unavailable")
+	}
+
+	docResp, err := a.fetchActDocument(ctx, service.InvokeURI, paymentRef)
+	if err != nil {
+		a.logger.Warn("Failed to fetch act document", zap.Error(err), mzap.ObjRef("organization_ref", orgRef))
+		return documentErrorResponse(a.logger, a.Name(), err)
+	}
+	if len(docResp.GetContent()) == 0 {
+		return response.Error(a.logger, a.Name(), http.StatusInternalServerError, "empty_document", "document service returned empty payload")
+	}
+
+	filename := strings.TrimSpace(docResp.GetFilename())
+	if filename == "" {
+		filename = fmt.Sprintf("act_%s.pdf", paymentRef)
+	}
+	mimeType := strings.TrimSpace(docResp.GetMimeType())
+	if mimeType == "" {
+		mimeType = "application/pdf"
+	}
+
+	return func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", mimeType)
+		w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", filename))
+		w.WriteHeader(http.StatusOK)
+		if _, writeErr := w.Write(docResp.GetContent()); writeErr != nil {
+			a.logger.Warn("Failed to write document response", zap.Error(writeErr))
+		}
+	}
+}
+
+func (a *PaymentAPI) fetchActDocument(ctx context.Context, invokeURI, paymentRef string) (*documentsv1.GetDocumentResponse, error) {
+	dialCtx, cancel := context.WithTimeout(ctx, documentsDialTimeout)
+	defer cancel()
+
+	conn, err := grpc.DialContext(dialCtx, invokeURI, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	if err != nil {
+		return nil, merrors.InternalWrap(err, "dial billing documents")
+	}
+	defer conn.Close()
+
+	client := documentsv1.NewDocumentServiceClient(conn)
+
+	callCtx, callCancel := context.WithTimeout(ctx, documentsCallTimeout)
+	defer callCancel()
+
+	return client.GetDocument(callCtx, &documentsv1.GetDocumentRequest{
+		PaymentRef: paymentRef,
+		Type:       documentsv1.DocumentType_DOCUMENT_TYPE_ACT,
+	})
+}
+
+func findDocumentsService(services []discovery.ServiceSummary) *discovery.ServiceSummary {
+	for _, svc := range services {
+		if !strings.EqualFold(svc.Service, documentsServiceName) {
+			continue
+		}
+		if !svc.Healthy || strings.TrimSpace(svc.InvokeURI) == "" {
+			continue
+		}
+		if len(svc.Ops) == 0 || hasOperation(svc.Ops, documentsOperationGet) {
+			return &svc
+		}
+	}
+	return nil
+}
+
+func hasOperation(ops []string, target string) bool {
+	for _, op := range ops {
+		if strings.EqualFold(strings.TrimSpace(op), target) {
+			return true
+		}
+	}
+	return false
+}
+
+func documentErrorResponse(logger mlogger.Logger, source mservice.Type, err error) http.HandlerFunc {
+	statusErr, ok := status.FromError(err)
+	if !ok {
+		return response.Internal(logger, source, err)
+	}
+
+	switch statusErr.Code() {
+	case codes.InvalidArgument:
+		return response.BadRequest(logger, source, "invalid_argument", statusErr.Message())
+	case codes.NotFound:
+		return response.NotFound(logger, source, statusErr.Message())
+	case codes.Unimplemented:
+		return response.NotImplemented(logger, source, statusErr.Message())
+	case codes.FailedPrecondition:
+		return response.Error(logger, source, http.StatusPreconditionFailed, "failed_precondition", statusErr.Message())
+	case codes.Unavailable:
+		return response.Error(logger, source, http.StatusServiceUnavailable, "service_unavailable", statusErr.Message())
+	default:
+		return response.Internal(logger, source, err)
+	}
+}