Merge branch 'FEAT/BE/report_customer_payment' into 'development'

[Feat][BE]: creating report customer payment API

See merge request mbugroup/lti-api!190

internal/middleware/permissions.go

@@ -52,6 +52,7 @@ const (
 	P_ReportDebtSupplierGetAll     = "lti.repport.debtsupplier.list"
 	P_ReportHppPerKandangGetAll    = "lti.repport.gethppperkandang.list"
 	P_ReportProductionResultGetAll = "lti.repport.production_result.list"
+	P_ReportCustomerPaymentGetAll  = "lti.repport.customerpayment.list"
 )
 
 const (

internal/modules/marketing/services/deliveryorder.service.go

@@ -249,7 +249,7 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 
 			// Hitung total_weight dan total_price otomatis
 			totalWeight := requestedProduct.Qty * requestedProduct.AvgWeight
-			totalPrice := requestedProduct.UnitPrice * requestedProduct.Qty
+			totalPrice := requestedProduct.UnitPrice * totalWeight
 
 			deliveryProduct.ProductWarehouseId = foundMarketingProduct.ProductWarehouseId
 			deliveryProduct.UnitPrice = requestedProduct.UnitPrice
@@ -363,7 +363,7 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 
 				// Hitung total_weight dan total_price otomatis
 				totalWeight := requestedProduct.Qty * requestedProduct.AvgWeight
-				totalPrice := requestedProduct.UnitPrice * requestedProduct.Qty
+				totalPrice := requestedProduct.UnitPrice * totalWeight
 
 				deliveryProduct.ProductWarehouseId = foundMarketingProduct.ProductWarehouseId
 				deliveryProduct.UnitPrice = requestedProduct.UnitPrice

internal/modules/marketing/services/salesorder.service.go

@@ -294,7 +294,7 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 
 					// Hitung total_weight dan total_price otomatis
 					totalWeight := rp.Qty * rp.AvgWeight
-					totalPrice := rp.UnitPrice * rp.Qty
+					totalPrice := rp.UnitPrice * totalWeight
 
 					updateBody := map[string]any{
 						"product_warehouse_id": rp.ProductWarehouseId,
@@ -594,7 +594,7 @@ func (s *salesOrdersService) createMarketingProductWithDelivery(ctx context.Cont
 
 	// Hitung total_weight dan total_price otomatis
 	totalWeight := rp.Qty * rp.AvgWeight
-	totalPrice := rp.UnitPrice * rp.Qty
+	totalPrice := rp.UnitPrice * totalWeight
 
 	marketingProduct := &entity.MarketingProduct{
 		MarketingId:        marketingId,

internal/modules/master/customers/dto/customer.dto.go

@@ -14,6 +14,7 @@ type CustomerRelationDTO struct {
 	Name          string                   `json:"name"`
 	Type          string                   `json:"type"`
 	AccountNumber string                   `json:"account_number"`
+	Address       string                   `json:"address,omitempty"`
 	Balance       float64                  `json:"balance"`
 	Pic           *userDTO.UserRelationDTO `json:"pic,omitempty"`
 }
@@ -52,6 +53,8 @@ func ToCustomerRelationDTO(e entity.Customer) CustomerRelationDTO {
 		Name:          e.Name,
 		Type:          e.Type,
 		AccountNumber: e.AccountNumber,
+		Address:       e.Address,
+		Balance:       e.Balance,
 		Pic:           pic,
 	}
 }

internal/modules/production/chickins/services/chickin.service.go

@@ -584,7 +584,6 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 	return updated, nil
 }
 
-// autoAddFlagToProduct adds target flag to product if not already present (idempotent)
 func (s *chickinService) autoAddFlagToProduct(ctx context.Context, tx *gorm.DB, productID uint, targetFlag utils.FlagType) error {
 	if s.ProductRepo == nil {
 		return nil

internal/modules/repports/controllers/repport.controller.go

@@ -242,6 +242,65 @@ func (c *RepportController) GetHppPerKandang(ctx *fiber.Ctx) error {
 	return ctx.Status(fiber.StatusOK).JSON(resp)
 }
 
+func (c *RepportController) GetCustomerPayment(ctx *fiber.Ctx) error {
+	var customerIDs []uint
+	if customerIDsStr := ctx.Query("customer_ids"); customerIDsStr != "" {
+		ids := strings.Split(customerIDsStr, ",")
+		for _, idStr := range ids {
+			idStr = strings.TrimSpace(idStr)
+			if idStr != "" {
+				if id, err := strconv.ParseUint(idStr, 10, 32); err == nil {
+					customerIDs = append(customerIDs, uint(id))
+				}
+			}
+		}
+	}
+
+	query := &validation.CustomerPaymentQuery{
+		Page:        ctx.QueryInt("page", 1),
+		Limit:       ctx.QueryInt("limit", 10),
+		CustomerIDs: customerIDs,
+		StartDate:   ctx.Query("start_date", ""),
+		EndDate:     ctx.Query("end_date", ""),
+	}
+
+	// Validate pagination
+	if len(customerIDs) == 0 && (query.Page < 1 || query.Limit < 1) {
+		return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0 when customer_ids is not provided")
+	}
+
+	result, totalResults, err := c.RepportService.GetCustomerPayment(ctx, query)
+	if err != nil {
+		return err
+	}
+
+	// If single customer mode (only 1 customer ID), return without pagination
+	if len(customerIDs) == 1 {
+		return ctx.Status(fiber.StatusOK).
+			JSON(response.Success{
+				Code:    fiber.StatusOK,
+				Status:  "success",
+				Message: "Get customer payment report successfully",
+				Data:    result,
+			})
+	}
+
+	// Multiple customers mode with pagination
+	return ctx.Status(fiber.StatusOK).
+		JSON(response.SuccessWithPaginate[dto.CustomerPaymentReportItem]{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Get customer payment report successfully",
+			Meta: response.Meta{
+				Page:         query.Page,
+				Limit:        query.Limit,
+				TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
+				TotalResults: totalResults,
+			},
+			Data: result,
+		})
+}
+
 func (c *RepportController) GetProductionResult(ctx *fiber.Ctx) error {
 	idParam := ctx.Params("idProjectFlockKandang")
 	if idParam == "" {

internal/modules/repports/dto/repportCustomerPayment.dto.go

@@ -0,0 +1,120 @@
+package dto
+
+import (
+	"strings"
+	"time"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/entities"
+	customerDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/customers/dto"
+	repportRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/repports/repositories"
+)
+
+type CustomerPaymentReportRow struct {
+	TransactionType string     `json:"transaction_type"`
+	TransactionID   int64      `json:"transaction_id"`
+	TransDate       time.Time  `json:"trans_date"`
+	DeliveryDate    *time.Time `json:"delivery_date"`
+	Reference       string     `json:"reference"`
+
+	Qty                float64  `json:"qty"`
+	Weight             float64  `json:"weight"`
+	AverageWeight      float64  `json:"average_weight"`
+	UnitPrice          float64  `json:"unit_price"`
+	FinalPrice         float64  `json:"final_price"`
+	TotalPrice         float64  `json:"total_price"`
+	PaymentAmount      float64  `json:"payment_amount"`
+	AccountsReceivable float64  `json:"accounts_receivable"`
+	AgingDay           *int     `json:"aging_day"`
+	Status             string   `json:"status"`
+	VehicleNumbers     []string `json:"vehicle_numbers"`
+	PickupInfo         []string `json:"pickup_info"`
+	SalesPerson        string   `json:"sales_person"`
+}
+
+type CustomerPaymentReportSummary struct {
+	TotalQty                float64 `json:"total_qty"`
+	TotalWeight             float64 `json:"total_weight"`
+	TotalFinalAmount        float64 `json:"total_final_amount"`
+	TotalGrandAmount        float64 `json:"total_grand_amount"`
+	TotalPayment            float64 `json:"total_payment"`
+	TotalAccountsReceivable float64 `json:"total_accounts_receivable"`
+}
+
+type CustomerPaymentReportItem struct {
+	Customer       customerDTO.CustomerRelationDTO `json:"customer"`
+	InitialBalance float64                         `json:"initial_balance"`
+	Rows           []CustomerPaymentReportRow      `json:"rows"`
+	Summary        CustomerPaymentReportSummary    `json:"summary"`
+}
+
+type CustomerPaymentReportResponse struct {
+	Data []CustomerPaymentReportItem `json:"data"`
+}
+
+func ToCustomerPaymentReportRow(tx repportRepo.CustomerPaymentTransaction) CustomerPaymentReportRow {
+	return CustomerPaymentReportRow{
+		TransactionType: tx.TransactionType,
+		TransactionID:   tx.TransactionID,
+		TransDate:       tx.TransDate,
+		DeliveryDate:    tx.DeliveryDate,
+		Reference:       tx.Reference,
+		Qty:             tx.Qty,
+		Weight:          tx.Weight,
+		AverageWeight:   tx.AverageWeight,
+		UnitPrice:       tx.Price,
+		FinalPrice:      tx.FinalPrice,
+		TotalPrice:      tx.TotalPrice,
+		PaymentAmount:   tx.PaymentAmount,
+		VehicleNumbers:  parseStringSlice(tx.VehicleNumbers),
+		PickupInfo:      parseStringSlice(tx.PickupInfo),
+		SalesPerson:     tx.SalesPerson,
+	}
+}
+
+func ToCustomerPaymentReportItem(customer entities.Customer, initialBalance float64, rows []CustomerPaymentReportRow, summary CustomerPaymentReportSummary) CustomerPaymentReportItem {
+	return CustomerPaymentReportItem{
+		Customer:       customerDTO.ToCustomerRelationDTO(customer),
+		InitialBalance: initialBalance,
+		Rows:           rows,
+		Summary:        summary,
+	}
+}
+
+func ToCustomerPaymentReportSummary(rows []CustomerPaymentReportRow, initialBalance float64) CustomerPaymentReportSummary {
+	summary := CustomerPaymentReportSummary{}
+
+	for _, row := range rows {
+		summary.TotalQty += row.Qty
+		summary.TotalWeight += row.Weight
+
+		if row.TransactionType == "SALES" {
+			summary.TotalFinalAmount += row.FinalPrice
+			summary.TotalGrandAmount += row.TotalPrice
+		} else if row.TransactionType == "PAYMENT" {
+			summary.TotalPayment += row.PaymentAmount
+		}
+	}
+
+	// Total AR = Initial Balance - Total Sales + Total Payment
+	summary.TotalAccountsReceivable = initialBalance - summary.TotalGrandAmount + summary.TotalPayment
+
+	return summary
+}
+
+func parseStringSlice(str string) []string {
+	str = strings.TrimSpace(str)
+	if str == "" || str == "-" {
+		return []string{}
+	}
+
+	parts := strings.Split(str, ",")
+	result := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part != "" {
+			result = append(result, part)
+		}
+	}
+
+	return result
+}

internal/modules/repports/module.go

@@ -12,6 +12,7 @@ import (
 
 	expenseRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/repositories"
 	marketingRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/repositories"
+	customerRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/customers/repositories"
 	productionStandardRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/production-standards/repositories"
 	chickinRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/repositories"
 	recordingRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
@@ -35,26 +36,14 @@ func (RepportModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 	debtSupplierRepository := repportRepo.NewDebtSupplierRepository(db)
 	hppPerKandangRepository := repportRepo.NewHppPerKandangRepository(db)
 	productionResultRepository := repportRepo.NewProductionResultRepository(db)
+	customerPaymentRepository := repportRepo.NewCustomerPaymentRepository(db)
+	customerRepository := customerRepo.NewCustomerRepository(db)
 	standardGrowthDetailRepository := productionStandardRepo.NewStandardGrowthDetailRepository(db)
 	productionStandardDetailRepository := productionStandardRepo.NewProductionStandardDetailRepository(db)
 	userRepository := rUser.NewUserRepository(db)
 
 	approvalSvc := approvalService.NewApprovalService(approvalRepository)
-	repportService := sRepport.NewRepportService(
-		validate,
-		expenseRealizationRepository,
-		marketingDeliveryProductRepository,
-		purchaseRepository,
-		chickinRepository,
-		recordingRepository,
-		approvalSvc,
-		purchaseSupplierRepository,
-		debtSupplierRepository,
-		hppPerKandangRepository,
-		productionResultRepository,
-		standardGrowthDetailRepository,
-		productionStandardDetailRepository,
-	)
+	repportService := sRepport.NewRepportService(db, validate, expenseRealizationRepository, marketingDeliveryProductRepository, purchaseRepository, chickinRepository, recordingRepository, approvalSvc, purchaseSupplierRepository, debtSupplierRepository, hppPerKandangRepository, productionResultRepository, customerPaymentRepository, customerRepository, standardGrowthDetailRepository, productionStandardDetailRepository)
 	userService := sUser.NewUserService(userRepository, validate)
 
 	RepportRoutes(router, userService, repportService)

internal/modules/repports/repositories/customer_payment.repository.go

@@ -0,0 +1,195 @@
+package repositories
+
+import (
+	"context"
+
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type CustomerPaymentTransaction struct {
+	TransactionType string     `gorm:"column:transaction_type"`
+	TransactionID   int64      `gorm:"column:transaction_id"`
+	CustomerID      int64      `gorm:"column:customer_id"`
+	TransDate       time.Time  `gorm:"column:trans_date"`
+	DeliveryDate    *time.Time `gorm:"column:delivery_date"`
+	Reference       string     `gorm:"column:reference"`
+	VehicleNumbers  string     `gorm:"column:vehicle_numbers"`
+	Qty             float64    `gorm:"column:qty"`
+	Weight          float64    `gorm:"column:weight"`
+	AverageWeight   float64    `gorm:"column:average_weight"`
+	Price           float64    `gorm:"column:price"`
+	FinalPrice      float64    `gorm:"column:final_price"`
+	TotalPrice      float64    `gorm:"column:total_price"`
+	PaymentAmount   float64    `gorm:"column:payment_amount"`
+	PickupInfo      string     `gorm:"column:pickup_info"`
+	SalesPerson     string     `gorm:"column:sales_person"`
+}
+
+type CustomerPaymentRepository interface {
+	GetCustomerPaymentTransactions(ctx context.Context, customerID *uint) ([]CustomerPaymentTransaction, error)
+	GetInitialBalanceByCustomer(ctx context.Context, customerID uint) (float64, error)
+	GetCustomerIDsWithTransactions(ctx context.Context, limit, offset int) ([]uint, int64, error)
+}
+
+type customerPaymentRepositoryImpl struct {
+	db *gorm.DB
+}
+
+func NewCustomerPaymentRepository(db *gorm.DB) CustomerPaymentRepository {
+	return &customerPaymentRepositoryImpl{db: db}
+}
+
+func (r *customerPaymentRepositoryImpl) GetCustomerPaymentTransactions(ctx context.Context, customerID *uint) ([]CustomerPaymentTransaction, error) {
+	salesQuery := r.db.WithContext(ctx).
+		Table("marketing_delivery_products mdp").
+		Select(`
+			'SALES' AS transaction_type,
+			mdp.id::BIGINT AS transaction_id,
+			c.id::BIGINT AS customer_id,
+			m.so_date::DATE AS trans_date,
+			mdp.delivery_date::DATE AS delivery_date,
+			m.so_number || '-' || TO_CHAR(mdp.delivery_date, 'YYYYMMDD') || '-' || CAST(pw.warehouse_id AS VARCHAR) AS reference,
+			COALESCE(mdp.vehicle_number, '') AS vehicle_numbers,
+
+			COALESCE(mdp.usage_qty, 0)::NUMERIC(15,3) AS qty,
+			COALESCE(mdp.total_weight, 0)::NUMERIC(15,3) AS weight,
+			COALESCE(mdp.avg_weight, 0)::NUMERIC(15,3) AS average_weight,
+			COALESCE(mdp.unit_price, 0)::NUMERIC(15,3) AS price,
+			COALESCE(mdp.total_price, 0)::NUMERIC(15,3) AS final_price,
+			COALESCE(mdp.total_price, 0)::NUMERIC(15,3) AS total_price,
+			0::NUMERIC(15,3) AS payment_amount,
+			w.name AS pickup_info,
+			u.name AS sales_person
+		`).
+		Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
+		Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+		Joins("INNER JOIN customers c ON c.id = m.customer_id").
+		Joins("INNER JOIN product_warehouses pw ON pw.id = mdp.product_warehouse_id").
+		Joins("INNER JOIN warehouses w ON w.id = pw.warehouse_id").
+		Joins("INNER JOIN users u ON u.id = m.sales_person_id").
+		Where("mdp.delivery_date IS NOT NULL").
+		Where("m.deleted_at IS NULL").
+		Where("c.deleted_at IS NULL")
+
+	if customerID != nil {
+		salesQuery = salesQuery.Where("c.id = ?", *customerID)
+	}
+
+	paymentQuery := r.db.WithContext(ctx).
+		Table("payments p").
+		Select(`
+			'PAYMENT' AS transaction_type,
+			p.id::BIGINT AS transaction_id,
+			c.id::BIGINT AS customer_id,
+			p.payment_date::DATE AS trans_date,
+			NULL AS delivery_date,
+			COALESCE(p.reference_number, p.payment_code) AS reference,
+			'-' AS vehicle_numbers,
+			0::NUMERIC(15,3) AS qty,
+			0::NUMERIC(15,3) AS weight,
+			0::NUMERIC(15,3) AS average_weight,
+			0::NUMERIC(15,3) AS price,
+			0::NUMERIC(15,3) AS final_price,
+			0::NUMERIC(15,3) AS total_price,
+			p.nominal::NUMERIC(15,3) AS payment_amount,
+			'-' AS pickup_info,
+			'-' AS sales_person
+		`).
+		Joins("INNER JOIN customers c ON c.id = p.party_id").
+		Where("p.party_type = ?", "CUSTOMER").
+		Where("p.direction = ?", "IN").
+		Where("p.transaction_type = ?", "PENJUALAN").
+		Where("p.deleted_at IS NULL").
+		Where("c.deleted_at IS NULL")
+
+	if customerID != nil {
+		paymentQuery = paymentQuery.Where("c.id = ?", *customerID)
+	}
+
+	var results []CustomerPaymentTransaction
+	err := r.db.WithContext(ctx).
+		Raw("? UNION ALL ? ORDER BY customer_id, trans_date, transaction_type DESC, transaction_id",
+			salesQuery,
+			paymentQuery,
+		).
+		Scan(&results).
+		Error
+
+	if err != nil {
+		return nil, err
+	}
+
+	return results, nil
+}
+
+func (r *customerPaymentRepositoryImpl) GetInitialBalanceByCustomer(ctx context.Context, customerID uint) (float64, error) {
+	var result struct {
+		Nominal float64
+	}
+
+	err := r.db.WithContext(ctx).
+		Table("payments").
+		Select("COALESCE(SUM(nominal), 0) as nominal").
+		Where("party_type = ?", "CUSTOMER").
+		Where("party_id = ?", customerID).
+		Where("transaction_type = ?", "SALDO_AWAL").
+		Where("deleted_at IS NULL").
+		Scan(&result).
+		Error
+
+	if err != nil {
+		return 0, err
+	}
+
+	return result.Nominal, nil
+}
+
+func (r *customerPaymentRepositoryImpl) GetCustomerIDsWithTransactions(ctx context.Context, limit, offset int) ([]uint, int64, error) {
+	subQuery := r.db.WithContext(ctx).
+		Table("(" +
+			"SELECT DISTINCT c.id as customer_id FROM marketing_delivery_products mdp " +
+			"INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id " +
+			"INNER JOIN marketings m ON m.id = mp.marketing_id " +
+			"INNER JOIN customers c ON c.id = m.customer_id " +
+			"WHERE mdp.delivery_date IS NOT NULL AND m.deleted_at IS NULL AND c.deleted_at IS NULL " +
+			"UNION " +
+			"SELECT DISTINCT c.id as customer_id FROM payments p " +
+			"INNER JOIN customers c ON c.id = p.party_id " +
+			"WHERE p.party_type = 'CUSTOMER' AND p.direction = 'IN' " +
+			"AND p.transaction_type = 'PENJUALAN' AND p.deleted_at IS NULL AND c.deleted_at IS NULL" +
+			") as customer_ids")
+
+	var total int64
+	if err := subQuery.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	var customerIDs []uint
+	err := r.db.WithContext(ctx).
+		Table("("+
+			"SELECT DISTINCT c.id as customer_id FROM marketing_delivery_products mdp "+
+			"INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id "+
+			"INNER JOIN marketings m ON m.id = mp.marketing_id "+
+			"INNER JOIN customers c ON c.id = m.customer_id "+
+			"WHERE mdp.delivery_date IS NOT NULL AND m.deleted_at IS NULL AND c.deleted_at IS NULL "+
+			"UNION "+
+			"SELECT DISTINCT c.id as customer_id FROM payments p "+
+			"INNER JOIN customers c ON c.id = p.party_id "+
+			"WHERE p.party_type = 'CUSTOMER' AND p.direction = 'IN' "+
+			"AND p.transaction_type = 'PENJUALAN' AND p.deleted_at IS NULL AND c.deleted_at IS NULL"+
+			") as customer_ids").
+		Select("customer_id").
+		Order("customer_id ASC").
+		Limit(limit).
+		Offset(offset).
+		Pluck("customer_id", &customerIDs).
+		Error
+
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return customerIDs, total, nil
+}

internal/modules/repports/route.go

@@ -21,5 +21,5 @@ func RepportRoutes(v1 fiber.Router, u user.UserService, s repport.RepportService
 	route.Get("/debt-supplier", m.RequirePermissions(m.P_ReportDebtSupplierGetAll), ctrl.GetDebtSupplier)
 	route.Get("/hpp-per-kandang", m.RequirePermissions(m.P_ReportHppPerKandangGetAll), ctrl.GetHppPerKandang)
 	route.Get("/production-result/:idProjectFlockKandang", m.RequirePermissions(m.P_ReportProductionResultGetAll), ctrl.GetProductionResult)
-
+	route.Get("/customer-payment", m.RequirePermissions(m.P_ReportCustomerPaymentGetAll), ctrl.GetCustomerPayment)
 }

internal/modules/repports/services/repport.service.go

@@ -20,6 +20,7 @@ import (
 	expenseRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/repositories"
 	marketingRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/repositories"
 	areaDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/areas/dto"
+	customerRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/customers/repositories"
 	supplierDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/suppliers/dto"
 	warehouseDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/dto"
 	productionStandardRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/master/production-standards/repositories"
@@ -42,11 +43,13 @@ type RepportService interface {
 	GetDebtSupplier(ctx *fiber.Ctx, params *validation.DebtSupplierQuery) ([]dto.DebtSupplierDTO, int64, error)
 	GetHppPerKandang(ctx *fiber.Ctx) (*dto.HppPerKandangResponseData, *dto.HppPerKandangMetaDTO, error)
 	GetProductionResult(ctx *fiber.Ctx, params *validation.ProductionResultQuery) ([]dto.ProductionResultDTO, int64, error)
+	GetCustomerPayment(ctx *fiber.Ctx, params *validation.CustomerPaymentQuery) ([]dto.CustomerPaymentReportItem, int64, error)
 }
 
 type repportService struct {
 	Log                    *logrus.Logger
 	Validate               *validator.Validate
+	DB                     *gorm.DB
 	ExpenseRealizationRepo expenseRepo.ExpenseRealizationRepository
 	MarketingDeliveryRepo  marketingRepo.MarketingDeliveryProductRepository
 	PurchaseRepo           purchaseRepo.PurchaseRepository
@@ -57,6 +60,8 @@ type repportService struct {
 	DebtSupplierRepo       repportRepo.DebtSupplierRepository
 	HppPerKandangRepo      repportRepo.HppPerKandangRepository
 	ProductionResultRepo   repportRepo.ProductionResultRepository
+	CustomerPaymentRepo    repportRepo.CustomerPaymentRepository
+	CustomerRepo           customerRepo.CustomerRepository
 	StandardGrowthDetailRepo     productionStandardRepository.StandardGrowthDetailRepository
 	ProductionStandardDetailRepo productionStandardRepository.ProductionStandardDetailRepository
 }
@@ -71,6 +76,7 @@ type HppCostAggregate struct {
 }
 
 func NewRepportService(
+	db *gorm.DB,
 	validate *validator.Validate,
 	expenseRealizationRepo expenseRepo.ExpenseRealizationRepository,
 	marketingDeliveryRepo marketingRepo.MarketingDeliveryProductRepository,
@@ -82,12 +88,15 @@ func NewRepportService(
 	debtSupplierRepo repportRepo.DebtSupplierRepository,
 	hppPerKandangRepo repportRepo.HppPerKandangRepository,
 	productionResultRepo repportRepo.ProductionResultRepository,
+	customerPaymentRepo repportRepo.CustomerPaymentRepository,
+	customerRepo customerRepo.CustomerRepository,
 	standardGrowthDetailRepo productionStandardRepository.StandardGrowthDetailRepository,
 	productionStandardDetailRepo productionStandardRepository.ProductionStandardDetailRepository,
 ) RepportService {
 	return &repportService{
 		Log:                    utils.Log,
 		Validate:               validate,
+		DB:                     db,
 		ExpenseRealizationRepo: expenseRealizationRepo,
 		MarketingDeliveryRepo:  marketingDeliveryRepo,
 		PurchaseRepo:           purchaseRepo,
@@ -98,6 +107,8 @@ func NewRepportService(
 		DebtSupplierRepo:       debtSupplierRepo,
 		HppPerKandangRepo:      hppPerKandangRepo,
 		ProductionResultRepo:   productionResultRepo,
+		CustomerPaymentRepo:    customerPaymentRepo,
+		CustomerRepo:           customerRepo,
 		StandardGrowthDetailRepo:     standardGrowthDetailRepo,
 		ProductionStandardDetailRepo: productionStandardDetailRepo,
 	}
@@ -390,6 +401,205 @@ func (s *repportService) GetProductionResult(ctx *fiber.Ctx, params *validation.
 	return weeklyResults, totalWeeks, nil
 }
 
+func (s *repportService) GetCustomerPayment(ctx *fiber.Ctx, params *validation.CustomerPaymentQuery) ([]dto.CustomerPaymentReportItem, int64, error) {
+	if err := s.Validate.Struct(params); err != nil {
+		return nil, 0, err
+	}
+
+	// Determine customer IDs to process
+	var customerIDs []uint
+	var totalCustomers int64
+
+	if len(params.CustomerIDs) > 0 {
+		// Specific customer IDs mode (no pagination)
+		customerIDs = params.CustomerIDs
+		totalCustomers = int64(len(customerIDs))
+
+		if len(customerIDs) == 0 {
+			return []dto.CustomerPaymentReportItem{}, 0, nil
+		}
+	} else {
+		// Multiple customers mode with pagination
+		page := params.Page
+		limit := params.Limit
+		if page < 1 {
+			page = 1
+		}
+		if limit < 1 {
+			limit = 10
+		}
+
+		offset := (page - 1) * limit
+
+		var err error
+		customerIDs, totalCustomers, err = s.CustomerPaymentRepo.GetCustomerIDsWithTransactions(ctx.Context(), limit, offset)
+		if err != nil {
+			return nil, 0, err
+		}
+
+		if len(customerIDs) == 0 {
+			return []dto.CustomerPaymentReportItem{}, 0, nil
+		}
+	}
+
+	var result []dto.CustomerPaymentReportItem
+	for _, customerID := range customerIDs {
+		item, err := s.processCustomerPayment(ctx.Context(), customerID, params)
+		if err != nil {
+			return nil, 0, err
+		}
+		result = append(result, item)
+	}
+
+	return result, totalCustomers, nil
+}
+
+func (s *repportService) processCustomerPayment(ctx context.Context, customerID uint, params *validation.CustomerPaymentQuery) (dto.CustomerPaymentReportItem, error) {
+
+	customer, err := s.CustomerRepo.GetByID(ctx, customerID, nil)
+	if err != nil {
+		return dto.CustomerPaymentReportItem{}, err
+	}
+
+	initialBalance, err := s.CustomerPaymentRepo.GetInitialBalanceByCustomer(ctx, customerID)
+	if err != nil {
+		return dto.CustomerPaymentReportItem{}, err
+	}
+
+	cid := customerID
+	transactions, err := s.CustomerPaymentRepo.GetCustomerPaymentTransactions(ctx, &cid)
+	if err != nil {
+		return dto.CustomerPaymentReportItem{}, err
+	}
+
+	rows := make([]dto.CustomerPaymentReportRow, 0, len(transactions))
+	runningBalance := initialBalance
+
+	for i, tx := range transactions {
+
+		previousBalance := runningBalance
+
+		row := dto.ToCustomerPaymentReportRow(tx)
+
+		if tx.TransactionType == "SALES" {
+			runningBalance -= tx.TotalPrice
+			status, paymentDate := s.determineSalesStatusAndPaymentDate(transactions, i, previousBalance, runningBalance)
+			row.Status = status
+
+			if status == "LUNAS" {
+				if previousBalance >= tx.TotalPrice {
+					days := 0
+					row.AgingDay = &days
+				} else if paymentDate != nil {
+					days := int(paymentDate.Sub(tx.TransDate).Hours() / 24)
+					if days < 0 {
+						days = 0
+					}
+					row.AgingDay = &days
+				} else {
+					days := 0
+					row.AgingDay = &days
+				}
+			} else {
+				days := int(time.Since(tx.TransDate).Hours() / 24)
+				if days < 0 {
+					days = 0
+				}
+				row.AgingDay = &days
+			}
+		} else if tx.TransactionType == "PAYMENT" {
+			runningBalance += tx.PaymentAmount
+			row.Status = ""
+			row.AgingDay = nil
+		}
+
+		row.AccountsReceivable = runningBalance
+		rows = append(rows, row)
+	}
+
+	if params.StartDate != "" || params.EndDate != "" {
+		filteredRows := make([]dto.CustomerPaymentReportRow, 0, len(rows))
+		location, err := time.LoadLocation("Asia/Jakarta")
+		if err != nil {
+			return dto.CustomerPaymentReportItem{}, err
+		}
+
+		var startDate, endDate *time.Time
+		if params.StartDate != "" {
+			parsed, err := time.ParseInLocation("2006-01-02", params.StartDate, location)
+			if err != nil {
+				return dto.CustomerPaymentReportItem{}, err
+			}
+			startDate = &parsed
+		}
+		if params.EndDate != "" {
+			parsed, err := time.ParseInLocation("2006-01-02", params.EndDate, location)
+			if err != nil {
+				return dto.CustomerPaymentReportItem{}, err
+			}
+			endOfDay := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 23, 59, 59, 999999999, location)
+			endDate = &endOfDay
+		}
+
+		for _, row := range rows {
+			transDate := row.TransDate.In(location)
+			if startDate != nil && transDate.Before(*startDate) {
+				continue
+			}
+			if endDate != nil && transDate.After(*endDate) {
+				continue
+			}
+			filteredRows = append(filteredRows, row)
+		}
+
+		rows = filteredRows
+	}
+
+	summary := dto.ToCustomerPaymentReportSummary(rows, initialBalance)
+
+	return dto.ToCustomerPaymentReportItem(*customer, initialBalance, rows, summary), nil
+}
+
+func (s *repportService) determineSalesStatusAndPaymentDate(transactions []repportRepo.CustomerPaymentTransaction, currentIndex int, previousBalance, currentBalance float64) (string, *time.Time) {
+	currentSales := transactions[currentIndex]
+
+	// Status Logic:
+	// 1. LUNAS: previousBalance >= salesAmount (paid from deposit)
+	// 2. LUNAS: future payments make AR >= 0 (eventually paid)
+	// 3. DIBAYAR SEBAGIAN: has payment but not enough
+	// 4. BELUM LUNAS: no payment at all
+
+	if previousBalance >= currentSales.TotalPrice {
+		return "LUNAS", nil
+	}
+
+	hasPartialPaymentFromBalance := previousBalance > 0 && previousBalance < currentSales.TotalPrice
+
+	futureBalance := currentBalance
+	hasPayment := false
+	var paymentDateThatMadeItLunas *time.Time
+
+	for i := currentIndex + 1; i < len(transactions); i++ {
+		if transactions[i].TransactionType == "PAYMENT" {
+			futureBalance += transactions[i].PaymentAmount
+			hasPayment = true
+
+			if futureBalance >= 0 {
+				paymentDateThatMadeItLunas = &transactions[i].TransDate
+				return "LUNAS", paymentDateThatMadeItLunas
+			}
+		} else if transactions[i].TransactionType == "SALES" {
+			futureBalance -= transactions[i].TotalPrice
+		}
+	}
+
+	if hasPayment || hasPartialPaymentFromBalance {
+		return "DIBAYAR SEBAGIAN", nil
+	}
+
+	return "BELUM LUNAS", nil
+}
+
 func mapRecordingToProductionResultDTO(record entity.Recording) dto.ProductionResultDTO {
 	result := dto.ProductionResultDTO{
 		CreatedAt:     record.CreatedAt,

internal/modules/repports/validations/repport.validation.go

@@ -71,3 +71,11 @@ type ProductionResultQuery struct {
 	Limit                 int  `query:"limit" validate:"omitempty,min=1,max=100,gt=0"`
 	ProjectFlockKandangID uint `query:"-" validate:"required,gt=0"`
 }
+
+type CustomerPaymentQuery struct {
+	Page        int    `query:"page" validate:"omitempty,min=1,gt=0"`
+	Limit       int    `query:"limit" validate:"omitempty,min=1,max=100,gt=0"`
+	CustomerIDs []uint `query:"customer_ids" validate:"omitempty,dive,gt=0"`
+	StartDate   string `query:"start_date" validate:"omitempty,datetime=2006-01-02"`
+	EndDate     string `query:"end_date" validate:"omitempty,datetime=2006-01-02"`
+}