feat: export input progress report for expenses, marketings, purchases, and recordings

internal/modules/expenses/controllers/expense.controller.go

@@ -6,7 +6,9 @@ import (
 	"math"
 	"strconv"
 	"strings"
+	"time"
 
+	"gitlab.com/mbugroup/lti-api.git/internal/common/exportprogress"
 	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/dto"
 	service "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/services"
@@ -29,6 +31,25 @@ func NewExpenseController(expenseService service.ExpenseService) *ExpenseControl
 }
 
 func (u *ExpenseController) GetAll(c *fiber.Ctx) error {
+	if exportprogress.IsProgressExportRequest(c) {
+		query, err := exportprogress.ParseQuery(c)
+		if err != nil {
+			return err
+		}
+		rows, err := u.ExpenseService.GetProgressRows(c, query)
+		if err != nil {
+			return err
+		}
+		content, err := exportprogress.BuildWorkbook("Expenses", query, rows)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "failed to generate progress excel file")
+		}
+		filename := fmt.Sprintf("expenses_progress_%s.xlsx", time.Now().Format("20060102_150405"))
+		c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+		c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+		return c.Status(fiber.StatusOK).Send(content)
+	}
+
 	query := &validation.Query{
 		Page:   c.QueryInt("page", 1),
 		Limit:  c.QueryInt("limit", 10),

internal/modules/expenses/repositories/expense.repository.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"
 
+	"gitlab.com/mbugroup/lti-api.git/internal/common/exportprogress"
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
@@ -20,6 +21,7 @@ type ExpenseRepository interface {
 	WithProjectFlockKandangFilter(pfkID, kandangID uint) func(*gorm.DB) *gorm.DB
 	CountUnfinishedByProjectFlockKandang(ctx context.Context, pfkID, kandangID uint, isFinished func(*entity.Approval) bool) (int64, error)
 	DeleteOne(ctx context.Context, id uint) error
+	GetProgressRows(ctx context.Context, startDate, endDate time.Time, allowedLocationIDs []uint, restrict bool) ([]exportprogress.Row, error)
 }
 
 type ExpenseRepositoryImpl struct {
@@ -130,3 +132,64 @@ func (r *ExpenseRepositoryImpl) DeleteOne(ctx context.Context, id uint) error {
 	}
 	return nil
 }
+
+func (r *ExpenseRepositoryImpl) GetProgressRows(ctx context.Context, startDate, endDate time.Time, allowedLocationIDs []uint, restrict bool) ([]exportprogress.Row, error) {
+	const unassignedSQL = "'" + exportprogress.UnassignedKandangName + "'"
+	query := r.DB().WithContext(ctx).
+		Table("expenses AS e").
+		Select(`
+			'Expenses' AS module,
+			COALESCE(pf.flock_name, loc.name, fallback_loc.name, 'Unknown Farm') AS farm_name,
+			COALESCE(k.name, `+unassignedSQL+`, 'Unknown Kandang') AS kandang_name,
+			DATE(e.transaction_date) AS activity_date,
+			COUNT(*) AS count
+		`).
+		Joins("LEFT JOIN (SELECT DISTINCT expense_id, project_flock_kandang_id, kandang_id FROM expense_nonstocks) en ON en.expense_id = e.id").
+		Joins("LEFT JOIN project_flock_kandangs pfk ON pfk.id = en.project_flock_kandang_id").
+		Joins("LEFT JOIN project_flocks pf ON pf.id = pfk.project_flock_id").
+		Joins("LEFT JOIN kandangs k ON k.id = COALESCE(en.kandang_id, pfk.kandang_id)").
+		Joins("LEFT JOIN locations loc ON loc.id = k.location_id").
+		Joins("LEFT JOIN locations fallback_loc ON fallback_loc.id = e.location_id").
+		Where("e.deleted_at IS NULL").
+		Where("DATE(e.transaction_date) >= DATE(?)", startDate).
+		Where("DATE(e.transaction_date) <= DATE(?)", endDate)
+
+	if restrict {
+		if len(allowedLocationIDs) == 0 {
+			return []exportprogress.Row{}, nil
+		}
+		query = query.Where("e.location_id IN ?", allowedLocationIDs)
+	}
+
+	type progressRowResult struct {
+		Module       string
+		FarmName     string
+		KandangName  string
+		ActivityDate string
+		Count        int
+	}
+	scanned := make([]progressRowResult, 0)
+	err := query.
+		Group("DATE(e.transaction_date), COALESCE(pf.flock_name, loc.name, fallback_loc.name, 'Unknown Farm'), COALESCE(k.name, " + unassignedSQL + ", 'Unknown Kandang')").
+		Order("activity_date ASC, farm_name ASC, kandang_name ASC").
+		Scan(&scanned).Error
+	if err != nil {
+		return nil, err
+	}
+
+	rows := make([]exportprogress.Row, 0, len(scanned))
+	for _, item := range scanned {
+		activityDate, err := time.Parse("2006-01-02", item.ActivityDate)
+		if err != nil {
+			return nil, err
+		}
+		rows = append(rows, exportprogress.Row{
+			Module:       item.Module,
+			FarmName:     item.FarmName,
+			KandangName:  item.KandangName,
+			ActivityDate: activityDate,
+			Count:        item.Count,
+		})
+	}
+	return rows, nil
+}

internal/modules/expenses/repositories/expense_progress_test.go

@@ -0,0 +1,72 @@
+package repository
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/common/exportprogress"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+)
+
+func TestExpenseRepositoryGetProgressRows(t *testing.T) {
+	db := openExpenseProgressTestDB(t)
+	repo := NewExpenseRepository(db)
+
+	mustExec(t, db, `CREATE TABLE locations (id INTEGER PRIMARY KEY, name TEXT)`)
+	mustExec(t, db, `CREATE TABLE project_flocks (id INTEGER PRIMARY KEY, flock_name TEXT)`)
+	mustExec(t, db, `CREATE TABLE kandangs (id INTEGER PRIMARY KEY, name TEXT, location_id INTEGER)`)
+	mustExec(t, db, `CREATE TABLE project_flock_kandangs (id INTEGER PRIMARY KEY, project_flock_id INTEGER, kandang_id INTEGER)`)
+	mustExec(t, db, `CREATE TABLE expenses (id INTEGER PRIMARY KEY, location_id INTEGER, transaction_date DATE, deleted_at DATETIME)`)
+	mustExec(t, db, `CREATE TABLE expense_nonstocks (id INTEGER PRIMARY KEY, expense_id INTEGER, project_flock_kandang_id INTEGER, kandang_id INTEGER)`)
+
+	mustExec(t, db, `INSERT INTO locations (id, name) VALUES (1, 'Farm Location')`)
+	mustExec(t, db, `INSERT INTO project_flocks (id, flock_name) VALUES (1, 'Farm A')`)
+	mustExec(t, db, `INSERT INTO kandangs (id, name, location_id) VALUES (1, 'Kandang 1', 1), (2, 'Kandang 2', 1)`)
+	mustExec(t, db, `INSERT INTO project_flock_kandangs (id, project_flock_id, kandang_id) VALUES (1, 1, 1), (2, 1, 2)`)
+	mustExec(t, db, `INSERT INTO expenses (id, location_id, transaction_date, deleted_at) VALUES (1, 1, '2026-06-10', NULL), (2, 1, '2026-06-10', NULL)`)
+	mustExec(t, db, `INSERT INTO expense_nonstocks (id, expense_id, project_flock_kandang_id, kandang_id) VALUES
+		(1, 1, 1, NULL),
+		(2, 1, 1, NULL),
+		(3, 1, 2, NULL)`)
+
+	rows, err := repo.GetProgressRows(context.Background(), time.Date(2026, 6, 1, 0, 0, 0, 0, time.UTC), time.Date(2026, 6, 30, 0, 0, 0, 0, time.UTC), nil, false)
+	if err != nil {
+		t.Fatalf("GetProgressRows failed: %v", err)
+	}
+
+	if len(rows) != 3 {
+		t.Fatalf("expected 3 grouped rows, got %d", len(rows))
+	}
+	assertProgressRow(t, rows, "Farm A", "Kandang 1", "2026-06-10", 1)
+	assertProgressRow(t, rows, "Farm A", "Kandang 2", "2026-06-10", 1)
+	assertProgressRow(t, rows, "Farm Location", "Farm-level / Unassigned", "2026-06-10", 1)
+}
+
+func openExpenseProgressTestDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=private"), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("failed opening sqlite db: %v", err)
+	}
+	return db
+}
+
+func mustExec(t *testing.T, db *gorm.DB, query string, args ...any) {
+	t.Helper()
+	if err := db.Exec(query, args...).Error; err != nil {
+		t.Fatalf("exec failed for %q: %v", query, err)
+	}
+}
+
+func assertProgressRow(t *testing.T, rows []exportprogress.Row, farm, kandang, date string, count int) {
+	t.Helper()
+	for _, row := range rows {
+		if row.FarmName == farm && row.KandangName == kandang && row.ActivityDate.Format("2006-01-02") == date && row.Count == count {
+			return
+		}
+	}
+	t.Fatalf("expected row farm=%s kandang=%s date=%s count=%d, got %+v", farm, kandang, date, count, rows)
+}

internal/modules/expenses/services/expense.service.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"time"
 
+	"gitlab.com/mbugroup/lti-api.git/internal/common/exportprogress"
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
@@ -38,6 +39,7 @@ type ExpenseService interface {
 	DeleteDocument(ctx *fiber.Ctx, expenseID uint, documentID uint64, isRealization bool) error
 	Approval(ctx *fiber.Ctx, req *validation.ApprovalRequest, approvalType string) ([]expenseDto.ExpenseDetailDTO, error)
 	BulkApproveToStatus(ctx *fiber.Ctx, req *validation.BulkApprovalRequest, target approvalutils.ApprovalStep) ([]expenseDto.ExpenseDetailDTO, error)
+	GetProgressRows(ctx *fiber.Ctx, query *exportprogress.Query) ([]exportprogress.Row, error)
 }
 
 type expenseService struct {
@@ -156,6 +158,14 @@ func (s expenseService) GetOne(c *fiber.Ctx, id uint) (*expenseDto.ExpenseDetail
 	return &responseDTO, nil
 }
 
+func (s expenseService) GetProgressRows(c *fiber.Ctx, query *exportprogress.Query) ([]exportprogress.Row, error) {
+	locationScope, err := middleware.ResolveLocationScope(c, s.Repository.DB())
+	if err != nil {
+		return nil, err
+	}
+	return s.Repository.GetProgressRows(c.Context(), query.StartDate, query.EndDate, locationScope.IDs, locationScope.Restrict)
+}
+
 func (s *expenseService) CreateOne(c *fiber.Ctx, req *validation.Create) (*expenseDto.ExpenseDetailDTO, error) {
 	if err := s.Validate.Struct(req); err != nil {
 		return nil, err