592 lines
17 KiB
Go
592 lines
17 KiB
Go
package routes
|
||
|
||
import (
|
||
"bssapp-backend/auth"
|
||
"bssapp-backend/models"
|
||
"bssapp-backend/queries"
|
||
"bytes"
|
||
"database/sql"
|
||
"fmt"
|
||
"math"
|
||
"net/http"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/jung-kurt/gofpdf"
|
||
)
|
||
|
||
type agingDetailPDF struct {
|
||
FaturaCari string
|
||
OdemeCari string
|
||
Doviz string
|
||
FaturaRef string
|
||
OdemeRef string
|
||
FaturaTarihi string
|
||
OdemeTarihi string
|
||
OdemeDocDate string
|
||
EslesenTutar float64
|
||
UsdTutar float64
|
||
TryTutar float64
|
||
Aciklama string
|
||
Gun int
|
||
GunBelge int
|
||
GunKur float64
|
||
odemeDateParsed time.Time
|
||
odemeDateEmpty bool
|
||
}
|
||
|
||
type agingCurrencyPDF struct {
|
||
Key string
|
||
Cari8 string
|
||
CariDetay string
|
||
Doviz string
|
||
AcikKalemTutar float64
|
||
AcikKalemUSD float64
|
||
AcikKalemTRY float64
|
||
OrtGun int
|
||
OrtBelgeGun int
|
||
weightedBase float64
|
||
weightedGunSum float64
|
||
weightedDocSum float64
|
||
Details []agingDetailPDF
|
||
}
|
||
|
||
type agingMasterPDF struct {
|
||
Key string
|
||
Cari8 string
|
||
CariDetay string
|
||
AcikKalemUSD float64
|
||
AcikKalemTRY float64
|
||
AcikKalemOrtVadeGun int
|
||
AcikKalemOrtBelge int
|
||
NormalUSD float64
|
||
NormalTRY float64
|
||
OrtalamaVadeGun int
|
||
OrtalamaBelgeGun int
|
||
weightedAllBase float64
|
||
weightedAllGunSum float64
|
||
weightedAllDocSum float64
|
||
weightedOpenBase float64
|
||
weightedOpenGunSum float64
|
||
weightedOpenDocSum float64
|
||
Currencies []agingCurrencyPDF
|
||
}
|
||
|
||
func ExportStatementAgingPDFHandler(_ *sql.DB) http.HandlerFunc {
|
||
return func(w http.ResponseWriter, r *http.Request) {
|
||
claims, ok := auth.GetClaimsFromContext(r.Context())
|
||
if !ok || claims == nil {
|
||
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
||
return
|
||
}
|
||
|
||
selectedDate := time.Now().Format("2006-01-02")
|
||
listParams := models.CustomerBalanceListParams{
|
||
SelectedDate: selectedDate,
|
||
CariSearch: strings.TrimSpace(r.URL.Query().Get("cari_search")),
|
||
CariIlkGrup: strings.TrimSpace(r.URL.Query().Get("cari_ilk_grup")),
|
||
Piyasa: strings.TrimSpace(r.URL.Query().Get("piyasa")),
|
||
Temsilci: strings.TrimSpace(r.URL.Query().Get("temsilci")),
|
||
RiskDurumu: strings.TrimSpace(r.URL.Query().Get("risk_durumu")),
|
||
IslemTipi: strings.TrimSpace(r.URL.Query().Get("islem_tipi")),
|
||
Ulke: strings.TrimSpace(r.URL.Query().Get("ulke")),
|
||
Il: strings.TrimSpace(r.URL.Query().Get("il")),
|
||
Ilce: strings.TrimSpace(r.URL.Query().Get("ilce")),
|
||
}
|
||
detailed := parseBoolQuery(r.URL.Query().Get("detailed"))
|
||
excludeZero12 := parseBoolQuery(r.URL.Query().Get("exclude_zero_12"))
|
||
excludeZero13 := parseBoolQuery(r.URL.Query().Get("exclude_zero_13"))
|
||
|
||
rows, err := queries.GetStatementAgingBalanceList(r.Context(), listParams)
|
||
if err != nil {
|
||
http.Error(w, "db error: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
rows = filterCustomerBalanceRowsForPDF(rows, excludeZero12, excludeZero13)
|
||
summaries, detailsByMaster := buildCustomerBalancePDFData(rows)
|
||
|
||
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
|
||
}
|
||
|
||
drawCustomerBalancePDF(
|
||
pdf,
|
||
selectedDate,
|
||
listParams.CariSearch,
|
||
detailed,
|
||
summaries,
|
||
detailsByMaster,
|
||
)
|
||
|
||
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")
|
||
filename := "account-aging-summary.pdf"
|
||
if detailed {
|
||
filename = "account-aging-detailed.pdf"
|
||
}
|
||
w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=%q", filename))
|
||
_, _ = w.Write(buf.Bytes())
|
||
}
|
||
}
|
||
|
||
func buildAgingPDFData(rows []map[string]interface{}) []agingMasterPDF {
|
||
masterMap := make(map[string]*agingMasterPDF)
|
||
currMap := make(map[string]*agingCurrencyPDF)
|
||
|
||
for _, row := range rows {
|
||
cari8 := strings.TrimSpace(readStrAny(row["Cari8"], row["cari8"]))
|
||
if cari8 == "" {
|
||
continue
|
||
}
|
||
cariDetay := strings.TrimSpace(readStrAny(row["CariDetay"], row["cari_detay"]))
|
||
doviz := strings.ToUpper(strings.TrimSpace(readStrAny(row["DocCurrencyCode"], row["doc_currency_code"])))
|
||
if doviz == "" {
|
||
doviz = "TRY"
|
||
}
|
||
aciklama := strings.ToUpper(strings.TrimSpace(readStrAny(row["Aciklama"], row["aciklama"])))
|
||
isAcik := aciklama == "ACIKKALEM"
|
||
|
||
eslesen := readFloatAny(row["EslesenTutar"], row["eslesen_tutar"])
|
||
usd := readFloatAny(row["UsdTutar"], row["usd_tutar"])
|
||
tryVal := readFloatAny(row["TryTutar"], row["try_tutar"])
|
||
gun := readIntAny(row["GunSayisi"], row["gun_sayisi"])
|
||
gunBelge := readIntAny(row["GunSayisi_DocDate"], row["gun_sayisi_docdate"])
|
||
absTry := math.Abs(tryVal)
|
||
|
||
m := masterMap[cari8]
|
||
if m == nil {
|
||
m = &agingMasterPDF{Key: cari8, Cari8: cari8, CariDetay: cariDetay}
|
||
masterMap[cari8] = m
|
||
}
|
||
if m.CariDetay == "" && cariDetay != "" {
|
||
m.CariDetay = cariDetay
|
||
}
|
||
|
||
ckey := cari8 + "|" + doviz
|
||
c := currMap[ckey]
|
||
if c == nil {
|
||
c = &agingCurrencyPDF{
|
||
Key: ckey,
|
||
Cari8: cari8,
|
||
CariDetay: cariDetay,
|
||
Doviz: doviz,
|
||
Details: make([]agingDetailPDF, 0, 128),
|
||
}
|
||
currMap[ckey] = c
|
||
}
|
||
if c.CariDetay == "" && cariDetay != "" {
|
||
c.CariDetay = cariDetay
|
||
}
|
||
|
||
if isAcik {
|
||
m.AcikKalemUSD += usd
|
||
m.AcikKalemTRY += tryVal
|
||
c.AcikKalemTutar += eslesen
|
||
c.AcikKalemUSD += usd
|
||
c.AcikKalemTRY += tryVal
|
||
} else {
|
||
m.NormalUSD += usd
|
||
m.NormalTRY += tryVal
|
||
}
|
||
|
||
if absTry > 0 {
|
||
m.weightedAllBase += absTry
|
||
m.weightedAllGunSum += absTry * float64(gun)
|
||
m.weightedAllDocSum += absTry * float64(gunBelge)
|
||
|
||
if isAcik {
|
||
m.weightedOpenBase += absTry
|
||
m.weightedOpenGunSum += absTry * float64(gun)
|
||
m.weightedOpenDocSum += absTry * float64(gunBelge)
|
||
|
||
c.weightedBase += absTry
|
||
c.weightedGunSum += absTry * float64(gun)
|
||
c.weightedDocSum += absTry * float64(gunBelge)
|
||
}
|
||
}
|
||
|
||
odemeTar := readStrAny(row["OdemeTarihi"], row["odeme_tarihi"])
|
||
odemeParsed, ok := parseYMD(odemeTar)
|
||
detail := agingDetailPDF{
|
||
FaturaCari: readStrAny(row["FaturaCari"], row["fatura_cari"]),
|
||
OdemeCari: readStrAny(row["OdemeCari"], row["odeme_cari"]),
|
||
Doviz: doviz,
|
||
FaturaRef: readStrAny(row["FaturaRef"], row["fatura_ref"]),
|
||
OdemeRef: readStrAny(row["OdemeRef"], row["odeme_ref"]),
|
||
FaturaTarihi: readStrAny(row["FaturaTarihi"], row["fatura_tarihi"]),
|
||
OdemeTarihi: odemeTar,
|
||
OdemeDocDate: readStrAny(row["OdemeDocDate"], row["odeme_doc_date"]),
|
||
EslesenTutar: eslesen,
|
||
UsdTutar: usd,
|
||
TryTutar: tryVal,
|
||
Aciklama: readStrAny(row["Aciklama"], row["aciklama"]),
|
||
Gun: gun,
|
||
GunBelge: gunBelge,
|
||
GunKur: readFloatAny(row["GunKur"], row["gun_kur"]),
|
||
odemeDateParsed: odemeParsed,
|
||
odemeDateEmpty: !ok,
|
||
}
|
||
c.Details = append(c.Details, detail)
|
||
}
|
||
|
||
masters := make([]agingMasterPDF, 0, len(masterMap))
|
||
for _, m := range masterMap {
|
||
if m.weightedOpenBase > 0 {
|
||
m.AcikKalemOrtVadeGun = int(math.Ceil(m.weightedOpenGunSum / m.weightedOpenBase))
|
||
m.AcikKalemOrtBelge = int(math.Ceil(m.weightedOpenDocSum / m.weightedOpenBase))
|
||
}
|
||
if m.weightedAllBase > 0 {
|
||
m.OrtalamaVadeGun = int(math.Ceil(m.weightedAllGunSum / m.weightedAllBase))
|
||
m.OrtalamaBelgeGun = int(math.Ceil(m.weightedAllDocSum / m.weightedAllBase))
|
||
}
|
||
|
||
currs := make([]agingCurrencyPDF, 0, len(currMap))
|
||
for _, c := range currMap {
|
||
if c.Cari8 != m.Cari8 {
|
||
continue
|
||
}
|
||
if c.weightedBase > 0 {
|
||
c.OrtGun = int(math.Ceil(c.weightedGunSum / c.weightedBase))
|
||
c.OrtBelgeGun = int(math.Ceil(c.weightedDocSum / c.weightedBase))
|
||
}
|
||
sort.SliceStable(c.Details, func(i, j int) bool {
|
||
ai := c.Details[i]
|
||
aj := c.Details[j]
|
||
if ai.odemeDateEmpty && !aj.odemeDateEmpty {
|
||
return true
|
||
}
|
||
if !ai.odemeDateEmpty && aj.odemeDateEmpty {
|
||
return false
|
||
}
|
||
if ai.odemeDateEmpty && aj.odemeDateEmpty {
|
||
return false
|
||
}
|
||
return ai.odemeDateParsed.After(aj.odemeDateParsed)
|
||
})
|
||
currs = append(currs, *c)
|
||
}
|
||
sort.SliceStable(currs, func(i, j int) bool { return currs[i].Doviz < currs[j].Doviz })
|
||
m.Currencies = currs
|
||
masters = append(masters, *m)
|
||
}
|
||
|
||
sort.SliceStable(masters, func(i, j int) bool { return masters[i].Cari8 < masters[j].Cari8 })
|
||
return masters
|
||
}
|
||
|
||
func drawStatementAgingPDF(pdf *gofpdf.Fpdf, p models.StatementAgingParams, masters []agingMasterPDF) {
|
||
pageW, pageH := pdf.GetPageSize()
|
||
marginL, marginR, marginT, marginB := 8.0, 8.0, 8.0, 10.0
|
||
tableW := pageW - marginL - marginR
|
||
|
||
colorPrimary := [3]int{149, 113, 22}
|
||
colorLevel2 := [3]int{76, 95, 122}
|
||
colorLevel3 := [3]int{31, 59, 91}
|
||
|
||
level1Cols := []string{"Ana Cari Kod", "Ana Cari Detay", "Açık Kalem USD", "Açık Kalem TRY", "Açık Kalem Ort Vade", "Açık Kalem Ort Belge", "Normal USD", "Normal TRY", "Ortalama Vade", "Ortalama Belge"}
|
||
level1W := normalizeWidths([]float64{20, 46, 18, 18, 15, 15, 16, 16, 15, 15}, tableW)
|
||
|
||
level2Cols := []string{"Ana Cari Kod", "Ana Cari Detay", "Döviz", "Açık Kalem", "Açık Kalem USD", "Açık Kalem TRY", "Ort Gün", "Ort Belge Gün"}
|
||
level2W := normalizeWidths([]float64{20, 52, 12, 24, 24, 24, 16, 18}, tableW)
|
||
|
||
level3Cols := []string{"Fatura Cari", "Ödeme Cari", "Döviz", "Fatura Ref", "Ödeme Ref", "Fatura Tarihi", "Ödeme Vade", "Ödeme DocDate", "Eşleşen", "USD", "TRY", "Açıklama", "Gün", "Gün Belge", "Gün Kur"}
|
||
level3W := normalizeWidths([]float64{15, 15, 10, 15, 15, 13, 13, 13, 14, 12, 14, 14, 8, 10, 10}, tableW)
|
||
|
||
pageHeader := func() {
|
||
pdf.AddPage()
|
||
pdf.SetFont("dejavu", "B", 15)
|
||
pdf.SetTextColor(colorPrimary[0], colorPrimary[1], colorPrimary[2])
|
||
pdf.SetXY(marginL, marginT)
|
||
pdf.CellFormat(150, 7, "Cari Yaşlandırmalı Ekstre", "", 0, "L", false, 0, "")
|
||
|
||
pdf.SetFont("dejavu", "", 9)
|
||
pdf.SetTextColor(20, 20, 20)
|
||
pdf.SetXY(pageW-marginR-95, marginT+1)
|
||
pdf.CellFormat(95, 5, "Son Tarih: "+p.EndDate, "", 0, "R", false, 0, "")
|
||
pdf.SetXY(pageW-marginR-95, marginT+6)
|
||
pdf.CellFormat(95, 5, "Cari: "+p.AccountCode, "", 0, "R", false, 0, "")
|
||
|
||
mode := "1_2"
|
||
if len(p.Parislemler) > 0 {
|
||
mode = strings.Join(p.Parislemler, ",")
|
||
}
|
||
pdf.SetXY(pageW-marginR-95, marginT+11)
|
||
pdf.CellFormat(95, 5, "Parasal İşlem: "+mode, "", 0, "R", false, 0, "")
|
||
|
||
pdf.SetDrawColor(colorPrimary[0], colorPrimary[1], colorPrimary[2])
|
||
pdf.Line(marginL, marginT+16, pageW-marginR, marginT+16)
|
||
pdf.SetDrawColor(210, 210, 210)
|
||
pdf.SetY(marginT + 19)
|
||
}
|
||
|
||
needPage := func(need float64) bool {
|
||
return pdf.GetY()+need+marginB > pageH
|
||
}
|
||
|
||
drawHeaderRow := func(cols []string, widths []float64, rgb [3]int, h float64) {
|
||
pdf.SetFont("dejavu", "B", 8.4)
|
||
pdf.SetFillColor(rgb[0], rgb[1], rgb[2])
|
||
pdf.SetTextColor(255, 255, 255)
|
||
y := pdf.GetY()
|
||
x := marginL
|
||
for i, c := range cols {
|
||
pdf.Rect(x, y, widths[i], h, "DF")
|
||
pdf.SetXY(x+0.8, y+1.0)
|
||
pdf.CellFormat(widths[i]-1.6, h-2.0, c, "", 0, "C", false, 0, "")
|
||
x += widths[i]
|
||
}
|
||
pdf.SetY(y + h)
|
||
}
|
||
|
||
drawRow := func(vals []string, widths []float64, h float64, fill bool, fillRGB [3]int, centerCols map[int]bool, rightCols map[int]bool) {
|
||
pdf.SetFont("dejavu", "", 7.6)
|
||
pdf.SetTextColor(20, 20, 20)
|
||
y := pdf.GetY()
|
||
x := marginL
|
||
for i, v := range vals {
|
||
if fill {
|
||
pdf.SetFillColor(fillRGB[0], fillRGB[1], fillRGB[2])
|
||
pdf.Rect(x, y, widths[i], h, "DF")
|
||
} else {
|
||
pdf.Rect(x, y, widths[i], h, "")
|
||
}
|
||
align := "L"
|
||
if rightCols[i] {
|
||
align = "R"
|
||
} else if centerCols[i] {
|
||
align = "C"
|
||
}
|
||
pdf.SetXY(x+0.8, y+0.8)
|
||
pdf.CellFormat(widths[i]-1.6, h-1.6, v, "", 0, align, false, 0, "")
|
||
x += widths[i]
|
||
}
|
||
pdf.SetY(y + h)
|
||
}
|
||
|
||
format2 := func(v float64) string {
|
||
return trFormat(v, 2)
|
||
}
|
||
|
||
pageHeader()
|
||
for _, m := range masters {
|
||
if needPage(7 + 7 + 6) {
|
||
pageHeader()
|
||
}
|
||
|
||
drawHeaderRow(level1Cols, level1W, colorPrimary, 7)
|
||
drawRow(
|
||
[]string{
|
||
m.Cari8, m.CariDetay,
|
||
format2(m.AcikKalemUSD), format2(m.AcikKalemTRY),
|
||
fmt.Sprintf("%d", m.AcikKalemOrtVadeGun), fmt.Sprintf("%d", m.AcikKalemOrtBelge),
|
||
format2(m.NormalUSD), format2(m.NormalTRY),
|
||
fmt.Sprintf("%d", m.OrtalamaVadeGun), fmt.Sprintf("%d", m.OrtalamaBelgeGun),
|
||
},
|
||
level1W, 6.4, true, [3]int{250, 246, 238},
|
||
map[int]bool{0: true, 4: true, 5: true, 8: true, 9: true},
|
||
map[int]bool{2: true, 3: true, 6: true, 7: true},
|
||
)
|
||
|
||
for _, c := range m.Currencies {
|
||
if needPage(6 + 6 + 6) {
|
||
pageHeader()
|
||
drawHeaderRow(level1Cols, level1W, colorPrimary, 7)
|
||
drawRow(
|
||
[]string{
|
||
m.Cari8, m.CariDetay,
|
||
format2(m.AcikKalemUSD), format2(m.AcikKalemTRY),
|
||
fmt.Sprintf("%d", m.AcikKalemOrtVadeGun), fmt.Sprintf("%d", m.AcikKalemOrtBelge),
|
||
format2(m.NormalUSD), format2(m.NormalTRY),
|
||
fmt.Sprintf("%d", m.OrtalamaVadeGun), fmt.Sprintf("%d", m.OrtalamaBelgeGun),
|
||
},
|
||
level1W, 6.4, true, [3]int{250, 246, 238},
|
||
map[int]bool{0: true, 4: true, 5: true, 8: true, 9: true},
|
||
map[int]bool{2: true, 3: true, 6: true, 7: true},
|
||
)
|
||
}
|
||
|
||
drawHeaderRow(level2Cols, level2W, colorLevel2, 6)
|
||
drawRow(
|
||
[]string{
|
||
c.Cari8, c.CariDetay, c.Doviz,
|
||
format2(c.AcikKalemTutar), format2(c.AcikKalemUSD), format2(c.AcikKalemTRY),
|
||
fmt.Sprintf("%d", c.OrtGun), fmt.Sprintf("%d", c.OrtBelgeGun),
|
||
},
|
||
level2W, 5.8, true, [3]int{236, 240, 247},
|
||
map[int]bool{0: true, 2: true, 6: true, 7: true},
|
||
map[int]bool{3: true, 4: true, 5: true},
|
||
)
|
||
|
||
if needPage(5.8) {
|
||
pageHeader()
|
||
}
|
||
drawHeaderRow(level3Cols, level3W, colorLevel3, 5.8)
|
||
|
||
for _, d := range c.Details {
|
||
if needPage(5.2) {
|
||
pageHeader()
|
||
drawHeaderRow(level3Cols, level3W, colorLevel3, 5.8)
|
||
}
|
||
drawRow(
|
||
[]string{
|
||
d.FaturaCari, d.OdemeCari, d.Doviz, d.FaturaRef, d.OdemeRef,
|
||
d.FaturaTarihi, d.OdemeTarihi, d.OdemeDocDate,
|
||
format2(d.EslesenTutar), format2(d.UsdTutar), format2(d.TryTutar), d.Aciklama,
|
||
fmt.Sprintf("%d", d.Gun), fmt.Sprintf("%d", d.GunBelge), trFormat(d.GunKur, 2),
|
||
},
|
||
level3W, 5.2, false, [3]int{},
|
||
map[int]bool{2: true, 5: true, 6: true, 7: true, 11: true, 12: true, 13: true, 14: true},
|
||
map[int]bool{8: true, 9: true, 10: true},
|
||
)
|
||
}
|
||
pdf.Ln(1.2)
|
||
}
|
||
pdf.Ln(1.8)
|
||
}
|
||
}
|
||
|
||
func trFormat(v float64, frac int) string {
|
||
neg := v < 0
|
||
if neg {
|
||
v = -v
|
||
}
|
||
pow := math.Pow(10, float64(frac))
|
||
rounded := math.Round(v*pow) / pow
|
||
intPart := int64(rounded)
|
||
decPart := int64(math.Round((rounded - float64(intPart)) * pow))
|
||
|
||
intStr := fmt.Sprintf("%d", intPart)
|
||
var grouped strings.Builder
|
||
for i, r := range intStr {
|
||
if i > 0 && (len(intStr)-i)%3 == 0 {
|
||
grouped.WriteString(".")
|
||
}
|
||
grouped.WriteRune(r)
|
||
}
|
||
|
||
out := grouped.String()
|
||
if frac > 0 {
|
||
decFmt := fmt.Sprintf("%%0%dd", frac)
|
||
out += "," + fmt.Sprintf(decFmt, decPart)
|
||
}
|
||
if neg {
|
||
return "-" + out
|
||
}
|
||
return out
|
||
}
|
||
|
||
func readStrAny(v ...interface{}) string {
|
||
for _, x := range v {
|
||
switch t := x.(type) {
|
||
case nil:
|
||
case string:
|
||
if strings.TrimSpace(t) != "" {
|
||
return t
|
||
}
|
||
case []byte:
|
||
s := strings.TrimSpace(string(t))
|
||
if s != "" {
|
||
return s
|
||
}
|
||
case time.Time:
|
||
return t.Format("2006-01-02")
|
||
default:
|
||
s := strings.TrimSpace(fmt.Sprint(t))
|
||
if s != "" && s != "<nil>" {
|
||
return s
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func readFloatAny(v ...interface{}) float64 {
|
||
for _, x := range v {
|
||
if x == nil {
|
||
continue
|
||
}
|
||
switch t := x.(type) {
|
||
case float64:
|
||
return t
|
||
case float32:
|
||
return float64(t)
|
||
case int:
|
||
return float64(t)
|
||
case int32:
|
||
return float64(t)
|
||
case int64:
|
||
return float64(t)
|
||
case string:
|
||
if n, ok := parseNumberFlexible(t); ok {
|
||
return n
|
||
}
|
||
case []byte:
|
||
if n, ok := parseNumberFlexible(string(t)); ok {
|
||
return n
|
||
}
|
||
default:
|
||
if n, ok := parseNumberFlexible(fmt.Sprint(t)); ok {
|
||
return n
|
||
}
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func readIntAny(v ...interface{}) int {
|
||
return int(math.Ceil(readFloatAny(v...)))
|
||
}
|
||
|
||
func parseNumberFlexible(s string) (float64, bool) {
|
||
s = strings.TrimSpace(s)
|
||
if s == "" {
|
||
return 0, false
|
||
}
|
||
hasComma := strings.Contains(s, ",")
|
||
hasDot := strings.Contains(s, ".")
|
||
if hasComma && hasDot {
|
||
if strings.LastIndex(s, ",") > strings.LastIndex(s, ".") {
|
||
s = strings.ReplaceAll(s, ".", "")
|
||
s = strings.Replace(s, ",", ".", 1)
|
||
} else {
|
||
s = strings.ReplaceAll(s, ",", "")
|
||
}
|
||
} else if hasComma {
|
||
s = strings.ReplaceAll(s, ".", "")
|
||
s = strings.Replace(s, ",", ".", 1)
|
||
}
|
||
n, err := strconv.ParseFloat(s, 64)
|
||
if err != nil {
|
||
return 0, false
|
||
}
|
||
return n, true
|
||
}
|
||
|
||
func parseYMD(v string) (time.Time, bool) {
|
||
v = strings.TrimSpace(v)
|
||
if v == "" {
|
||
return time.Time{}, false
|
||
}
|
||
t, err := time.Parse("2006-01-02", v)
|
||
if err != nil {
|
||
return time.Time{}, false
|
||
}
|
||
return t, true
|
||
}
|