379 lines
9.6 KiB
Go
379 lines
9.6 KiB
Go
package routes
|
|
|
|
import (
|
|
"bssapp-backend/queries"
|
|
"bytes"
|
|
"database/sql"
|
|
"fmt"
|
|
"net/http"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jung-kurt/gofpdf"
|
|
)
|
|
|
|
type orderListPDFRow struct {
|
|
OrderNumber string
|
|
OrderDate string
|
|
TerminTarihi string
|
|
CurrAccCode string
|
|
CurrAccDescription string
|
|
MusteriTemsilcisi string
|
|
Piyasa string
|
|
DocCurrencyCode string
|
|
TotalAmount float64
|
|
TotalAmountUSD float64
|
|
PackedUSD float64
|
|
PackedRatePct float64
|
|
HasUretimUrunu bool
|
|
Description string
|
|
}
|
|
|
|
type pdfColumn struct {
|
|
Header string
|
|
Width float64
|
|
Align string
|
|
Wrap bool
|
|
MaxLines int
|
|
}
|
|
|
|
func OrderListPDFRoute(db *sql.DB) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
search := strings.TrimSpace(r.URL.Query().Get("search"))
|
|
currAcc := strings.TrimSpace(r.URL.Query().Get("CurrAccCode"))
|
|
orderDate := strings.TrimSpace(r.URL.Query().Get("OrderDate"))
|
|
sortBy := strings.TrimSpace(r.URL.Query().Get("sort_by"))
|
|
descending := parseBool(r.URL.Query().Get("descending"))
|
|
|
|
rows, err := queries.GetOrderListExcel(db, search, currAcc, orderDate)
|
|
if err != nil {
|
|
http.Error(w, "db error: "+err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
out := make([]orderListPDFRow, 0, 256)
|
|
for rows.Next() {
|
|
var (
|
|
id, no, date, termin, code, name string
|
|
rep, piyasa, cur string
|
|
total float64
|
|
totalUSD float64
|
|
packedAmount float64
|
|
packedUSD float64
|
|
packedRatePct float64
|
|
hasUretim bool
|
|
desc string
|
|
usdRate float64
|
|
)
|
|
|
|
if err := rows.Scan(
|
|
&id, &no, &date, &termin, &code, &name, &rep, &piyasa, &cur,
|
|
&total, &totalUSD, &packedAmount, &packedUSD, &packedRatePct,
|
|
&hasUretim, &desc, &usdRate,
|
|
); err != nil {
|
|
http.Error(w, "scan error: "+err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
_ = id
|
|
_ = packedAmount
|
|
_ = usdRate
|
|
|
|
out = append(out, orderListPDFRow{
|
|
OrderNumber: no,
|
|
OrderDate: date,
|
|
TerminTarihi: termin,
|
|
CurrAccCode: code,
|
|
CurrAccDescription: name,
|
|
MusteriTemsilcisi: rep,
|
|
Piyasa: piyasa,
|
|
DocCurrencyCode: cur,
|
|
TotalAmount: total,
|
|
TotalAmountUSD: totalUSD,
|
|
PackedUSD: packedUSD,
|
|
PackedRatePct: packedRatePct,
|
|
HasUretimUrunu: hasUretim,
|
|
Description: desc,
|
|
})
|
|
}
|
|
|
|
applyOrderListSort(out, sortBy, descending)
|
|
|
|
pdf := gofpdf.New("L", "mm", "A4", "")
|
|
pdf.SetMargins(8, 8, 8)
|
|
pdf.SetAutoPageBreak(false, 10)
|
|
if err := registerDejavuFonts(pdf, "dejavu"); err != nil {
|
|
http.Error(w, "pdf font error: "+err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
drawOrderListPDF(pdf, out, search, currAcc, orderDate, sortBy, descending)
|
|
if err := pdf.Error(); err != nil {
|
|
http.Error(w, "pdf render error: "+err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
if err := pdf.Output(&buf); err != nil {
|
|
http.Error(w, "pdf output error: "+err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/pdf")
|
|
w.Header().Set("Content-Disposition", "inline; filename=\"siparis-listesi.pdf\"")
|
|
_, _ = w.Write(buf.Bytes())
|
|
})
|
|
}
|
|
|
|
func drawOrderListPDF(
|
|
pdf *gofpdf.Fpdf,
|
|
rows []orderListPDFRow,
|
|
search, currAcc, orderDate, sortBy string,
|
|
desc bool,
|
|
) {
|
|
cols := []pdfColumn{
|
|
{Header: "Siparis No", Width: 20, Align: "L", Wrap: false, MaxLines: 1},
|
|
{Header: "Tarih", Width: 12, Align: "C", Wrap: false, MaxLines: 1},
|
|
{Header: "Termin", Width: 12, Align: "C", Wrap: false, MaxLines: 1},
|
|
{Header: "Cari Kod", Width: 15, Align: "L", Wrap: true, MaxLines: 2},
|
|
{Header: "Cari Adi", Width: 27, Align: "L", Wrap: true, MaxLines: 3},
|
|
{Header: "Temsilci", Width: 18, Align: "L", Wrap: true, MaxLines: 2},
|
|
{Header: "Piyasa", Width: 13, Align: "L", Wrap: true, MaxLines: 2},
|
|
{Header: "PB", Width: 8, Align: "C", Wrap: false, MaxLines: 1},
|
|
{Header: "Tutar", Width: 15, Align: "R", Wrap: false, MaxLines: 1},
|
|
{Header: "USD", Width: 15, Align: "R", Wrap: false, MaxLines: 1},
|
|
{Header: "Paket USD", Width: 15, Align: "R", Wrap: false, MaxLines: 1},
|
|
{Header: "%", Width: 8, Align: "R", Wrap: false, MaxLines: 1},
|
|
{Header: "Uretim", Width: 24, Align: "L", Wrap: true, MaxLines: 3},
|
|
{Header: "Aciklama", Width: 52, Align: "L", Wrap: true, MaxLines: 3},
|
|
}
|
|
|
|
pageW, pageH := pdf.GetPageSize()
|
|
marginL, marginT, marginR := 8.0, 8.0, 8.0
|
|
bottomLimit := pageH - 10.0
|
|
lineH := 3.8
|
|
cellPadX := 1.1
|
|
cellPadY := 0.6
|
|
|
|
drawHeader := func() {
|
|
pdf.AddPage()
|
|
pdf.SetFont("dejavu", "B", 12)
|
|
pdf.CellFormat(0, 7, "Siparis Listesi", "", 1, "L", false, 0, "")
|
|
|
|
pdf.SetFont("dejavu", "", 8)
|
|
sortText := "TotalAmountUSD DESC (varsayilan)"
|
|
if sortBy != "" {
|
|
dir := "ASC"
|
|
if desc {
|
|
dir = "DESC"
|
|
}
|
|
sortText = fmt.Sprintf("%s %s", sortBy, dir)
|
|
}
|
|
filterLine := fmt.Sprintf(
|
|
"Filtreler -> Arama: %s | Cari: %s | Siparis Tarihi: %s | Siralama: %s | Olusturma: %s",
|
|
emptyDash(search),
|
|
emptyDash(currAcc),
|
|
emptyDash(orderDate),
|
|
sortText,
|
|
time.Now().Format("2006-01-02 15:04"),
|
|
)
|
|
pdf.CellFormat(0, 5, filterLine, "", 1, "L", false, 0, "")
|
|
pdf.Ln(1)
|
|
|
|
pdf.SetFont("dejavu", "B", 8)
|
|
pdf.SetFillColor(240, 240, 240)
|
|
for _, c := range cols {
|
|
pdf.CellFormat(c.Width, 6, c.Header, "1", 0, "C", true, 0, "")
|
|
}
|
|
pdf.Ln(-1)
|
|
pdf.SetFont("dejavu", "", 7)
|
|
}
|
|
|
|
buildCells := func(row orderListPDFRow) []string {
|
|
uretim := ""
|
|
if row.HasUretimUrunu {
|
|
uretim = "Uretime Verilecek Urunu Var"
|
|
}
|
|
return []string{
|
|
row.OrderNumber,
|
|
row.OrderDate,
|
|
row.TerminTarihi,
|
|
row.CurrAccCode,
|
|
row.CurrAccDescription,
|
|
row.MusteriTemsilcisi,
|
|
row.Piyasa,
|
|
row.DocCurrencyCode,
|
|
fmt.Sprintf("%.2f", row.TotalAmount),
|
|
fmt.Sprintf("%.2f", row.TotalAmountUSD),
|
|
fmt.Sprintf("%.2f", row.PackedUSD),
|
|
fmt.Sprintf("%.2f", row.PackedRatePct),
|
|
uretim,
|
|
row.Description,
|
|
}
|
|
}
|
|
|
|
calcLineCount := func(col pdfColumn, text string) int {
|
|
if !col.Wrap {
|
|
return 1
|
|
}
|
|
lines := pdf.SplitLines([]byte(strings.TrimSpace(text)), col.Width-(cellPadX*2))
|
|
n := len(lines)
|
|
if n < 1 {
|
|
n = 1
|
|
}
|
|
if col.MaxLines > 0 && n > col.MaxLines {
|
|
n = col.MaxLines
|
|
}
|
|
return n
|
|
}
|
|
|
|
drawWrappedCell := func(x, y, w, h float64, text, align string, maxLines int) {
|
|
pdf.Rect(x, y, w, h, "D")
|
|
lines := pdf.SplitLines([]byte(strings.TrimSpace(text)), w-(cellPadX*2))
|
|
if len(lines) == 0 {
|
|
lines = [][]byte{[]byte("")}
|
|
}
|
|
if maxLines > 0 && len(lines) > maxLines {
|
|
lines = lines[:maxLines]
|
|
}
|
|
ty := y + cellPadY + 2.8
|
|
for _, ln := range lines {
|
|
pdf.SetXY(x+cellPadX, ty-2.8)
|
|
pdf.CellFormat(w-(cellPadX*2), 3.8, string(ln), "", 0, align, false, 0, "")
|
|
ty += 3.8
|
|
}
|
|
}
|
|
|
|
drawHeader()
|
|
|
|
for _, row := range rows {
|
|
cells := buildCells(row)
|
|
maxLines := 1
|
|
for i, c := range cols {
|
|
n := calcLineCount(c, cells[i])
|
|
if n > maxLines {
|
|
maxLines = n
|
|
}
|
|
}
|
|
rowH := (float64(maxLines) * lineH) + (cellPadY * 2)
|
|
|
|
if pdf.GetY()+rowH > bottomLimit {
|
|
drawHeader()
|
|
}
|
|
|
|
x := marginL
|
|
y := pdf.GetY()
|
|
for i, c := range cols {
|
|
if c.Wrap {
|
|
drawWrappedCell(x, y, c.Width, rowH, cells[i], c.Align, c.MaxLines)
|
|
} else {
|
|
pdf.SetXY(x, y)
|
|
pdf.CellFormat(c.Width, rowH, cells[i], "1", 0, c.Align, false, 0, "")
|
|
}
|
|
x += c.Width
|
|
}
|
|
pdf.SetXY(marginL, y+rowH)
|
|
}
|
|
|
|
_ = pageW
|
|
_ = marginT
|
|
_ = marginR
|
|
}
|
|
|
|
func applyOrderListSort(rows []orderListPDFRow, sortBy string, desc bool) {
|
|
if len(rows) <= 1 {
|
|
return
|
|
}
|
|
|
|
field := strings.TrimSpace(sortBy)
|
|
if field == "" {
|
|
field = "TotalAmountUSD"
|
|
desc = true
|
|
}
|
|
|
|
lessText := func(a, b string) bool {
|
|
aa := strings.ToLower(strings.TrimSpace(a))
|
|
bb := strings.ToLower(strings.TrimSpace(b))
|
|
if desc {
|
|
return aa > bb
|
|
}
|
|
return aa < bb
|
|
}
|
|
lessNum := func(a, b float64) bool {
|
|
if desc {
|
|
return a > b
|
|
}
|
|
return a < b
|
|
}
|
|
lessBool := func(a, b bool) bool {
|
|
av, bv := 0, 0
|
|
if a {
|
|
av = 1
|
|
}
|
|
if b {
|
|
bv = 1
|
|
}
|
|
if desc {
|
|
return av > bv
|
|
}
|
|
return av < bv
|
|
}
|
|
|
|
sort.SliceStable(rows, func(i, j int) bool {
|
|
a := rows[i]
|
|
b := rows[j]
|
|
switch field {
|
|
case "OrderNumber":
|
|
return lessText(a.OrderNumber, b.OrderNumber)
|
|
case "OrderDate":
|
|
return lessText(a.OrderDate, b.OrderDate)
|
|
case "TerminTarihi":
|
|
return lessText(a.TerminTarihi, b.TerminTarihi)
|
|
case "CurrAccCode":
|
|
return lessText(a.CurrAccCode, b.CurrAccCode)
|
|
case "CurrAccDescription":
|
|
return lessText(a.CurrAccDescription, b.CurrAccDescription)
|
|
case "MusteriTemsilcisi":
|
|
return lessText(a.MusteriTemsilcisi, b.MusteriTemsilcisi)
|
|
case "Piyasa":
|
|
return lessText(a.Piyasa, b.Piyasa)
|
|
case "DocCurrencyCode":
|
|
return lessText(a.DocCurrencyCode, b.DocCurrencyCode)
|
|
case "TotalAmount":
|
|
return lessNum(a.TotalAmount, b.TotalAmount)
|
|
case "PackedUSD":
|
|
return lessNum(a.PackedUSD, b.PackedUSD)
|
|
case "PackedRatePct":
|
|
return lessNum(a.PackedRatePct, b.PackedRatePct)
|
|
case "HasUretimUrunu":
|
|
return lessBool(a.HasUretimUrunu, b.HasUretimUrunu)
|
|
case "Description":
|
|
return lessText(a.Description, b.Description)
|
|
default:
|
|
return lessNum(a.TotalAmountUSD, b.TotalAmountUSD)
|
|
}
|
|
})
|
|
}
|
|
|
|
func emptyDash(v string) string {
|
|
if strings.TrimSpace(v) == "" {
|
|
return "-"
|
|
}
|
|
return v
|
|
}
|
|
|
|
func parseBool(v string) bool {
|
|
b, err := strconv.ParseBool(strings.TrimSpace(v))
|
|
if err == nil {
|
|
return b
|
|
}
|
|
switch strings.TrimSpace(strings.ToLower(v)) {
|
|
case "1", "yes", "on":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|