Merge remote-tracking branch 'origin/master'

2026-03-03 00:30:19 +03:00
parent ea27d34336
commit a4f4c2457f
29 changed files with 4522 additions and 752 deletions
--- a/svc/queries/statement_aging.go
+++ b/svc/queries/statement_aging.go
@@ -0,0 +1,414 @@
+package queries
+
+import (
+	"bssapp-backend/db"
+	"bssapp-backend/models"
+	"context"
+	"database/sql"
+	"fmt"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func GetStatementAging(params models.StatementAgingParams) ([]map[string]interface{}, error) {
+	accountCode := normalizeMasterAccountCode(params.AccountCode)
+	if strings.TrimSpace(accountCode) == "" {
+		return nil, fmt.Errorf("accountcode is required")
+	}
+	if strings.TrimSpace(params.EndDate) == "" {
+		return nil, fmt.Errorf("enddate is required")
+	}
+
+	useType2, useType3 := resolveUseTypes(params.Parislemler)
+	endDate, _ := time.Parse("2006-01-02", strings.TrimSpace(params.EndDate))
+
+	rows, err := db.MssqlDB.Query(`
+		EXEC dbo.SP_FIFO_MATCH_FINAL
+			@Cari8    = @Cari8,
+			@SonTarih = @SonTarih,
+			@UseType2 = @UseType2,
+			@UseType3 = @UseType3;
+	`,
+		sql.Named("Cari8", accountCode),
+		sql.Named("SonTarih", params.EndDate),
+		sql.Named("UseType2", useType2),
+		sql.Named("UseType3", useType3),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("SP_FIFO_MATCH_FINAL query error: %w", err)
+	}
+	defer rows.Close()
+
+	columns, err := rows.Columns()
+	if err != nil {
+		return nil, fmt.Errorf("columns read error: %w", err)
+	}
+
+	result := make([]map[string]interface{}, 0, 2048)
+	cari8Set := make(map[string]struct{})
+	currencySet := make(map[string]struct{})
+	for rows.Next() {
+		values := make([]interface{}, len(columns))
+		scanArgs := make([]interface{}, len(columns))
+		for i := range values {
+			scanArgs[i] = &values[i]
+		}
+
+		if err := rows.Scan(scanArgs...); err != nil {
+			return nil, fmt.Errorf("row scan error: %w", err)
+		}
+
+		row := make(map[string]interface{}, len(columns))
+		for i, col := range columns {
+			switch v := values[i].(type) {
+			case nil:
+				row[col] = nil
+			case []byte:
+				row[col] = string(v)
+			case time.Time:
+				row[col] = v.Format("2006-01-02")
+			default:
+				row[col] = v
+			}
+		}
+
+		cari8 := strings.TrimSpace(asString(row["Cari8"]))
+		if cari8 != "" {
+			cari8Set[cari8] = struct{}{}
+		}
+		curr := strings.ToUpper(strings.TrimSpace(asString(row["DocCurrencyCode"])))
+		if curr != "" && curr != "TRY" {
+			currencySet[curr] = struct{}{}
+		}
+		currencySet["USD"] = struct{}{}
+
+		result = append(result, row)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("rows error: %w", err)
+	}
+
+	cariDetailMap, err := loadAgingMasterCariDetailMap(context.Background(), cari8Set)
+	if err != nil {
+		return nil, err
+	}
+	rateSeriesByCurr, err := loadTryRateSeriesByCurrency(context.Background(), currencySet)
+	if err != nil {
+		return nil, err
+	}
+
+	for i := range result {
+		row := result[i]
+		cari8 := strings.TrimSpace(asString(row["Cari8"]))
+		curr := strings.ToUpper(strings.TrimSpace(asString(row["DocCurrencyCode"])))
+		if curr == "" {
+			curr = "TRY"
+		}
+		aciklama := strings.ToUpper(strings.TrimSpace(asString(row["Aciklama"])))
+		targetDate := endDate
+		if aciklama != "ACIKKALEM" {
+			if odemeTarihi, ok := parseDateOnly(asString(row["OdemeTarihi"])); ok {
+				targetDate = odemeTarihi
+			}
+		}
+
+		tutar := asFloat64(row["EslesenTutar"])
+		currTry := resolveTryRate(curr, targetDate, rateSeriesByCurr)
+		usdTry := resolveTryRate("USD", targetDate, rateSeriesByCurr)
+		tryTutar := toTRYByRate(tutar, curr, currTry)
+		usdTutar := toUSDByRates(tutar, curr, currTry, usdTry)
+		gunKur := usdRateInCurrency(curr, currTry, usdTry)
+
+		row["CariDetay"] = cariDetailMap[cari8]
+		row["UsdTutar"] = round2(usdTutar)
+		row["TryTutar"] = round2(tryTutar)
+		row["GunKur"] = round6(gunKur)
+	}
+
+	return result, nil
+}
+
+func resolveUseTypes(parislemler []string) (int, int) {
+	if len(parislemler) == 0 {
+		return 1, 0
+	}
+
+	useType2 := 0
+	useType3 := 0
+
+	for _, v := range parislemler {
+		switch strings.TrimSpace(v) {
+		case "2":
+			useType2 = 1
+		case "3":
+			useType3 = 1
+		}
+	}
+
+	if useType2 == 0 && useType3 == 0 {
+		return 1, 0
+	}
+
+	return useType2, useType3
+}
+
+func loadAgingMasterCariDetailMap(ctx context.Context, cari8Set map[string]struct{}) (map[string]string, error) {
+	if len(cari8Set) == 0 {
+		return map[string]string{}, nil
+	}
+
+	query := fmt.Sprintf(`
+WITH BaseCari AS (
+	SELECT
+		CurrAccCode,
+		CurrAccTypeCode,
+		MasterCari = LEFT(CurrAccCode, 8),
+		rn = ROW_NUMBER() OVER (
+			PARTITION BY LEFT(CurrAccCode, 8)
+			ORDER BY CurrAccCode
+		)
+	FROM cdCurrAcc WITH (NOLOCK)
+	WHERE CurrAccTypeCode IN (1,3)
+	  AND LEFT(CurrAccCode, 8) IN (%s)
+)
+SELECT
+	b.MasterCari,
+	CariDetay = ISNULL(d.CurrAccDescription, '')
+FROM BaseCari b
+LEFT JOIN cdCurrAccDesc d WITH (NOLOCK)
+	ON d.CurrAccTypeCode = b.CurrAccTypeCode
+   AND d.CurrAccCode = b.CurrAccCode
+   AND d.LangCode = 'TR'
+WHERE b.rn = 1;
+`, quotedInList(cari8Set))
+
+	rows, err := db.MssqlDB.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("aging cari detail query error: %w", err)
+	}
+	defer rows.Close()
+
+	out := make(map[string]string, len(cari8Set))
+	for rows.Next() {
+		var cari8 string
+		var detail sql.NullString
+		if err := rows.Scan(&cari8, &detail); err != nil {
+			return nil, err
+		}
+		out[strings.TrimSpace(cari8)] = strings.TrimSpace(detail.String)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func asString(v interface{}) string {
+	switch x := v.(type) {
+	case nil:
+		return ""
+	case string:
+		return x
+	case []byte:
+		return string(x)
+	default:
+		return fmt.Sprint(x)
+	}
+}
+
+func asFloat64(v interface{}) float64 {
+	switch x := v.(type) {
+	case nil:
+		return 0
+	case float64:
+		return x
+	case float32:
+		return float64(x)
+	case int64:
+		return float64(x)
+	case int32:
+		return float64(x)
+	case int:
+		return float64(x)
+	case string:
+		return parseNumberString(x)
+	case []byte:
+		return parseNumberString(string(x))
+	default:
+		return parseNumberString(fmt.Sprint(x))
+	}
+}
+
+func parseNumberString(s string) float64 {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return 0
+	}
+
+	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
+	}
+	return n
+}
+
+func round2(v float64) float64 {
+	return math.Round(v*100) / 100
+}
+
+func round6(v float64) float64 {
+	return math.Round(v*1_000_000) / 1_000_000
+}
+
+type ratePoint struct {
+	date time.Time
+	rate float64
+}
+
+func loadTryRateSeriesByCurrency(ctx context.Context, currencies map[string]struct{}) (map[string][]ratePoint, error) {
+	if len(currencies) == 0 {
+		return map[string][]ratePoint{}, nil
+	}
+
+	query := fmt.Sprintf(`
+SELECT CurrencyCode, Rate, CAST([Date] AS date) AS RateDate
+FROM AllExchangeRates
+WHERE RelationCurrencyCode = 'TRY'
+  AND ExchangeTypeCode = 6
+  AND Rate > 0
+  AND CurrencyCode IN (%s)
+`, quotedInList(currencies))
+
+	rows, err := db.MssqlDB.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("aging currency series query error: %w", err)
+	}
+	defer rows.Close()
+
+	out := make(map[string][]ratePoint, len(currencies))
+	for rows.Next() {
+		var code string
+		var rate float64
+		var dt time.Time
+		if err := rows.Scan(&code, &rate, &dt); err != nil {
+			return nil, err
+		}
+		code = strings.ToUpper(strings.TrimSpace(code))
+		out[code] = append(out[code], ratePoint{date: dt, rate: rate})
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	for c := range out {
+		sort.Slice(out[c], func(i, j int) bool { return out[c][i].date.Before(out[c][j].date) })
+	}
+	return out, nil
+}
+
+func resolveTryRate(currency string, target time.Time, series map[string][]ratePoint) float64 {
+	currency = strings.ToUpper(strings.TrimSpace(currency))
+	if currency == "" || currency == "TRY" {
+		return 1
+	}
+	points := series[currency]
+	if len(points) == 0 {
+		return 0
+	}
+
+	best := points[0]
+	bestDiff := absDurationDays(points[0].date.Sub(target))
+	for i := 1; i < len(points); i++ {
+		diff := absDurationDays(points[i].date.Sub(target))
+		if diff < bestDiff || (diff == bestDiff && points[i].date.After(best.date)) {
+			best = points[i]
+			bestDiff = diff
+		}
+	}
+	return best.rate
+}
+
+func absDurationDays(d time.Duration) int64 {
+	if d < 0 {
+		d = -d
+	}
+	return int64(d.Hours() / 24)
+}
+
+func parseDateOnly(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
+}
+
+func toTRYByRate(amount float64, currency string, currTry float64) float64 {
+	currency = strings.ToUpper(strings.TrimSpace(currency))
+	if currency == "" || currency == "TRY" {
+		return amount
+	}
+	if currTry <= 0 {
+		return 0
+	}
+	return amount * currTry
+}
+
+func toUSDByRates(amount float64, currency string, currTry, usdTry float64) float64 {
+	currency = strings.ToUpper(strings.TrimSpace(currency))
+	switch currency {
+	case "USD":
+		return amount
+	case "", "TRY":
+		if usdTry <= 0 {
+			return 0
+		}
+		return amount / usdTry
+	default:
+		if currTry <= 0 || usdTry <= 0 {
+			return 0
+		}
+		return (amount * currTry) / usdTry
+	}
+}
+
+// Returns X for "1 USD = X <currency>".
+func usdRateInCurrency(currency string, currTry, usdTry float64) float64 {
+	currency = strings.ToUpper(strings.TrimSpace(currency))
+	switch currency {
+	case "", "USD":
+		return 1
+	case "TRY":
+		if usdTry <= 0 {
+			return 0
+		}
+		return usdTry
+	default:
+		if currTry <= 0 || usdTry <= 0 {
+			return 0
+		}
+		return usdTry / currTry
+	}
+}