fix: compiled generic_report.jrxml manually using docker exec unlockedv2-server-1 sh -c cd /app/backend/src/templates && /opt/jasperstarter/bin/jasperstarter compile generic_report.jrxml

Author: corypride

backend/go.mod

@@ -26,10 +26,7 @@ require (
 	gorm.io/gorm v1.25.12
 )
 
-require (
-	github.com/go-pdf/fpdf v0.9.0
-	github.com/xuri/excelize/v2 v2.9.0
-)
+require github.com/xuri/excelize/v2 v2.9.0
 
 require (
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect

backend/go.sum

@@ -57,8 +57,6 @@ github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GM
 github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
 github.com/go-co-op/gocron/v2 v2.16.1 h1:ux/5zxVRveCaCuTtNI3DiOk581KC1KpJbpJFYUEVYwo=
 github.com/go-co-op/gocron/v2 v2.16.1/go.mod h1:opexeOFy5BplhsKdA7bzY9zeYih8I8/WNJ4arTIFPVc=
-github.com/go-pdf/fpdf v0.9.0 h1:PPvSaUuo1iMi9KkaAn90NuKi+P4gwMedWPHhj8YlJQw=
-github.com/go-pdf/fpdf v0.9.0/go.mod h1:oO8N111TkmKb9D7VvWGLvLJlaZUQVPM+6V42pp3iV4Y=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=

backend/src/handlers/reports_handler.go

@@ -1,9 +1,8 @@
 package handlers
 
 import (
-	"UnlockEdv2/src"
+	"UnlockEdv2/src/jasper"
 	"UnlockEdv2/src/models"
-	"bytes"
 	"context"
 	"encoding/csv"
 	"encoding/json"
@@ -13,106 +12,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/go-pdf/fpdf"
 	"github.com/sirupsen/logrus"
 	"github.com/xuri/excelize/v2"
 )
 
 const (
-	pdfMaxWidth         = 280.0
-	pdfSampleSize       = 100
 	maxDateRangeDays    = 90
 	maxFacilitiesInList = 50
 )
 
-func calculateOptimalColumnWidths(config *ColumnWidthConfig) []float64 {
-	colWidths := make([]float64, len(config.Headers))
-	copy(colWidths, config.MinWidths)
-
-	sampleSize := config.SampleSize
-	if sampleSize > len(config.Data) {
-		sampleSize = len(config.Data)
-	}
-
-	for i := 0; i < sampleSize; i++ {
-		for j, cell := range config.Data[i] {
-			if j < len(colWidths) {
-				contentWidth := config.PDF.GetStringWidth(cell) + 4
-				if contentWidth > colWidths[j] {
-					colWidths[j] = contentWidth
-				}
-			}
-		}
-	}
-
-	totalWidth := 0.0
-	for _, width := range colWidths {
-		totalWidth += width
-	}
-
-	if totalWidth > config.MaxWidth {
-		scale := config.MaxWidth / totalWidth
-		for i := range colWidths {
-			colWidths[i] *= scale
-		}
-	}
-
-	return colWidths
-}
-
-func renderPDFTable(config *PDFTableConfig) {
-	config.PDF.SetFont("Arial", "B", config.HeaderFontSize)
-	for i, header := range config.Headers {
-		config.PDF.CellFormat(config.ColumnWidths[i], 7, header, "1", 0, "C", false, 0, "")
-	}
-	config.PDF.Ln(-1)
-
-	config.PDF.SetFont("Arial", "", config.DataFontSize)
-	for _, row := range config.Data {
-		for i, cell := range row {
-			if i < len(config.ColumnWidths) {
-				alignment := "L"
-				if i < len(config.Alignments) {
-					alignment = config.Alignments[i]
-				}
-				config.PDF.CellFormat(config.ColumnWidths[i], 6, cell, "1", 0, alignment, false, 0, "")
-			}
-		}
-		config.PDF.Ln(-1)
-	}
-}
-
-func renderPDFHeader(pdf *fpdf.Fpdf, title string, filterSummary []models.PDFFilterLine) {
-	pdf.RegisterImageOptionsReader("logo", fpdf.ImageOptions{ImageType: "PNG"}, bytes.NewReader(src.UnlockedLogoImg))
-	pdf.ImageOptions("logo", 10, 10, 25, 0, false, fpdf.ImageOptions{ImageType: "PNG"}, 0, "")
-
-	pdf.SetFont("Arial", "B", 16)
-	pdf.SetXY(40, 12)
-	pdf.Cell(0, 8, title+" Report")
-
-	pdf.SetFont("Arial", "", 9)
-	pdf.SetXY(40, 21)
-	pdf.Cell(0, 5, "Generated: "+time.Now().Format("January 2, 2006 at 3:04 PM"))
-
-	if len(filterSummary) > 0 {
-		pdf.SetXY(10, 38)
-		pdf.SetFont("Arial", "B", 10)
-		pdf.Cell(0, 5, "Report Filters:")
-		pdf.Ln(6)
-
-		pdf.SetFont("Arial", "", 9)
-		for _, filter := range filterSummary {
-			pdf.SetX(15)
-			pdf.Cell(30, 5, filter.Label+":")
-			pdf.Cell(0, 5, filter.Value)
-			pdf.Ln(5)
-		}
-		pdf.Ln(5)
-	} else {
-		pdf.Ln(30)
-	}
-}
-
 func buildFilterSummary(req *models.ReportGenerateRequest, facilityName, residentName string) []models.PDFFilterLine {
 	var filters []models.PDFFilterLine
 
@@ -245,25 +153,6 @@ func (srv *Server) handleGenerateReport(w http.ResponseWriter, r *http.Request,
 	}
 }
 
-type PDFTableConfig struct {
-	PDF            *fpdf.Fpdf
-	Headers        []string
-	ColumnWidths   []float64
-	Alignments     []string
-	Data           [][]string
-	HeaderFontSize float64
-	DataFontSize   float64
-}
-
-type ColumnWidthConfig struct {
-	PDF        *fpdf.Fpdf
-	Headers    []string
-	Data       [][]string
-	MinWidths  []float64
-	MaxWidth   float64
-	SampleSize int
-}
-
 type reportExporter interface {
 	ToCSV() ([][]string, error)
 	ToExcel() (*excelize.File, error)
@@ -412,39 +301,30 @@ func (srv *Server) exportReport(w http.ResponseWriter, report reportExporter, fo
 
 		filterSummary := buildFilterSummary(req, facilityName, residentName)
 
-		pdf := fpdf.New("L", "mm", "A4", "")
-		pdf.AddPage()
-
-		renderPDFHeader(pdf, config.Title, filterSummary)
-
-		pdf.SetFont("Arial", "", config.DataFontSize)
-
-		colWidths := calculateOptimalColumnWidths(&ColumnWidthConfig{
-			PDF:        pdf,
-			Headers:    config.Headers,
-			Data:       config.Data,
-			MinWidths:  config.MinWidths,
-			MaxWidth:   pdfMaxWidth,
-			SampleSize: pdfSampleSize,
-		})
+		var pdfBytes []byte
+		switch req.Type {
+		case models.AttendanceReport:
+			pdfBytes, err = jasper.GenerateAttendanceReportPDF(config, filterSummary)
+		case models.ProgramOutcomesReport:
+			pdfBytes, err = jasper.GenerateProgramOutcomesReportPDF(config, filterSummary)
+		case models.FacilityComparisonReport:
+			pdfBytes, err = jasper.GenerateFacilityComparisonReportPDF(config, filterSummary)
+		default:
+			return newBadRequestServiceError(errors.New("unsupported report type"), "unsupported report type for PDF generation")
+		}
 
-		renderPDFTable(&PDFTableConfig{
-			PDF:            pdf,
-			Headers:        config.Headers,
-			ColumnWidths:   colWidths,
-			Alignments:     config.Alignments,
-			Data:           config.Data,
-			HeaderFontSize: config.HeaderFontSize,
-			DataFontSize:   config.DataFontSize,
-		})
+		if err != nil {
+			logrus.WithError(err).Error("Failed to generate PDF with Jasper")
+			return newInternalServerServiceError(err, "failed to generate PDF")
+		}
 
 		filename := fmt.Sprintf("%s-Report-%s.pdf", config.Title, time.Now().Format("2006-01-02"))
 		w.Header().Set("Content-Type", "application/pdf")
 		w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
 		w.WriteHeader(http.StatusOK)
 
-		if err := pdf.Output(w); err != nil {
-			return newInternalServerServiceError(err, "failed to generate PDF")
+		if _, err := w.Write(pdfBytes); err != nil {
+			return newInternalServerServiceError(err, "failed to write PDF")
 		}
 		return nil
 

backend/src/jasper/jasper_service.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/evertonvps/go-jasper"
@@ -182,3 +183,119 @@ func GenerateUsageReportPDF(db *database.DB, queryCtx *models.QueryContext, hasP
 	service := newJasperServiceWithContext(db, queryCtx, hasProgramAccess)
 	return service.generateUsageReportPDF(userID)
 }
+
+func generateReportPDF(config models.PDFConfig, filterSummary []models.PDFFilterLine, templateName string) ([]byte, error) {
+	type ReportData struct {
+		Rows [][]string `json:"rows"`
+	}
+
+	rows := config.Data
+	if len(rows) == 0 {
+		rows = [][]string{}
+	}
+
+	reportData := ReportData{
+		Rows: rows,
+	}
+
+	jsonData, err := json.Marshal(reportData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal report data: %w", err)
+	}
+
+	title := config.Title
+	if title == "" {
+		title = "Report"
+	}
+
+	filterSummaryText := ""
+	if len(filterSummary) > 0 {
+		var filterLines []string
+		for _, filter := range filterSummary {
+			filterLines = append(filterLines, fmt.Sprintf("%s: %s", filter.Label, filter.Value))
+		}
+		filterSummaryText = strings.Join(filterLines, "\n")
+	}
+
+	params := []jasper.Parameter{
+		{Key: "ReportTitle", Value: title},
+		{Key: "GeneratedDate", Value: time.Now().Format("January 2, 2006 at 3:04 PM")},
+		{Key: "LogoImage", Value: base64.StdEncoding.EncodeToString(src.UnlockedLogoImg)},
+		{Key: "FilterSummary", Value: filterSummaryText},
+	}
+
+	tempDir := os.Getenv("JASPER_TEMP_DIR")
+	if tempDir == "" {
+		tempDir = filepath.Join(os.TempDir(), "jasper-reports")
+		if err := os.MkdirAll(tempDir, 0755); err != nil {
+			return nil, fmt.Errorf("failed to create temp directory: %w", err)
+		}
+		logrus.WithField("temp_dir", tempDir).Info("JASPER_TEMP_DIR not set, using fallback directory")
+	}
+
+	outputFileName := fmt.Sprintf("%s_%s", templateName, uuid.New().String())
+	outputFilePath := filepath.Join(tempDir, outputFileName)
+	jsonFileName := fmt.Sprintf("%s_%s.json", templateName, uuid.New().String())
+	jsonFilePath := filepath.Join(tempDir, jsonFileName)
+
+	if err := os.WriteFile(jsonFilePath, jsonData, 0600); err != nil {
+		return nil, fmt.Errorf("failed to write temporary data file: %w", err)
+	}
+
+	defer func() {
+		if err := os.Remove(jsonFilePath); err != nil {
+			logrus.WithFields(logrus.Fields{
+				"json_file": jsonFilePath,
+				"error":     err,
+			}).Warn("Failed to remove temporary JSON file")
+		}
+
+		if err := os.Remove(outputFilePath + ".pdf"); err != nil {
+			logrus.WithFields(logrus.Fields{
+				"pdf_file": outputFilePath + ".pdf",
+				"error":    err,
+			}).Warn("Failed to remove temporary PDF file")
+		}
+	}()
+
+	gj := jasper.NewGoJasperJsonData(jsonFilePath, "", params, "pdf", outputFilePath)
+	gj.Output = outputFilePath
+
+	if path, err := exec.LookPath("jasperstarter"); err == nil {
+		gj.Executable = path
+	} else {
+		logrus.Info("jasperstarter not found in PATH, falling back to default path")
+		gj.Executable = "/opt/jasperstarter/bin/jasperstarter"
+	}
+
+	templateDir := os.Getenv("JASPER_TEMPLATE_DIR")
+	if templateDir == "" {
+		templateDir = "/templates"
+	}
+	compiledTemplatePath := filepath.Join(templateDir, templateName+".jasper")
+
+	pdfBytes, err := gj.Process(compiledTemplatePath)
+	if err != nil {
+		logrus.WithFields(logrus.Fields{
+			"template_path": compiledTemplatePath,
+			"template_dir":  templateDir,
+			"error":         err,
+		}).Error("Failed to process compiled template")
+
+		return nil, fmt.Errorf("failed to process template: %w", err)
+	}
+
+	return pdfBytes, nil
+}
+
+func GenerateAttendanceReportPDF(config models.PDFConfig, filterSummary []models.PDFFilterLine) ([]byte, error) {
+	return generateReportPDF(config, filterSummary, "attendance_report")
+}
+
+func GenerateProgramOutcomesReportPDF(config models.PDFConfig, filterSummary []models.PDFFilterLine) ([]byte, error) {
+	return generateReportPDF(config, filterSummary, "program_outcomes_report")
+}
+
+func GenerateFacilityComparisonReportPDF(config models.PDFConfig, filterSummary []models.PDFFilterLine) ([]byte, error) {
+	return generateReportPDF(config, filterSummary, "facility_comparison_report")
+}