PDF & Excel Export

type ExportService struct {
    db *gorm.DB
}

func NewExportService(db *gorm.DB) *ExportService {
    return &ExportService{db: db}
}

// GeneratePDF creates a formatted PDF document from records
func (s *ExportService) GeneratePDF(resource string) (string, error) {
    // Queries data, formats into PDF, saves to temp file
    // Returns the file path
}

// GenerateExcel creates an .xlsx spreadsheet from records
func (s *ExportService) GenerateExcel(resource string) (string, error) {
    // Queries data, creates Excel workbook with headers and rows
    // Returns the file path
}

// GenerateCSV creates a .csv file from records
func (s *ExportService) GenerateCSV(resource string) (string, error) {
    // Queries data, writes CSV with headers and rows
    // Returns the file path
}

func (s *ExportService) GeneratePDF(resource string) (string, error) {
    // 1. Query all records from the database
    var blogs []models.Blog
    s.db.Find(&blogs)

    // 2. Create a new PDF document
    pdf := gopdf.New()
    pdf.AddPage()

    // 3. Add a title
    pdf.SetFont("Helvetica", "B", 18)
    pdf.Cell(nil, "Blog Export Report")

    // 4. Add a table with headers
    pdf.SetFont("Helvetica", "B", 10)
    headers := []string{"ID", "Title", "Created At", "Status"}
    for _, h := range headers {
        pdf.Cell(nil, h)
    }

    // 5. Add data rows
    pdf.SetFont("Helvetica", "", 10)
    for _, blog := range blogs {
        pdf.Cell(nil, blog.Title)
        pdf.Cell(nil, blog.CreatedAt.Format("2006-01-02"))
    }

    // 6. Save to temp file and return path
    path := filepath.Join(os.TempDir(), "blog-export.pdf")
    pdf.WritePdf(path)
    return path, nil
}

func (s *ExportService) GenerateExcel(resource string) (string, error) {
    // 1. Query all records
    var blogs []models.Blog
    s.db.Find(&blogs)

    // 2. Create a new Excel workbook
    f := excelize.NewFile()
    sheet := "Blogs"
    f.SetSheetName("Sheet1", sheet)

    // 3. Write headers (row 1)
    headers := []string{"ID", "Title", "Content", "Created At"}
    for i, h := range headers {
        cell := fmt.Sprintf("%c1", 'A'+i)
        f.SetCellValue(sheet, cell, h)
    }

    // 4. Style headers (bold, background color)
    style, _ := f.NewStyle(&excelize.Style{
        Font: &excelize.Font{Bold: true},
        Fill: excelize.Fill{Type: "pattern", Color: []string{"#6c5ce7"}, Pattern: 1},
    })
    f.SetCellStyle(sheet, "A1", "D1", style)

    // 5. Write data rows
    for i, blog := range blogs {
        row := i + 2
        f.SetCellValue(sheet, fmt.Sprintf("A%d", row), blog.ID)
        f.SetCellValue(sheet, fmt.Sprintf("B%d", row), blog.Title)
        f.SetCellValue(sheet, fmt.Sprintf("C%d", row), blog.Content)
        f.SetCellValue(sheet, fmt.Sprintf("D%d", row), blog.CreatedAt.Format("2006-01-02"))
    }

    // 6. Save to temp file
    path := filepath.Join(os.TempDir(), "blog-export.xlsx")
    f.SaveAs(path)
    return path, nil
}

func (s *ExportService) GenerateCSV(resource string) (string, error) {
    var blogs []models.Blog
    s.db.Find(&blogs)

    path := filepath.Join(os.TempDir(), "blog-export.csv")
    file, _ := os.Create(path)
    defer file.Close()

    writer := csv.NewWriter(file)
    defer writer.Flush()

    // Write headers
    writer.Write([]string{"ID", "Title", "Content", "Created At"})

    // Write data rows
    for _, blog := range blogs {
        writer.Write([]string{
            fmt.Sprintf("%d", blog.ID),
            blog.Title,
            blog.Content,
            blog.CreatedAt.Format("2006-01-02"),
        })
    }

    return path, nil
}

ID,Title,Content,Created At
1,My First Post,Hello world...,2026-03-15
2,Second Post,More content...,2026-03-16
3,Third Post,Even more...,2026-03-17

// Export blogs to PDF — returns the file path
func (a *App) ExportBlogsPDF() (string, error) {
    return a.exportService.GeneratePDF("blogs")
}

// Export blogs to Excel
func (a *App) ExportBlogsExcel() (string, error) {
    return a.exportService.GenerateExcel("blogs")
}

// Export blogs to CSV
func (a *App) ExportBlogsCSV() (string, error) {
    return a.exportService.GenerateCSV("blogs")
}

import { ExportBlogsPDF } from '../../../wailsjs/go/main/App'
import { BrowserOpenURL } from '../../../wailsjs/runtime'

async function handleExportPDF() {
  const filePath = await ExportBlogsPDF()
  // Open the file with the system default app
  BrowserOpenURL("file://" + filePath)
}

func (s *ExportService) addHeader(pdf *gopdf.GoPdf, title string) {
    // Company name
    pdf.SetFont("Helvetica", "B", 24)
    pdf.SetTextColor(108, 92, 231) // Grit purple
    pdf.Cell(nil, "My Company")

    // Report title
    pdf.SetFont("Helvetica", "", 14)
    pdf.SetTextColor(144, 144, 168) // Muted text
    pdf.Cell(nil, title)

    // Date
    pdf.SetFont("Helvetica", "", 10)
    pdf.Cell(nil, "Generated: " + time.Now().Format("January 2, 2006"))

    // Divider line
    pdf.Line(20, pdf.GetY()+5, 575, pdf.GetY()+5)
}