mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-20 13:31:56 +00:00
giovanni
586 lines
14 KiB
Go
586 lines
14 KiB
Go
package controller
|
||
|
||
import (
|
||
"fmt"
|
||
"math"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/gofiber/fiber/v2"
|
||
"github.com/xuri/excelize/v2"
|
||
"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
|
||
)
|
||
|
||
func isCustomerPaymentExcelExportRequest(c *fiber.Ctx) bool {
|
||
return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
|
||
}
|
||
|
||
func isCustomerPaymentExcelAllExportRequest(c *fiber.Ctx) bool {
|
||
return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel-all")
|
||
}
|
||
|
||
func exportCustomerPaymentExcel(c *fiber.Ctx, items []dto.CustomerPaymentReportItem) error {
|
||
content, err := buildCustomerPaymentWorkbook(items)
|
||
if err != nil {
|
||
return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
|
||
}
|
||
|
||
filename := fmt.Sprintf("laporan-kontrol-pembayaran-customer-%s.xlsx", time.Now().Format("2006-01-02-1504"))
|
||
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)
|
||
}
|
||
|
||
func exportCustomerPaymentExcelAll(c *fiber.Ctx, items []dto.CustomerPaymentReportItem) error {
|
||
content, err := buildCustomerPaymentAllWorkbook(items)
|
||
if err != nil {
|
||
return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
|
||
}
|
||
|
||
filename := fmt.Sprintf("laporan-kontrol-pembayaran-customer-all-%s.xlsx", time.Now().Format("2006-01-02-1504"))
|
||
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)
|
||
}
|
||
|
||
func buildCustomerPaymentWorkbook(items []dto.CustomerPaymentReportItem) ([]byte, error) {
|
||
file := excelize.NewFile()
|
||
defer file.Close()
|
||
|
||
defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
|
||
|
||
if len(items) == 0 {
|
||
if err := writeCustomerPaymentSheet(file, defaultSheet, dto.CustomerPaymentReportItem{}); err != nil {
|
||
return nil, err
|
||
}
|
||
buf, err := file.WriteToBuffer()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return buf.Bytes(), nil
|
||
}
|
||
|
||
for idx, item := range items {
|
||
sheetName := sanitizeCustomerPaymentSheetName(customerPaymentName(item))
|
||
if sheetName == "" {
|
||
sheetName = fmt.Sprintf("Customer %d", idx+1)
|
||
}
|
||
|
||
if idx == 0 {
|
||
if defaultSheet != sheetName {
|
||
if err := file.SetSheetName(defaultSheet, sheetName); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
} else {
|
||
if _, err := file.NewSheet(sheetName); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
if err := writeCustomerPaymentSheet(file, sheetName, item); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
buf, err := file.WriteToBuffer()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return buf.Bytes(), nil
|
||
}
|
||
|
||
func buildCustomerPaymentAllWorkbook(items []dto.CustomerPaymentReportItem) ([]byte, error) {
|
||
file := excelize.NewFile()
|
||
defer file.Close()
|
||
|
||
const sheet = "Kontrol Pembayaran Customer"
|
||
defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
|
||
if defaultSheet != sheet {
|
||
if err := file.SetSheetName(defaultSheet, sheet); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
if err := setCustomerPaymentAllColumns(file, sheet); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := setCustomerPaymentAllHeaders(file, sheet); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := writeCustomerPaymentAllRows(file, sheet, items); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := file.SetPanes(sheet, &excelize.Panes{
|
||
Freeze: true,
|
||
YSplit: 1,
|
||
TopLeftCell: "A2",
|
||
ActivePane: "bottomLeft",
|
||
}); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
buf, err := file.WriteToBuffer()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return buf.Bytes(), nil
|
||
}
|
||
|
||
var cpSheetHeaders = []string{
|
||
"No",
|
||
"Tanggal DO/Bayar",
|
||
"Tanggal Realisasi",
|
||
"Aging",
|
||
"Referensi",
|
||
"Nomor Polisi",
|
||
"Ekor/Qty",
|
||
"Berat (Kg)",
|
||
"AVG",
|
||
"Harga/Unit (Rp)",
|
||
"Harga Akhir (Rp)",
|
||
"Total (Rp)",
|
||
"Pembayaran (Rp)",
|
||
"Saldo Piutang (Rp)",
|
||
"Keterangan",
|
||
"Pengambilan",
|
||
"Sales/Marketing",
|
||
}
|
||
|
||
var cpAllSheetHeaders = append([]string{"Customer"}, cpSheetHeaders...)
|
||
|
||
var cpSheetColumnWidths = map[string]float64{
|
||
"A": 5,
|
||
"B": 15,
|
||
"C": 12,
|
||
"D": 8,
|
||
"E": 12,
|
||
"F": 15,
|
||
"G": 10,
|
||
"H": 12,
|
||
"I": 10,
|
||
"J": 15,
|
||
"K": 15,
|
||
"L": 15,
|
||
"M": 15,
|
||
"N": 15,
|
||
"O": 20,
|
||
"P": 15,
|
||
"Q": 20,
|
||
}
|
||
|
||
var cpAllSheetColumnWidths = map[string]float64{
|
||
"A": 22,
|
||
"B": 6,
|
||
"C": 15,
|
||
"D": 15,
|
||
"E": 8,
|
||
"F": 12,
|
||
"G": 15,
|
||
"H": 10,
|
||
"I": 12,
|
||
"J": 10,
|
||
"K": 15,
|
||
"L": 15,
|
||
"M": 15,
|
||
"N": 15,
|
||
"O": 15,
|
||
"P": 20,
|
||
"Q": 15,
|
||
"R": 20,
|
||
}
|
||
|
||
func writeCustomerPaymentSheet(file *excelize.File, sheet string, item dto.CustomerPaymentReportItem) error {
|
||
for col, width := range cpSheetColumnWidths {
|
||
if err := file.SetColWidth(sheet, col, col, width); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
// Row 1: headers
|
||
for i, h := range cpSheetHeaders {
|
||
col, _ := excelize.ColumnNumberToName(i + 1)
|
||
if err := file.SetCellValue(sheet, col+"1", h); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
redStyle, err := file.NewStyle(&excelize.Style{
|
||
Font: &excelize.Font{Color: "FF0000"},
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// Row 2: saldo awal
|
||
initialFormatted := formatCPRupiah(item.InitialBalance)
|
||
if err := file.SetCellValue(sheet, "N2", initialFormatted); err != nil {
|
||
return err
|
||
}
|
||
if item.InitialBalance < 0 {
|
||
if err := file.SetCellStyle(sheet, "N2", "N2", redStyle); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
// Rows 3+: data rows
|
||
for i, row := range item.Rows {
|
||
rowNum := i + 3
|
||
rowStr := fmt.Sprintf("%d", rowNum)
|
||
|
||
cells := customerPaymentRowCells(row, i+1)
|
||
for colIdx, val := range cells {
|
||
col, _ := excelize.ColumnNumberToName(colIdx + 1)
|
||
if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
if row.AccountsReceivable < 0 {
|
||
if err := file.SetCellStyle(sheet, "N"+rowStr, "N"+rowStr, redStyle); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
|
||
// Total row
|
||
totalRowNum := len(item.Rows) + 3
|
||
totalRowStr := fmt.Sprintf("%d", totalRowNum)
|
||
|
||
totalCells := map[string]string{
|
||
"A": "Total",
|
||
"G": formatCPIDInteger(item.Summary.TotalQty),
|
||
"H": formatCPIDInteger(item.Summary.TotalWeight),
|
||
"K": formatCPRupiah(item.Summary.TotalFinalAmount),
|
||
"L": formatCPRupiah(item.Summary.TotalGrandAmount),
|
||
"M": formatCPRupiah(item.Summary.TotalPayment),
|
||
"N": formatCPRupiah(item.Summary.TotalAccountsReceivable),
|
||
}
|
||
for col, val := range totalCells {
|
||
if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
if item.Summary.TotalAccountsReceivable < 0 {
|
||
if err := file.SetCellStyle(sheet, "N"+totalRowStr, "N"+totalRowStr, redStyle); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func setCustomerPaymentAllColumns(file *excelize.File, sheet string) error {
|
||
for col, width := range cpAllSheetColumnWidths {
|
||
if err := file.SetColWidth(sheet, col, col, width); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return file.SetRowHeight(sheet, 1, 24)
|
||
}
|
||
|
||
func setCustomerPaymentAllHeaders(file *excelize.File, sheet string) error {
|
||
borderStyle := []excelize.Border{
|
||
{Type: "left", Color: "000000", Style: 1},
|
||
{Type: "top", Color: "000000", Style: 1},
|
||
{Type: "bottom", Color: "000000", Style: 1},
|
||
{Type: "right", Color: "000000", Style: 1},
|
||
}
|
||
headerStyle, err := file.NewStyle(&excelize.Style{
|
||
Font: &excelize.Font{Bold: true, Color: "FFFFFF", Family: "Arial", Size: 10},
|
||
Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
|
||
Alignment: &excelize.Alignment{
|
||
Horizontal: "center",
|
||
Vertical: "center",
|
||
WrapText: true,
|
||
},
|
||
Border: borderStyle,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
for i, h := range cpAllSheetHeaders {
|
||
col, _ := excelize.ColumnNumberToName(i + 1)
|
||
if err := file.SetCellValue(sheet, col+"1", h); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
lastCol, _ := excelize.ColumnNumberToName(len(cpAllSheetHeaders))
|
||
return file.SetCellStyle(sheet, "A1", lastCol+"1", headerStyle)
|
||
}
|
||
|
||
func writeCustomerPaymentAllRows(file *excelize.File, sheet string, items []dto.CustomerPaymentReportItem) error {
|
||
borderStyle := []excelize.Border{
|
||
{Type: "left", Color: "000000", Style: 1},
|
||
{Type: "top", Color: "000000", Style: 1},
|
||
{Type: "bottom", Color: "000000", Style: 1},
|
||
{Type: "right", Color: "000000", Style: 1},
|
||
}
|
||
|
||
dataStyle, err := file.NewStyle(&excelize.Style{
|
||
Font: &excelize.Font{Color: "000000", Family: "Arial", Size: 10},
|
||
Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
|
||
Border: borderStyle,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
totalStyle, err := file.NewStyle(&excelize.Style{
|
||
Font: &excelize.Font{Bold: true, Color: "000000", Family: "Arial", Size: 10},
|
||
Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
|
||
Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
|
||
Border: borderStyle,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
redDataStyle, err := file.NewStyle(&excelize.Style{
|
||
Font: &excelize.Font{Color: "FF0000", Family: "Arial", Size: 10},
|
||
Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
|
||
Border: borderStyle,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
redTotalStyle, err := file.NewStyle(&excelize.Style{
|
||
Font: &excelize.Font{Bold: true, Color: "FF0000", Family: "Arial", Size: 10},
|
||
Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
|
||
Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
|
||
Border: borderStyle,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lastHeaderCol, _ := excelize.ColumnNumberToName(len(cpAllSheetHeaders))
|
||
currentRow := 2
|
||
|
||
for _, item := range items {
|
||
name := customerPaymentName(item)
|
||
|
||
// Saldo awal row
|
||
saldoStr := fmt.Sprintf("%d", currentRow)
|
||
if err := file.SetCellValue(sheet, "A"+saldoStr, name); err != nil {
|
||
return err
|
||
}
|
||
initialFormatted := formatCPRupiah(item.InitialBalance)
|
||
if err := file.SetCellValue(sheet, "O"+saldoStr, initialFormatted); err != nil {
|
||
return err
|
||
}
|
||
if err := file.SetCellStyle(sheet, "A"+saldoStr, lastHeaderCol+saldoStr, dataStyle); err != nil {
|
||
return err
|
||
}
|
||
if item.InitialBalance < 0 {
|
||
if err := file.SetCellStyle(sheet, "O"+saldoStr, "O"+saldoStr, redDataStyle); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
currentRow++
|
||
|
||
// Data rows
|
||
for seq, row := range item.Rows {
|
||
rowStr := fmt.Sprintf("%d", currentRow)
|
||
if err := file.SetCellValue(sheet, "A"+rowStr, name); err != nil {
|
||
return err
|
||
}
|
||
cells := customerPaymentRowCells(row, seq+1)
|
||
for colIdx, val := range cells {
|
||
col, _ := excelize.ColumnNumberToName(colIdx + 2)
|
||
if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
if err := file.SetCellStyle(sheet, "A"+rowStr, lastHeaderCol+rowStr, dataStyle); err != nil {
|
||
return err
|
||
}
|
||
if row.AccountsReceivable < 0 {
|
||
if err := file.SetCellStyle(sheet, "O"+rowStr, "O"+rowStr, redDataStyle); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
currentRow++
|
||
}
|
||
|
||
// Total row
|
||
totalStr := fmt.Sprintf("%d", currentRow)
|
||
totalCells := map[string]string{
|
||
"A": name,
|
||
"B": "Total",
|
||
"H": formatCPIDInteger(item.Summary.TotalQty),
|
||
"I": formatCPIDInteger(item.Summary.TotalWeight),
|
||
"L": formatCPRupiah(item.Summary.TotalFinalAmount),
|
||
"M": formatCPRupiah(item.Summary.TotalGrandAmount),
|
||
"N": formatCPRupiah(item.Summary.TotalPayment),
|
||
"O": formatCPRupiah(item.Summary.TotalAccountsReceivable),
|
||
}
|
||
for col, val := range totalCells {
|
||
if err := file.SetCellValue(sheet, col+totalStr, val); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
if err := file.SetCellStyle(sheet, "A"+totalStr, lastHeaderCol+totalStr, totalStyle); err != nil {
|
||
return err
|
||
}
|
||
if item.Summary.TotalAccountsReceivable < 0 {
|
||
if err := file.SetCellStyle(sheet, "O"+totalStr, "O"+totalStr, redTotalStyle); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
currentRow++
|
||
|
||
// Empty separator row
|
||
currentRow++
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// customerPaymentRowCells returns 17 cell values for cols A..Q.
|
||
func customerPaymentRowCells(row dto.CustomerPaymentReportRow, seq int) []interface{} {
|
||
return []interface{}{
|
||
seq,
|
||
formatCPDate(row.TransDate),
|
||
formatCPOptionalDate(row.DeliveryDate),
|
||
formatCPAging(row.AgingDay),
|
||
safeCPText(row.Reference),
|
||
joinCPStrings(row.VehicleNumbers),
|
||
formatCPIDInteger(row.Qty),
|
||
formatCPIDInteger(row.Weight),
|
||
formatCPAvg(row.AverageWeight),
|
||
formatCPRupiah(row.UnitPrice),
|
||
formatCPRupiah(row.FinalPrice),
|
||
formatCPRupiah(row.TotalPrice),
|
||
formatCPRupiah(row.PaymentAmount),
|
||
formatCPRupiah(row.AccountsReceivable),
|
||
safeCPText(row.Status),
|
||
joinCPStrings(row.PickupInfo),
|
||
safeCPText(row.SalesPerson),
|
||
}
|
||
}
|
||
|
||
func customerPaymentName(item dto.CustomerPaymentReportItem) string {
|
||
name := strings.TrimSpace(item.Customer.Name)
|
||
if name == "" {
|
||
return "Customer"
|
||
}
|
||
return name
|
||
}
|
||
|
||
func sanitizeCustomerPaymentSheetName(name string) string {
|
||
replacer := strings.NewReplacer(
|
||
":", " ", "\\", " ", "/", " ",
|
||
"?", " ", "*", " ", "[", " ", "]", " ",
|
||
)
|
||
sanitized := strings.TrimSpace(replacer.Replace(name))
|
||
if sanitized == "" {
|
||
return "Sheet"
|
||
}
|
||
runes := []rune(sanitized)
|
||
if len(runes) > 31 {
|
||
return string(runes[:31])
|
||
}
|
||
return sanitized
|
||
}
|
||
|
||
var cpIndonesianMonths = [12]string{
|
||
"Jan", "Feb", "Mar", "Apr", "Mei", "Jun",
|
||
"Jul", "Agu", "Sep", "Okt", "Nov", "Des",
|
||
}
|
||
|
||
func formatCPDate(t time.Time) string {
|
||
if t.IsZero() {
|
||
return "-"
|
||
}
|
||
loc, err := time.LoadLocation("Asia/Jakarta")
|
||
if err == nil {
|
||
t = t.In(loc)
|
||
}
|
||
return fmt.Sprintf("%02d %s %d", t.Day(), cpIndonesianMonths[t.Month()-1], t.Year())
|
||
}
|
||
|
||
func formatCPOptionalDate(t *time.Time) string {
|
||
if t == nil || t.IsZero() {
|
||
return "-"
|
||
}
|
||
return formatCPDate(*t)
|
||
}
|
||
|
||
func formatCPAging(v *int) string {
|
||
if v == nil {
|
||
return "-"
|
||
}
|
||
return strconv.Itoa(*v)
|
||
}
|
||
|
||
func formatCPIDInteger(v float64) string {
|
||
n := int64(math.Round(v))
|
||
if n == 0 {
|
||
return "0"
|
||
}
|
||
negative := n < 0
|
||
abs := n
|
||
if negative {
|
||
abs = -n
|
||
}
|
||
s := strconv.FormatInt(abs, 10)
|
||
// insert dots as thousand separators
|
||
var b strings.Builder
|
||
start := len(s) % 3
|
||
if start == 0 {
|
||
start = 3
|
||
}
|
||
b.WriteString(s[:start])
|
||
for i := start; i < len(s); i += 3 {
|
||
b.WriteByte('.')
|
||
b.WriteString(s[i : i+3])
|
||
}
|
||
if negative {
|
||
return "-" + b.String()
|
||
}
|
||
return b.String()
|
||
}
|
||
|
||
func formatCPRupiah(v float64) string {
|
||
const nbsp = " "
|
||
if v < 0 {
|
||
return "-Rp" + nbsp + formatCPIDInteger(-v)
|
||
}
|
||
return "Rp" + nbsp + formatCPIDInteger(v)
|
||
}
|
||
|
||
func formatCPAvg(v float64) string {
|
||
if v == 0 {
|
||
return "0"
|
||
}
|
||
s := strconv.FormatFloat(v, 'f', 2, 64)
|
||
return strings.ReplaceAll(s, ".", ",")
|
||
}
|
||
|
||
func safeCPText(s string) string {
|
||
t := strings.TrimSpace(s)
|
||
if t == "" {
|
||
return "-"
|
||
}
|
||
return t
|
||
}
|
||
|
||
func joinCPStrings(ss []string) string {
|
||
var parts []string
|
||
for _, s := range ss {
|
||
s = strings.TrimSpace(s)
|
||
if s != "" {
|
||
parts = append(parts, s)
|
||
}
|
||
}
|
||
if len(parts) == 0 {
|
||
return "-"
|
||
}
|
||
return strings.Join(parts, "\n")
|
||
}
|