1129 lines
44 KiB
Go
1129 lines
44 KiB
Go
package queries
|
|
|
|
import (
|
|
"bssapp-backend/db"
|
|
"bssapp-backend/models"
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"log"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type ProductPerformanceFilters struct {
|
|
Search string
|
|
ProductCode string
|
|
MarketKey string
|
|
Kategori string
|
|
Seri string
|
|
Bucket string
|
|
SortBy string
|
|
Descending bool
|
|
Limit int
|
|
Page int
|
|
}
|
|
|
|
type ProductPerformanceRefreshRequest struct {
|
|
Mode string
|
|
Stage string
|
|
ResumeAfter int
|
|
SkipDelete bool
|
|
StartDate time.Time
|
|
EndDate time.Time
|
|
}
|
|
|
|
type ProductPerformanceRefreshResult struct {
|
|
Mode string `json:"mode"`
|
|
Stage string `json:"stage"`
|
|
StartDate string `json:"start_date"`
|
|
EndDate string `json:"end_date"`
|
|
SalesRows int `json:"sales_rows"`
|
|
StockRows int `json:"stock_rows"`
|
|
KpiRows int `json:"kpi_rows"`
|
|
DurationMS int64 `json:"duration_ms"`
|
|
}
|
|
|
|
func EnsureProductPerformanceTables(pg *sql.DB) error {
|
|
stmts := []string{
|
|
`
|
|
CREATE TABLE IF NOT EXISTS mk_product_performance_sales_daily (
|
|
sales_date DATE NOT NULL,
|
|
product_code TEXT NOT NULL,
|
|
color_code TEXT NOT NULL DEFAULT '',
|
|
yaka_kodu TEXT NOT NULL DEFAULT '',
|
|
item_description TEXT NOT NULL DEFAULT '',
|
|
kategori TEXT NOT NULL DEFAULT '',
|
|
seri TEXT NOT NULL DEFAULT '',
|
|
yas_grubu TEXT NOT NULL DEFAULT '',
|
|
askili_yan TEXT NOT NULL DEFAULT '',
|
|
urun_ilk_grubu TEXT NOT NULL DEFAULT '',
|
|
urun_ana_grubu TEXT NOT NULL DEFAULT '',
|
|
urun_alt_grubu TEXT NOT NULL DEFAULT '',
|
|
market_key TEXT NOT NULL DEFAULT '',
|
|
channel_code TEXT NOT NULL DEFAULT '',
|
|
customer_country TEXT NOT NULL DEFAULT '',
|
|
customer_segment TEXT NOT NULL DEFAULT '',
|
|
customer_code TEXT NOT NULL DEFAULT '',
|
|
customer_name TEXT NOT NULL DEFAULT '',
|
|
sales_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_tl NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_usd NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
avg_price_usd NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
invoice_line_count INTEGER NOT NULL DEFAULT 0,
|
|
invoice_count INTEGER NOT NULL DEFAULT 0,
|
|
customer_count INTEGER NOT NULL DEFAULT 0,
|
|
last_ref_number TEXT NOT NULL DEFAULT '',
|
|
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
|
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
|
CONSTRAINT pk_mk_product_performance_sales_daily PRIMARY KEY
|
|
(sales_date, product_code, color_code, yaka_kodu, market_key, customer_country, customer_segment, customer_code)
|
|
)`,
|
|
`ALTER TABLE mk_product_performance_sales_daily ADD COLUMN IF NOT EXISTS customer_code TEXT NOT NULL DEFAULT ''`,
|
|
`ALTER TABLE mk_product_performance_sales_daily ADD COLUMN IF NOT EXISTS customer_name TEXT NOT NULL DEFAULT ''`,
|
|
`ALTER TABLE mk_product_performance_sales_daily ADD COLUMN IF NOT EXISTS urun_ilk_grubu TEXT NOT NULL DEFAULT ''`,
|
|
`ALTER TABLE mk_product_performance_sales_daily ADD COLUMN IF NOT EXISTS urun_ana_grubu TEXT NOT NULL DEFAULT ''`,
|
|
`ALTER TABLE mk_product_performance_sales_daily ADD COLUMN IF NOT EXISTS urun_alt_grubu TEXT NOT NULL DEFAULT ''`,
|
|
`
|
|
DO $$
|
|
BEGIN
|
|
IF EXISTS (
|
|
SELECT 1
|
|
FROM pg_constraint
|
|
WHERE conname = 'pk_mk_product_performance_sales_daily'
|
|
AND conrelid = 'mk_product_performance_sales_daily'::regclass
|
|
) THEN
|
|
ALTER TABLE mk_product_performance_sales_daily DROP CONSTRAINT pk_mk_product_performance_sales_daily;
|
|
END IF;
|
|
ALTER TABLE mk_product_performance_sales_daily
|
|
ADD CONSTRAINT pk_mk_product_performance_sales_daily PRIMARY KEY
|
|
(sales_date, product_code, color_code, yaka_kodu, market_key, customer_country, customer_segment, customer_code);
|
|
END $$`,
|
|
`CREATE INDEX IF NOT EXISTS ix_mk_product_perf_sales_product_date ON mk_product_performance_sales_daily (product_code, sales_date DESC)`,
|
|
`CREATE INDEX IF NOT EXISTS ix_mk_product_perf_sales_market ON mk_product_performance_sales_daily (market_key, sales_date DESC)`,
|
|
`CREATE INDEX IF NOT EXISTS ix_mk_product_perf_sales_customer ON mk_product_performance_sales_daily (customer_code, sales_date DESC)`,
|
|
`
|
|
CREATE TABLE IF NOT EXISTS mk_product_performance_stock_daily (
|
|
stock_date DATE NOT NULL,
|
|
product_code TEXT NOT NULL,
|
|
color_code TEXT NOT NULL DEFAULT '',
|
|
yaka_kodu TEXT NOT NULL DEFAULT '',
|
|
stock_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
in_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
out_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
kpi_in_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
kpi_out_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_movement_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
production_in_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
purchase_in_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
consumption_out_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
count_diff_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
|
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
|
CONSTRAINT pk_mk_product_performance_stock_daily PRIMARY KEY
|
|
(stock_date, product_code, color_code, yaka_kodu)
|
|
)`,
|
|
`CREATE INDEX IF NOT EXISTS ix_mk_product_perf_stock_product_date ON mk_product_performance_stock_daily (product_code, stock_date DESC)`,
|
|
`
|
|
CREATE TABLE IF NOT EXISTS mk_product_performance_price_dim (
|
|
product_code TEXT PRIMARY KEY,
|
|
cost_price_usd NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
base_price_usd NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
base_price_try NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
last_pricing_date DATE,
|
|
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
|
)`,
|
|
`
|
|
CREATE TABLE IF NOT EXISTS mk_product_performance_kpi_daily (
|
|
kpi_date DATE NOT NULL,
|
|
product_code TEXT NOT NULL,
|
|
color_code TEXT NOT NULL DEFAULT '',
|
|
yaka_kodu TEXT NOT NULL DEFAULT '',
|
|
item_description TEXT NOT NULL DEFAULT '',
|
|
kategori TEXT NOT NULL DEFAULT '',
|
|
seri TEXT NOT NULL DEFAULT '',
|
|
yas_grubu TEXT NOT NULL DEFAULT '',
|
|
askili_yan TEXT NOT NULL DEFAULT '',
|
|
urun_ilk_grubu TEXT NOT NULL DEFAULT '',
|
|
urun_ana_grubu TEXT NOT NULL DEFAULT '',
|
|
urun_alt_grubu TEXT NOT NULL DEFAULT '',
|
|
market_key TEXT NOT NULL DEFAULT '',
|
|
stock_qty NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_qty_30d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_qty_90d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_qty_180d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_qty_365d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_qty_730d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_usd_30d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_usd_90d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_usd_180d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
sales_usd_365d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
avg_daily_sales_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
avg_daily_sales_180d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
stock_days_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
stock_days_180d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
avg_price_usd_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
avg_price_usd_180d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
cost_price_usd NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
base_price_usd NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
base_price_try NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
gross_profit_usd_90d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
gross_profit_usd_180d NUMERIC(18,4) NOT NULL DEFAULT 0,
|
|
gross_margin_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
gross_margin_180d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
unit_profit_cost_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
unit_profit_cost_180d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
unit_profit_base_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
unit_profit_base_180d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
market_count_90d INTEGER NOT NULL DEFAULT 0,
|
|
customer_count_90d INTEGER NOT NULL DEFAULT 0,
|
|
sales_index_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
price_index_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
margin_index_90d NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
performance_score NUMERIC(18,6) NOT NULL DEFAULT 0,
|
|
performance_bucket TEXT NOT NULL DEFAULT '',
|
|
recommendation TEXT NOT NULL DEFAULT '',
|
|
last_sale_date DATE,
|
|
last_ref_number TEXT NOT NULL DEFAULT '',
|
|
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
|
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
|
CONSTRAINT pk_mk_product_performance_kpi_daily PRIMARY KEY
|
|
(kpi_date, product_code, color_code, yaka_kodu, market_key)
|
|
)`,
|
|
`CREATE INDEX IF NOT EXISTS ix_mk_product_perf_kpi_bucket ON mk_product_performance_kpi_daily (kpi_date DESC, performance_bucket)`,
|
|
`CREATE INDEX IF NOT EXISTS ix_mk_product_perf_kpi_market ON mk_product_performance_kpi_daily (kpi_date DESC, market_key, sales_index_90d DESC)`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS urun_ilk_grubu TEXT NOT NULL DEFAULT ''`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS urun_ana_grubu TEXT NOT NULL DEFAULT ''`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS urun_alt_grubu TEXT NOT NULL DEFAULT ''`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS sales_qty_180d NUMERIC(18,4) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS sales_usd_180d NUMERIC(18,4) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS avg_daily_sales_180d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS stock_days_180d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS avg_price_usd_180d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS gross_profit_usd_180d NUMERIC(18,4) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS gross_margin_180d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS unit_profit_cost_90d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS unit_profit_cost_180d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS unit_profit_base_90d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS unit_profit_base_180d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
|
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS market_count_90d INTEGER NOT NULL DEFAULT 0`,
|
|
}
|
|
for _, stmt := range stmts {
|
|
if _, err := pg.Exec(stmt); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func RefreshProductPerformance(ctx context.Context, pg *sql.DB, req ProductPerformanceRefreshRequest) (ProductPerformanceRefreshResult, error) {
|
|
started := time.Now()
|
|
stage := productPerformanceRefreshStage(req.Stage)
|
|
log.Printf("[ProductPerformanceRefresh] start mode=%s stage=%s start=%s end=%s", req.Mode, stage, req.StartDate.Format("2006-01-02"), req.EndDate.Format("2006-01-02"))
|
|
if pg == nil {
|
|
return ProductPerformanceRefreshResult{}, fmt.Errorf("postgres db nil")
|
|
}
|
|
if db.MssqlDB == nil {
|
|
return ProductPerformanceRefreshResult{}, fmt.Errorf("mssql db nil")
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] ensure tables start")
|
|
if err := EnsureProductPerformanceTables(pg); err != nil {
|
|
return ProductPerformanceRefreshResult{}, err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] ensure tables done")
|
|
mode := strings.ToLower(strings.TrimSpace(req.Mode))
|
|
if mode == "" {
|
|
mode = "delta"
|
|
}
|
|
if req.EndDate.IsZero() {
|
|
req.EndDate = time.Now()
|
|
}
|
|
if req.StartDate.IsZero() {
|
|
if mode == "full" {
|
|
req.StartDate = time.Date(2022, 1, 1, 0, 0, 0, 0, req.EndDate.Location())
|
|
} else {
|
|
req.StartDate = req.EndDate.AddDate(0, 0, -45)
|
|
}
|
|
}
|
|
req.StartDate = dateOnly(req.StartDate)
|
|
req.EndDate = dateOnly(req.EndDate)
|
|
shouldRun := func(name string) bool {
|
|
if stage == "all" {
|
|
return true
|
|
}
|
|
order := map[string]int{
|
|
"sales": 1,
|
|
"stock": 2,
|
|
"price": 3,
|
|
"kpi": 4,
|
|
}
|
|
return order[name] >= order[stage]
|
|
}
|
|
|
|
runStage := func(stage string, fn func(*sql.Tx) error) error {
|
|
log.Printf("[ProductPerformanceRefresh] %s tx begin", stage)
|
|
tx, err := pg.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if err := fn(tx); err != nil {
|
|
return err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] %s tx commit start", stage)
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] %s tx commit done elapsed=%s", stage, time.Since(started).Round(time.Second))
|
|
return nil
|
|
}
|
|
|
|
var salesRows int
|
|
if shouldRun("sales") {
|
|
if err := runStage("sales", func(tx *sql.Tx) error {
|
|
log.Printf("[ProductPerformanceRefresh] delete sales cache start")
|
|
if _, err := tx.ExecContext(ctx, `DELETE FROM mk_product_performance_sales_daily WHERE sales_date BETWEEN $1 AND $2`, req.StartDate, req.EndDate); err != nil {
|
|
return err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] delete sales cache done")
|
|
log.Printf("[ProductPerformanceRefresh] sales refresh start")
|
|
rows, err := refreshProductPerformanceSales(ctx, tx, req.StartDate, req.EndDate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
salesRows = rows
|
|
log.Printf("[ProductPerformanceRefresh] sales refresh done rows=%d elapsed=%s", salesRows, time.Since(started).Round(time.Second))
|
|
return nil
|
|
}); err != nil {
|
|
return ProductPerformanceRefreshResult{}, err
|
|
}
|
|
} else {
|
|
log.Printf("[ProductPerformanceRefresh] sales skipped stage=%s", stage)
|
|
}
|
|
|
|
var stockRows int
|
|
if shouldRun("stock") {
|
|
rows, err := refreshProductPerformanceStockChunked(ctx, pg, req.StartDate, req.EndDate, started, req.SkipDelete || req.ResumeAfter > 0, req.ResumeAfter)
|
|
if err != nil {
|
|
return ProductPerformanceRefreshResult{}, err
|
|
}
|
|
stockRows = rows
|
|
} else {
|
|
log.Printf("[ProductPerformanceRefresh] stock skipped stage=%s", stage)
|
|
}
|
|
|
|
if shouldRun("price") {
|
|
if err := runStage("price", func(tx *sql.Tx) error {
|
|
log.Printf("[ProductPerformanceRefresh] price refresh start")
|
|
if err := refreshProductPerformancePrices(ctx, tx); err != nil {
|
|
return err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] price refresh done elapsed=%s", time.Since(started).Round(time.Second))
|
|
return nil
|
|
}); err != nil {
|
|
return ProductPerformanceRefreshResult{}, err
|
|
}
|
|
} else {
|
|
log.Printf("[ProductPerformanceRefresh] price skipped stage=%s", stage)
|
|
}
|
|
|
|
var kpiRows int
|
|
if shouldRun("kpi") {
|
|
if err := runStage("kpi", func(tx *sql.Tx) error {
|
|
log.Printf("[ProductPerformanceRefresh] kpi rebuild start")
|
|
rows, err := RebuildProductPerformanceKPI(ctx, tx, req.EndDate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
kpiRows = rows
|
|
log.Printf("[ProductPerformanceRefresh] kpi rebuild done rows=%d elapsed=%s", kpiRows, time.Since(started).Round(time.Second))
|
|
return nil
|
|
}); err != nil {
|
|
return ProductPerformanceRefreshResult{}, err
|
|
}
|
|
} else {
|
|
log.Printf("[ProductPerformanceRefresh] kpi skipped stage=%s", stage)
|
|
}
|
|
|
|
log.Printf("[ProductPerformanceRefresh] refresh done total_elapsed=%s", time.Since(started).Round(time.Second))
|
|
return ProductPerformanceRefreshResult{
|
|
Mode: mode,
|
|
Stage: stage,
|
|
StartDate: req.StartDate.Format("2006-01-02"),
|
|
EndDate: req.EndDate.Format("2006-01-02"),
|
|
SalesRows: salesRows,
|
|
StockRows: stockRows,
|
|
KpiRows: kpiRows,
|
|
DurationMS: time.Since(started).Milliseconds(),
|
|
}, nil
|
|
}
|
|
|
|
func productPerformanceRefreshStage(raw string) string {
|
|
switch strings.ToLower(strings.TrimSpace(raw)) {
|
|
case "", "all", "full":
|
|
return "all"
|
|
case "sales", "stock", "price", "kpi":
|
|
return strings.ToLower(strings.TrimSpace(raw))
|
|
default:
|
|
return "all"
|
|
}
|
|
}
|
|
|
|
func refreshProductPerformanceSales(ctx context.Context, tx *sql.Tx, startDate, endDate time.Time) (int, error) {
|
|
log.Printf("[ProductPerformanceRefresh] sales mssql query start start=%s end=%s", startDate.Format("2006-01-02"), endDate.Format("2006-01-02"))
|
|
rows, err := db.MssqlDB.QueryContext(ctx, productPerformanceSalesSQL(), startDate, endDate)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer rows.Close()
|
|
log.Printf("[ProductPerformanceRefresh] sales mssql query returned, postgres insert start")
|
|
count := 0
|
|
for rows.Next() {
|
|
var r productPerformanceSalesDaily
|
|
if err := rows.Scan(
|
|
&r.SalesDate, &r.ProductCode, &r.ColorCode, &r.YakaKodu, &r.ItemDescription,
|
|
&r.Kategori, &r.Seri, &r.YasGrubu, &r.AskiliYan, &r.UrunIlkGrubu, &r.UrunAnaGrubu, &r.UrunAltGrubu, &r.MarketKey, &r.ChannelCode,
|
|
&r.CustomerCountry, &r.CustomerSegment, &r.CustomerCode, &r.CustomerName, &r.SalesQty, &r.SalesTL, &r.SalesUSD,
|
|
&r.AvgPriceUSD, &r.InvoiceLineCount, &r.InvoiceCount, &r.CustomerCount, &r.LastRefNumber,
|
|
); err != nil {
|
|
return count, err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
INSERT INTO mk_product_performance_sales_daily (
|
|
sales_date, product_code, color_code, yaka_kodu, item_description,
|
|
kategori, seri, yas_grubu, askili_yan, urun_ilk_grubu, urun_ana_grubu, urun_alt_grubu, market_key, channel_code,
|
|
customer_country, customer_segment, customer_code, customer_name, sales_qty, sales_tl, sales_usd,
|
|
avg_price_usd, invoice_line_count, invoice_count, customer_count, last_ref_number, updated_at
|
|
) VALUES (
|
|
$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,now()
|
|
)
|
|
ON CONFLICT (sales_date, product_code, color_code, yaka_kodu, market_key, customer_country, customer_segment, customer_code)
|
|
DO UPDATE SET
|
|
item_description=EXCLUDED.item_description,
|
|
kategori=EXCLUDED.kategori,
|
|
seri=EXCLUDED.seri,
|
|
yas_grubu=EXCLUDED.yas_grubu,
|
|
askili_yan=EXCLUDED.askili_yan,
|
|
urun_ilk_grubu=EXCLUDED.urun_ilk_grubu,
|
|
urun_ana_grubu=EXCLUDED.urun_ana_grubu,
|
|
urun_alt_grubu=EXCLUDED.urun_alt_grubu,
|
|
channel_code=EXCLUDED.channel_code,
|
|
customer_name=EXCLUDED.customer_name,
|
|
sales_qty=EXCLUDED.sales_qty,
|
|
sales_tl=EXCLUDED.sales_tl,
|
|
sales_usd=EXCLUDED.sales_usd,
|
|
avg_price_usd=EXCLUDED.avg_price_usd,
|
|
invoice_line_count=EXCLUDED.invoice_line_count,
|
|
invoice_count=EXCLUDED.invoice_count,
|
|
customer_count=EXCLUDED.customer_count,
|
|
last_ref_number=EXCLUDED.last_ref_number,
|
|
updated_at=now()
|
|
`, r.SalesDate, r.ProductCode, r.ColorCode, r.YakaKodu, r.ItemDescription,
|
|
r.Kategori, r.Seri, r.YasGrubu, r.AskiliYan, r.UrunIlkGrubu, r.UrunAnaGrubu, r.UrunAltGrubu, r.MarketKey, r.ChannelCode,
|
|
r.CustomerCountry, r.CustomerSegment, r.CustomerCode, r.CustomerName, r.SalesQty, r.SalesTL, r.SalesUSD,
|
|
r.AvgPriceUSD, r.InvoiceLineCount, r.InvoiceCount, r.CustomerCount, r.LastRefNumber); err != nil {
|
|
return count, err
|
|
}
|
|
count++
|
|
if count%5000 == 0 {
|
|
log.Printf("[ProductPerformanceRefresh] sales inserted rows=%d", count)
|
|
}
|
|
}
|
|
return count, rows.Err()
|
|
}
|
|
|
|
func refreshProductPerformanceStock(ctx context.Context, tx *sql.Tx, startDate, endDate time.Time) (int, error) {
|
|
log.Printf("[ProductPerformanceRefresh] stock mssql query start start=%s end=%s", startDate.Format("2006-01-02"), endDate.Format("2006-01-02"))
|
|
rows, err := db.MssqlDB.QueryContext(ctx, productPerformanceStockSQL(), startDate, endDate)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer rows.Close()
|
|
log.Printf("[ProductPerformanceRefresh] stock mssql query returned, postgres insert start")
|
|
count := 0
|
|
for rows.Next() {
|
|
var r productPerformanceStockDaily
|
|
if err := rows.Scan(
|
|
&r.StockDate, &r.ProductCode, &r.ColorCode, &r.YakaKodu, &r.StockQty,
|
|
&r.InQty, &r.OutQty, &r.KpiInQty, &r.KpiOutQty, &r.SalesMovementQty,
|
|
&r.ProductionInQty, &r.PurchaseInQty, &r.ConsumptionOutQty, &r.CountDiffQty,
|
|
); err != nil {
|
|
return count, err
|
|
}
|
|
if err := insertProductPerformanceStock(ctx, tx, r); err != nil {
|
|
return count, err
|
|
}
|
|
count++
|
|
if count%5000 == 0 {
|
|
log.Printf("[ProductPerformanceRefresh] stock inserted rows=%d", count)
|
|
}
|
|
}
|
|
return count, rows.Err()
|
|
}
|
|
|
|
func refreshProductPerformanceStockChunked(ctx context.Context, pg *sql.DB, startDate, endDate, started time.Time, skipDelete bool, resumeAfter int) (int, error) {
|
|
if skipDelete {
|
|
log.Printf("[ProductPerformanceRefresh] stock delete skipped resume_after=%d", resumeAfter)
|
|
} else {
|
|
log.Printf("[ProductPerformanceRefresh] stock delete tx begin")
|
|
deleteTx, err := pg.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer deleteTx.Rollback()
|
|
log.Printf("[ProductPerformanceRefresh] delete stock cache start")
|
|
if _, err := deleteTx.ExecContext(ctx, `DELETE FROM mk_product_performance_stock_daily WHERE stock_date BETWEEN $1 AND $2`, startDate, endDate); err != nil {
|
|
return 0, err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] delete stock cache done")
|
|
log.Printf("[ProductPerformanceRefresh] stock delete tx commit start")
|
|
if err := deleteTx.Commit(); err != nil {
|
|
return 0, err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] stock delete tx commit done elapsed=%s", time.Since(started).Round(time.Second))
|
|
}
|
|
|
|
log.Printf("[ProductPerformanceRefresh] stock refresh start")
|
|
log.Printf("[ProductPerformanceRefresh] stock mssql query start start=%s end=%s", startDate.Format("2006-01-02"), endDate.Format("2006-01-02"))
|
|
rows, err := db.MssqlDB.QueryContext(ctx, productPerformanceStockSQL(), startDate, endDate)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer rows.Close()
|
|
log.Printf("[ProductPerformanceRefresh] stock mssql query returned, postgres chunk insert start")
|
|
|
|
const chunkSize = 5000
|
|
count := 0
|
|
seen := 0
|
|
chunkRows := 0
|
|
tx, err := pg.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer tx.Rollback()
|
|
|
|
for rows.Next() {
|
|
var r productPerformanceStockDaily
|
|
if err := rows.Scan(
|
|
&r.StockDate, &r.ProductCode, &r.ColorCode, &r.YakaKodu, &r.StockQty,
|
|
&r.InQty, &r.OutQty, &r.KpiInQty, &r.KpiOutQty, &r.SalesMovementQty,
|
|
&r.ProductionInQty, &r.PurchaseInQty, &r.ConsumptionOutQty, &r.CountDiffQty,
|
|
); err != nil {
|
|
return count, err
|
|
}
|
|
seen++
|
|
if resumeAfter > 0 && seen <= resumeAfter {
|
|
if seen%50000 == 0 || seen == resumeAfter {
|
|
log.Printf("[ProductPerformanceRefresh] stock resume skipped rows=%d", seen)
|
|
}
|
|
continue
|
|
}
|
|
if err := insertProductPerformanceStock(ctx, tx, r); err != nil {
|
|
return count, err
|
|
}
|
|
count++
|
|
chunkRows++
|
|
if chunkRows >= chunkSize {
|
|
log.Printf("[ProductPerformanceRefresh] stock chunk commit start inserted_rows=%d scanned_rows=%d", count, seen)
|
|
if err := tx.Commit(); err != nil {
|
|
return count, err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] stock chunk commit done inserted_rows=%d scanned_rows=%d elapsed=%s", count, seen, time.Since(started).Round(time.Second))
|
|
tx, err = pg.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return count, err
|
|
}
|
|
chunkRows = 0
|
|
}
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return count, err
|
|
}
|
|
if chunkRows > 0 {
|
|
log.Printf("[ProductPerformanceRefresh] stock final chunk commit start inserted_rows=%d scanned_rows=%d", count, seen)
|
|
if err := tx.Commit(); err != nil {
|
|
return count, err
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] stock final chunk commit done inserted_rows=%d scanned_rows=%d elapsed=%s", count, seen, time.Since(started).Round(time.Second))
|
|
} else {
|
|
_ = tx.Rollback()
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] stock refresh done inserted_rows=%d scanned_rows=%d elapsed=%s", count, seen, time.Since(started).Round(time.Second))
|
|
return count, nil
|
|
}
|
|
|
|
type productPerformanceStockExec interface {
|
|
ExecContext(context.Context, string, ...any) (sql.Result, error)
|
|
}
|
|
|
|
func insertProductPerformanceStock(ctx context.Context, exec productPerformanceStockExec, r productPerformanceStockDaily) error {
|
|
_, err := exec.ExecContext(ctx, `
|
|
INSERT INTO mk_product_performance_stock_daily (
|
|
stock_date, product_code, color_code, yaka_kodu, stock_qty, in_qty, out_qty,
|
|
kpi_in_qty, kpi_out_qty, sales_movement_qty, production_in_qty, purchase_in_qty,
|
|
consumption_out_qty, count_diff_qty, updated_at
|
|
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,now())
|
|
ON CONFLICT (stock_date, product_code, color_code, yaka_kodu)
|
|
DO UPDATE SET
|
|
stock_qty=EXCLUDED.stock_qty,
|
|
in_qty=EXCLUDED.in_qty,
|
|
out_qty=EXCLUDED.out_qty,
|
|
kpi_in_qty=EXCLUDED.kpi_in_qty,
|
|
kpi_out_qty=EXCLUDED.kpi_out_qty,
|
|
sales_movement_qty=EXCLUDED.sales_movement_qty,
|
|
production_in_qty=EXCLUDED.production_in_qty,
|
|
purchase_in_qty=EXCLUDED.purchase_in_qty,
|
|
consumption_out_qty=EXCLUDED.consumption_out_qty,
|
|
count_diff_qty=EXCLUDED.count_diff_qty,
|
|
updated_at=now()
|
|
`, r.StockDate, r.ProductCode, r.ColorCode, r.YakaKodu, r.StockQty,
|
|
r.InQty, r.OutQty, r.KpiInQty, r.KpiOutQty, r.SalesMovementQty,
|
|
r.ProductionInQty, r.PurchaseInQty, r.ConsumptionOutQty, r.CountDiffQty)
|
|
return err
|
|
}
|
|
|
|
func refreshProductPerformancePrices(ctx context.Context, tx *sql.Tx) error {
|
|
log.Printf("[ProductPerformanceRefresh] price mssql query start")
|
|
rows, err := db.MssqlDB.QueryContext(ctx, productPerformancePriceSQL())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
log.Printf("[ProductPerformanceRefresh] price mssql query returned, postgres upsert start")
|
|
count := 0
|
|
for rows.Next() {
|
|
var code string
|
|
var cost, usd, tryPrice float64
|
|
var lastPricing sql.NullTime
|
|
if err := rows.Scan(&code, &cost, &usd, &tryPrice, &lastPricing); err != nil {
|
|
return err
|
|
}
|
|
var lp any
|
|
if lastPricing.Valid {
|
|
lp = lastPricing.Time
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
INSERT INTO mk_product_performance_price_dim (product_code, cost_price_usd, base_price_usd, base_price_try, last_pricing_date, updated_at)
|
|
VALUES ($1,$2,$3,$4,$5,now())
|
|
ON CONFLICT (product_code) DO UPDATE SET
|
|
cost_price_usd=EXCLUDED.cost_price_usd,
|
|
base_price_usd=EXCLUDED.base_price_usd,
|
|
base_price_try=EXCLUDED.base_price_try,
|
|
last_pricing_date=EXCLUDED.last_pricing_date,
|
|
updated_at=now()
|
|
`, strings.TrimSpace(code), cost, usd, tryPrice, lp); err != nil {
|
|
return err
|
|
}
|
|
count++
|
|
if count%5000 == 0 {
|
|
log.Printf("[ProductPerformanceRefresh] price upserted rows=%d", count)
|
|
}
|
|
}
|
|
log.Printf("[ProductPerformanceRefresh] price upsert done rows=%d", count)
|
|
return rows.Err()
|
|
}
|
|
|
|
func RebuildProductPerformanceKPI(ctx context.Context, exec interface {
|
|
ExecContext(context.Context, string, ...any) (sql.Result, error)
|
|
}, kpiDate time.Time) (int, error) {
|
|
kpiDate = dateOnly(kpiDate)
|
|
if _, err := exec.ExecContext(ctx, `DELETE FROM mk_product_performance_kpi_daily WHERE kpi_date=$1`, kpiDate); err != nil {
|
|
return 0, err
|
|
}
|
|
res, err := exec.ExecContext(ctx, productPerformanceKPISQL(), kpiDate)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
n, _ := res.RowsAffected()
|
|
return int(n), nil
|
|
}
|
|
|
|
func ListProductPerformance(ctx context.Context, pg *sql.DB, f ProductPerformanceFilters) ([]models.ProductPerformanceRow, int, error) {
|
|
if err := EnsureProductPerformanceTables(pg); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
limit := f.Limit
|
|
if limit <= 0 || limit > 500 {
|
|
limit = 100
|
|
}
|
|
page := f.Page
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
where, args := productPerformanceWhere(f)
|
|
countQuery := `SELECT COUNT(*) FROM mk_product_performance_kpi_daily WHERE kpi_date = (SELECT MAX(kpi_date) FROM mk_product_performance_kpi_daily)` + where
|
|
var total int
|
|
if err := pg.QueryRowContext(ctx, countQuery, args...).Scan(&total); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
args = append(args, limit, (page-1)*limit)
|
|
orderBy := productPerformanceOrderBy(f.SortBy, f.Descending)
|
|
rows, err := pg.QueryContext(ctx, `
|
|
SELECT
|
|
to_char(kpi_date,'YYYY-MM-DD'), product_code, color_code, yaka_kodu, item_description,
|
|
kategori, seri, yas_grubu, askili_yan, urun_ilk_grubu, urun_ana_grubu, urun_alt_grubu, market_key, stock_qty,
|
|
sales_qty_30d, sales_qty_90d, sales_qty_180d, sales_qty_365d, sales_qty_730d,
|
|
sales_usd_30d, sales_usd_90d, sales_usd_180d, sales_usd_365d, avg_daily_sales_90d, avg_daily_sales_180d,
|
|
stock_days_90d, stock_days_180d, avg_price_usd_90d, avg_price_usd_180d, cost_price_usd, base_price_usd, base_price_try,
|
|
gross_profit_usd_90d, gross_profit_usd_180d, gross_margin_90d, gross_margin_180d,
|
|
unit_profit_cost_90d, unit_profit_cost_180d, unit_profit_base_90d, unit_profit_base_180d, market_count_90d, customer_count_90d, sales_index_90d,
|
|
price_index_90d, margin_index_90d, performance_score, performance_bucket,
|
|
recommendation, COALESCE(to_char(last_sale_date,'YYYY-MM-DD'),''), last_ref_number,
|
|
to_char(updated_at,'YYYY-MM-DD HH24:MI:SS')
|
|
FROM mk_product_performance_kpi_daily
|
|
WHERE kpi_date = (SELECT MAX(kpi_date) FROM mk_product_performance_kpi_daily)`+where+`
|
|
ORDER BY `+orderBy+`
|
|
LIMIT $`+fmt.Sprint(len(args)-1)+` OFFSET $`+fmt.Sprint(len(args)), args...)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
defer rows.Close()
|
|
out := make([]models.ProductPerformanceRow, 0, limit)
|
|
for rows.Next() {
|
|
var r models.ProductPerformanceRow
|
|
if err := rows.Scan(
|
|
&r.KpiDate, &r.ProductCode, &r.ColorCode, &r.YakaKodu, &r.ItemDescription,
|
|
&r.Kategori, &r.Seri, &r.YasGrubu, &r.AskiliYan, &r.UrunIlkGrubu, &r.UrunAnaGrubu, &r.UrunAltGrubu, &r.MarketKey, &r.StockQty,
|
|
&r.SalesQty30, &r.SalesQty90, &r.SalesQty180, &r.SalesQty365, &r.SalesQty730,
|
|
&r.SalesUSD30, &r.SalesUSD90, &r.SalesUSD180, &r.SalesUSD365, &r.AvgDailySales90, &r.AvgDailySales180,
|
|
&r.StockDays90, &r.StockDays180, &r.AvgPriceUSD90, &r.AvgPriceUSD180, &r.CostPriceUSD, &r.BasePriceUSD, &r.BasePriceTRY,
|
|
&r.GrossProfitUSD90, &r.GrossProfitUSD180, &r.GrossMargin90, &r.GrossMargin180,
|
|
&r.UnitProfitCost90, &r.UnitProfitCost180, &r.UnitProfitBase90, &r.UnitProfitBase180, &r.MarketCount90, &r.CustomerCount90, &r.SalesIndex90,
|
|
&r.PriceIndex90, &r.MarginIndex90, &r.PerformanceScore, &r.PerformanceBucket,
|
|
&r.Recommendation, &r.LastSaleDate, &r.LastRefNumber, &r.UpdatedAt,
|
|
); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, total, rows.Err()
|
|
}
|
|
|
|
func GetProductPerformanceSummary(ctx context.Context, pg *sql.DB) (models.ProductPerformanceSummary, error) {
|
|
if err := EnsureProductPerformanceTables(pg); err != nil {
|
|
return models.ProductPerformanceSummary{}, err
|
|
}
|
|
var s models.ProductPerformanceSummary
|
|
err := pg.QueryRowContext(ctx, `
|
|
WITH Latest AS (
|
|
SELECT MAX(kpi_date) AS kpi_date
|
|
FROM mk_product_performance_kpi_daily
|
|
),
|
|
KPI AS (
|
|
SELECT *
|
|
FROM mk_product_performance_kpi_daily
|
|
WHERE kpi_date = (SELECT kpi_date FROM Latest)
|
|
),
|
|
Sales90 AS (
|
|
SELECT
|
|
COUNT(DISTINCT market_key) AS market_count_90d,
|
|
COUNT(DISTINCT NULLIF(customer_code, '-')) AS customer_count_90d
|
|
FROM mk_product_performance_sales_daily
|
|
WHERE sales_date BETWEEN (SELECT kpi_date FROM Latest) - INTERVAL '89 days' AND (SELECT kpi_date FROM Latest)
|
|
)
|
|
SELECT
|
|
COALESCE(to_char(MAX(kpi_date),'YYYY-MM-DD'),''),
|
|
COUNT(*),
|
|
COUNT(*) FILTER (WHERE performance_bucket='YILDIZ_URUN'),
|
|
COUNT(*) FILTER (WHERE performance_bucket='STOK_RISKI'),
|
|
COUNT(*) FILTER (WHERE performance_bucket='STOKSUZ_TALEP'),
|
|
COALESCE(SUM(stock_qty),0),
|
|
COALESCE(SUM(stock_qty * cost_price_usd),0),
|
|
COALESCE(SUM(CASE WHEN performance_bucket IN ('STOK_RISKI','TAKIP') AND COALESCE(sales_qty_90d,0)=0 THEN stock_qty * cost_price_usd ELSE 0 END),0),
|
|
COALESCE(SUM(sales_qty_90d),0),
|
|
COALESCE(SUM(sales_usd_90d),0),
|
|
COALESCE(SUM(gross_profit_usd_90d),0),
|
|
COALESCE(MAX(Sales90.market_count_90d),0)::integer,
|
|
COALESCE(MAX(Sales90.customer_count_90d),0)::integer,
|
|
COALESCE(to_char(MAX(updated_at),'YYYY-MM-DD HH24:MI:SS'),'')
|
|
FROM KPI
|
|
CROSS JOIN Sales90
|
|
`).Scan(&s.KpiDate, &s.TotalRows, &s.StarCount, &s.StockRisk, &s.NoStockDemand, &s.TotalStock, &s.StockCostUSD, &s.RiskCostUSD, &s.SalesQty90, &s.SalesUSD90, &s.GrossProfit90, &s.MarketCount90, &s.CustomerCount90, &s.UpdatedAt)
|
|
return s, err
|
|
}
|
|
|
|
func ListProductPerformanceMarkets(ctx context.Context, pg *sql.DB, limit int) ([]models.ProductPerformanceMarketRow, error) {
|
|
if err := EnsureProductPerformanceTables(pg); err != nil {
|
|
return nil, err
|
|
}
|
|
if limit <= 0 || limit > 500 {
|
|
limit = 100
|
|
}
|
|
rows, err := pg.QueryContext(ctx, `
|
|
SELECT
|
|
market_key,
|
|
MAX(kategori) AS kategori,
|
|
MAX(seri) AS seri,
|
|
MAX(yas_grubu) AS yas_grubu,
|
|
MAX(askili_yan) AS askili_yan,
|
|
MAX(urun_ilk_grubu) AS urun_ilk_grubu,
|
|
MAX(urun_ana_grubu) AS urun_ana_grubu,
|
|
MAX(urun_alt_grubu) AS urun_alt_grubu,
|
|
COUNT(DISTINCT product_code) AS product_count,
|
|
COUNT(*) FILTER (WHERE performance_bucket='YILDIZ_URUN') AS star_count,
|
|
COUNT(*) FILTER (WHERE performance_bucket='STOK_RISKI') AS stock_risk_count,
|
|
COALESCE(SUM(stock_qty),0) AS stock_qty,
|
|
COALESCE(SUM(stock_qty * cost_price_usd),0) AS stock_cost_value_usd,
|
|
COALESCE(SUM(CASE WHEN performance_bucket IN ('STOK_RISKI','TAKIP') AND COALESCE(sales_qty_90d,0)=0 THEN stock_qty * cost_price_usd ELSE 0 END),0) AS risk_stock_cost_value_usd,
|
|
COALESCE(SUM(sales_qty_90d),0) AS sales_qty_90d,
|
|
COALESCE(SUM(sales_usd_90d),0) AS sales_usd_90d,
|
|
COALESCE(SUM(gross_profit_usd_90d),0) AS gross_profit_usd_90d,
|
|
COALESCE(AVG(NULLIF(gross_margin_90d,0)),0) AS avg_gross_margin_90d,
|
|
COALESCE(AVG(NULLIF(stock_days_90d,0)),0) AS avg_stock_days_90d
|
|
FROM mk_product_performance_kpi_daily
|
|
WHERE kpi_date = (SELECT MAX(kpi_date) FROM mk_product_performance_kpi_daily)
|
|
GROUP BY market_key
|
|
ORDER BY risk_stock_cost_value_usd DESC, stock_cost_value_usd DESC, sales_usd_90d DESC
|
|
LIMIT $1
|
|
`, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := make([]models.ProductPerformanceMarketRow, 0, limit)
|
|
for rows.Next() {
|
|
var r models.ProductPerformanceMarketRow
|
|
if err := rows.Scan(
|
|
&r.MarketKey, &r.Kategori, &r.Seri, &r.YasGrubu, &r.AskiliYan, &r.UrunIlkGrubu, &r.UrunAnaGrubu, &r.UrunAltGrubu,
|
|
&r.ProductCount, &r.StarCount, &r.StockRiskCount, &r.StockQty,
|
|
&r.StockCostValueUSD, &r.RiskStockCostValueUSD, &r.SalesQty90,
|
|
&r.SalesUSD90, &r.GrossProfitUSD90, &r.AvgGrossMargin90, &r.AvgStockDays90,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func ListProductPerformanceCountries(ctx context.Context, pg *sql.DB, limit int) ([]models.ProductPerformanceCountryRow, error) {
|
|
if err := EnsureProductPerformanceTables(pg); err != nil {
|
|
return nil, err
|
|
}
|
|
if limit <= 0 || limit > 500 {
|
|
limit = 100
|
|
}
|
|
rows, err := pg.QueryContext(ctx, `
|
|
SELECT
|
|
customer_country,
|
|
customer_segment,
|
|
market_key,
|
|
MAX(kategori) AS kategori,
|
|
MAX(seri) AS seri,
|
|
COUNT(DISTINCT product_code) AS product_count,
|
|
COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0) AS sales_qty_90d,
|
|
COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0) AS sales_usd_90d,
|
|
CASE
|
|
WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)=0 THEN 0
|
|
ELSE COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)
|
|
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)
|
|
END AS avg_price_usd_90d,
|
|
COALESCE(SUM(customer_count) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)::integer AS customer_count_90d,
|
|
COALESCE(SUM(invoice_count) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)::integer AS invoice_count_90d,
|
|
COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '364 days'),0) AS sales_qty_365d,
|
|
COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '364 days'),0) AS sales_usd_365d
|
|
FROM mk_product_performance_sales_daily
|
|
WHERE sales_date >= current_date - INTERVAL '364 days'
|
|
GROUP BY customer_country, customer_segment, market_key
|
|
ORDER BY sales_usd_90d DESC, sales_qty_90d DESC
|
|
LIMIT $1
|
|
`, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := make([]models.ProductPerformanceCountryRow, 0, limit)
|
|
for rows.Next() {
|
|
var r models.ProductPerformanceCountryRow
|
|
if err := rows.Scan(
|
|
&r.Country, &r.CustomerSegment, &r.MarketKey, &r.Kategori, &r.Seri,
|
|
&r.ProductCount, &r.SalesQty90, &r.SalesUSD90, &r.AvgPriceUSD90,
|
|
&r.CustomerCount90, &r.InvoiceCount90, &r.SalesQty365, &r.SalesUSD365,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func ListProductPerformanceCustomers(ctx context.Context, pg *sql.DB, breakdown string, limit int) ([]models.ProductPerformanceCustomerRow, error) {
|
|
if err := EnsureProductPerformanceTables(pg); err != nil {
|
|
return nil, err
|
|
}
|
|
if limit <= 0 || limit > 500 {
|
|
limit = 100
|
|
}
|
|
mode := strings.ToLower(strings.TrimSpace(breakdown))
|
|
if mode == "" {
|
|
mode = "market_customer"
|
|
}
|
|
selectMarket := "''"
|
|
selectCountry := "''"
|
|
selectSegment := "''"
|
|
groupCols := []string{"customer_code", "customer_name"}
|
|
switch mode {
|
|
case "country_customer":
|
|
selectCountry = "customer_country"
|
|
selectSegment = "customer_segment"
|
|
groupCols = append(groupCols, "customer_country", "customer_segment")
|
|
case "market_country_customer":
|
|
selectMarket = "market_key"
|
|
selectCountry = "customer_country"
|
|
selectSegment = "customer_segment"
|
|
groupCols = append(groupCols, "market_key", "customer_country", "customer_segment")
|
|
default:
|
|
mode = "market_customer"
|
|
selectMarket = "market_key"
|
|
groupCols = append(groupCols, "market_key")
|
|
}
|
|
|
|
query := fmt.Sprintf(`
|
|
SELECT
|
|
$2::text AS breakdown,
|
|
%s AS market_key,
|
|
%s AS country,
|
|
%s AS customer_segment,
|
|
customer_code,
|
|
customer_name,
|
|
COUNT(DISTINCT product_code) AS product_count,
|
|
COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0) AS sales_qty_90d,
|
|
COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0) AS sales_usd_90d,
|
|
CASE
|
|
WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)=0 THEN 0
|
|
ELSE COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)
|
|
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)
|
|
END AS avg_price_usd_90d,
|
|
COALESCE(SUM(invoice_count) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)::integer AS invoice_count_90d,
|
|
COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '364 days'),0) AS sales_qty_365d,
|
|
COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '364 days'),0) AS sales_usd_365d,
|
|
COALESCE(to_char(MAX(sales_date),'YYYY-MM-DD'),'') AS last_sale_date
|
|
FROM mk_product_performance_sales_daily
|
|
WHERE sales_date >= current_date - INTERVAL '364 days'
|
|
AND COALESCE(customer_code,'') <> ''
|
|
GROUP BY %s
|
|
ORDER BY sales_usd_90d DESC, sales_qty_90d DESC
|
|
LIMIT $1
|
|
`, selectMarket, selectCountry, selectSegment, strings.Join(groupCols, ", "))
|
|
|
|
rows, err := pg.QueryContext(ctx, query, limit, mode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := make([]models.ProductPerformanceCustomerRow, 0, limit)
|
|
for rows.Next() {
|
|
var r models.ProductPerformanceCustomerRow
|
|
if err := rows.Scan(
|
|
&r.Breakdown, &r.MarketKey, &r.Country, &r.CustomerSegment, &r.CustomerCode, &r.CustomerName,
|
|
&r.ProductCount, &r.SalesQty90, &r.SalesUSD90, &r.AvgPriceUSD90, &r.InvoiceCount90,
|
|
&r.SalesQty365, &r.SalesUSD365, &r.LastSaleDate,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func ListProductPerformanceSalesDetails(ctx context.Context, pg *sql.DB, productCode, colorCode, yakaKodu string, limit int) ([]models.ProductPerformanceSalesDetailRow, error) {
|
|
if limit <= 0 || limit > 500 {
|
|
limit = 100
|
|
}
|
|
rows, err := pg.QueryContext(ctx, `
|
|
SELECT
|
|
to_char(sales_date,'YYYY-MM-DD') AS sales_date,
|
|
last_ref_number,
|
|
market_key,
|
|
customer_country,
|
|
customer_segment,
|
|
customer_code,
|
|
customer_name,
|
|
sales_qty,
|
|
sales_usd,
|
|
avg_price_usd
|
|
FROM mk_product_performance_sales_daily
|
|
WHERE product_code=$1
|
|
AND color_code=$2
|
|
AND yaka_kodu=$3
|
|
ORDER BY sales_date DESC, sales_usd DESC
|
|
LIMIT $4
|
|
`, strings.TrimSpace(productCode), strings.TrimSpace(colorCode), strings.TrimSpace(yakaKodu), limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := make([]models.ProductPerformanceSalesDetailRow, 0, limit)
|
|
for rows.Next() {
|
|
var r models.ProductPerformanceSalesDetailRow
|
|
if err := rows.Scan(&r.SalesDate, &r.RefNumber, &r.MarketKey, &r.Country, &r.CustomerSegment, &r.CustomerCode, &r.CustomerName, &r.SalesQty, &r.SalesUSD, &r.AvgPriceUSD); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func ListProductPerformanceStockSizes(ctx context.Context, productCode, colorCode, yakaKodu string) ([]models.ProductPerformanceStockSizeRow, error) {
|
|
if db.MssqlDB == nil {
|
|
return nil, fmt.Errorf("mssql db nil")
|
|
}
|
|
rows, err := db.MssqlDB.QueryContext(ctx, `
|
|
SELECT
|
|
SizeCode = LTRIM(RTRIM(ISNULL(S.ItemDim1Code, ''))),
|
|
StockQty = SUM(S.InventoryQty1)
|
|
FROM StockWithCost S WITH(NOLOCK)
|
|
WHERE S.ItemTypeCode = 1
|
|
AND LTRIM(RTRIM(S.ItemCode)) = @p1
|
|
AND LTRIM(RTRIM(ISNULL(S.ColorCode, ''))) = @p2
|
|
AND LTRIM(RTRIM(ISNULL(S.ItemDim2Code, ''))) = @p3
|
|
GROUP BY LTRIM(RTRIM(ISNULL(S.ItemDim1Code, '')))
|
|
HAVING SUM(S.InventoryQty1) <> 0
|
|
ORDER BY LTRIM(RTRIM(ISNULL(S.ItemDim1Code, '')))
|
|
`, strings.TrimSpace(productCode), strings.TrimSpace(colorCode), strings.TrimSpace(yakaKodu))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := make([]models.ProductPerformanceStockSizeRow, 0, 32)
|
|
for rows.Next() {
|
|
var r models.ProductPerformanceStockSizeRow
|
|
if err := rows.Scan(&r.SizeCode, &r.StockQty); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, r)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func productPerformanceWhere(f ProductPerformanceFilters) (string, []any) {
|
|
parts := make([]string, 0, 6)
|
|
args := make([]any, 0, 6)
|
|
add := func(cond string, value any) {
|
|
args = append(args, value)
|
|
parts = append(parts, fmt.Sprintf(cond, len(args)))
|
|
}
|
|
if q := strings.TrimSpace(f.Search); q != "" {
|
|
args = append(args, q)
|
|
idx := len(args)
|
|
parts = append(parts, fmt.Sprintf(" AND (product_code ILIKE '%%' || $%d || '%%' OR item_description ILIKE '%%' || $%d || '%%')", idx, idx))
|
|
}
|
|
if v := strings.TrimSpace(f.ProductCode); v != "" {
|
|
add(" AND product_code = $%d", v)
|
|
}
|
|
if v := strings.TrimSpace(f.MarketKey); v != "" {
|
|
add(" AND market_key = $%d", v)
|
|
}
|
|
if v := strings.TrimSpace(f.Kategori); v != "" {
|
|
add(" AND kategori = $%d", v)
|
|
}
|
|
if v := strings.TrimSpace(f.Seri); v != "" {
|
|
args = append(args, v)
|
|
idx := len(args)
|
|
parts = append(parts, fmt.Sprintf(" AND (seri = $%d OR urun_ana_grubu = $%d)", idx, idx))
|
|
}
|
|
if v := strings.TrimSpace(f.Bucket); v != "" {
|
|
add(" AND performance_bucket = $%d", v)
|
|
}
|
|
return strings.Join(parts, ""), args
|
|
}
|
|
|
|
func productPerformanceOrderBy(sortBy string, desc bool) string {
|
|
allowed := map[string]string{
|
|
"product_code": "product_code",
|
|
"color_code": "color_code",
|
|
"yaka_kodu": "yaka_kodu",
|
|
"item_description": "item_description",
|
|
"kategori": "kategori",
|
|
"urun_ilk_grubu": "urun_ilk_grubu",
|
|
"askili_yan": "askili_yan",
|
|
"urun_ana_grubu": "urun_ana_grubu",
|
|
"urun_alt_grubu": "urun_alt_grubu",
|
|
"market_key": "market_key",
|
|
"stock_qty": "stock_qty",
|
|
"sales_qty_90d": "sales_qty_90d",
|
|
"sales_qty_180d": "sales_qty_180d",
|
|
"sales_usd_90d": "sales_usd_90d",
|
|
"sales_usd_180d": "sales_usd_180d",
|
|
"stock_days_90d": "stock_days_90d",
|
|
"stock_days_180d": "stock_days_180d",
|
|
"avg_price_usd_90d": "avg_price_usd_90d",
|
|
"avg_price_usd_180d": "avg_price_usd_180d",
|
|
"base_price_usd": "base_price_usd",
|
|
"cost_price_usd": "cost_price_usd",
|
|
"unit_profit_base_90d": "unit_profit_base_90d",
|
|
"unit_profit_cost_90d": "unit_profit_cost_90d",
|
|
"unit_profit_base_180d": "unit_profit_base_180d",
|
|
"unit_profit_cost_180d": "unit_profit_cost_180d",
|
|
"gross_margin_90d": "gross_margin_90d",
|
|
"gross_margin_180d": "gross_margin_180d",
|
|
"market_count_90d": "market_count_90d",
|
|
"customer_count_90d": "customer_count_90d",
|
|
"sales_index_90d": "sales_index_90d",
|
|
"performance_score": "performance_score",
|
|
"performance_bucket": "performance_bucket",
|
|
"last_sale_date": "last_sale_date",
|
|
}
|
|
col := allowed[strings.TrimSpace(sortBy)]
|
|
if col == "" {
|
|
col = "performance_score"
|
|
desc = true
|
|
}
|
|
dir := "ASC"
|
|
if desc {
|
|
dir = "DESC"
|
|
}
|
|
return col + " " + dir + ", product_code ASC, color_code ASC, yaka_kodu ASC"
|
|
}
|
|
|
|
func dateOnly(t time.Time) time.Time {
|
|
y, m, d := t.Date()
|
|
return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
|
|
}
|
|
|
|
type productPerformanceSalesDaily struct {
|
|
SalesDate time.Time
|
|
ProductCode string
|
|
ColorCode string
|
|
YakaKodu string
|
|
ItemDescription string
|
|
Kategori string
|
|
Seri string
|
|
YasGrubu string
|
|
AskiliYan string
|
|
UrunIlkGrubu string
|
|
UrunAnaGrubu string
|
|
UrunAltGrubu string
|
|
MarketKey string
|
|
ChannelCode string
|
|
CustomerCountry string
|
|
CustomerSegment string
|
|
CustomerCode string
|
|
CustomerName string
|
|
SalesQty float64
|
|
SalesTL float64
|
|
SalesUSD float64
|
|
AvgPriceUSD float64
|
|
InvoiceLineCount int
|
|
InvoiceCount int
|
|
CustomerCount int
|
|
LastRefNumber string
|
|
}
|
|
|
|
type productPerformanceStockDaily struct {
|
|
StockDate time.Time
|
|
ProductCode string
|
|
ColorCode string
|
|
YakaKodu string
|
|
StockQty float64
|
|
InQty float64
|
|
OutQty float64
|
|
KpiInQty float64
|
|
KpiOutQty float64
|
|
SalesMovementQty float64
|
|
ProductionInQty float64
|
|
PurchaseInQty float64
|
|
ConsumptionOutQty float64
|
|
CountDiffQty float64
|
|
}
|