M_Kececi
be125a6880
# Conflicts: # svc/queries/product_performance_sql.go # ui/src/pages/ProductPerformanceProfitability.vue
4706 lines
194 KiB
Go
4706 lines
194 KiB
Go
package queries
|
||
|
||
import (
|
||
"bssapp-backend/db"
|
||
"bssapp-backend/models"
|
||
"context"
|
||
"database/sql"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"sort"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/lib/pq"
|
||
)
|
||
|
||
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
|
||
ProductPrefix string
|
||
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 productPerformanceStockQuery() string {
|
||
return `
|
||
;WITH ActiveWarehouses AS (
|
||
SELECT WarehouseCode
|
||
FROM (VALUES
|
||
('1-0-14'),('1-0-10'),('1-0-8'),('1-2-5'),('1-2-4'),('1-0-12'),('100'),('1-0-28'),
|
||
('1-0-24'),('1-2-6'),('1-1-14'),('1-0-2'),('1-0-52'),('1-1-2'),('1-0-21'),('1-1-3'),
|
||
('1-0-33'),('101'),('1-014'),('1-0-49'),('1-0-36'),('1-0-4'),('1-0-29')
|
||
) W(WarehouseCode)
|
||
),
|
||
Raw AS (
|
||
SELECT
|
||
ProductCode = UPPER(LTRIM(RTRIM(S.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(S.ColorCode, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(S.ItemDim2Code, '')))),
|
||
MovementDate = CAST(S.DocumentDate AS date),
|
||
ProcessCode = CASE
|
||
WHEN LTRIM(RTRIM(ISNULL(S.ProcessCode, ''))) <> '' THEN LTRIM(RTRIM(S.ProcessCode))
|
||
ELSE LTRIM(RTRIM(ISNULL(S.InnerProcessCode, '')))
|
||
END,
|
||
InQty = SUM(S.In_Qty1),
|
||
OutQty = SUM(S.Out_Qty1),
|
||
NetQty = SUM(S.In_Qty1 - S.Out_Qty1)
|
||
FROM trStock S WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W
|
||
ON W.WarehouseCode = LTRIM(RTRIM(S.WarehouseCode))
|
||
WHERE S.ItemTypeCode = 1
|
||
AND LEN(LTRIM(RTRIM(S.ItemCode))) = 13
|
||
AND (@p3 = '' OR UPPER(LTRIM(RTRIM(S.ItemCode))) LIKE @p3 + '%')
|
||
AND S.DocumentDate < DATEADD(DAY, 1, @p2)
|
||
GROUP BY
|
||
S.ItemCode,
|
||
S.ColorCode,
|
||
S.ItemDim2Code,
|
||
CAST(S.DocumentDate AS date),
|
||
CASE
|
||
WHEN LTRIM(RTRIM(ISNULL(S.ProcessCode, ''))) <> '' THEN LTRIM(RTRIM(S.ProcessCode))
|
||
ELSE LTRIM(RTRIM(ISNULL(S.InnerProcessCode, '')))
|
||
END
|
||
),
|
||
Opening AS (
|
||
SELECT
|
||
StockDate = @p1,
|
||
ProductCode,
|
||
ColorCode,
|
||
YakaKodu,
|
||
NetQty = SUM(NetQty),
|
||
InQty = CAST(0 AS decimal(18,4)),
|
||
OutQty = CAST(0 AS decimal(18,4)),
|
||
KpiInQty = CAST(0 AS decimal(18,4)),
|
||
KpiOutQty = CAST(0 AS decimal(18,4)),
|
||
SalesMovementQty = CAST(0 AS decimal(18,4)),
|
||
ProductionInQty = CAST(0 AS decimal(18,4)),
|
||
PurchaseInQty = CAST(0 AS decimal(18,4)),
|
||
ConsumptionOutQty = CAST(0 AS decimal(18,4)),
|
||
CountDiffQty = CAST(0 AS decimal(18,4))
|
||
FROM Raw
|
||
WHERE MovementDate < @p1
|
||
GROUP BY ProductCode, ColorCode, YakaKodu
|
||
),
|
||
Daily AS (
|
||
SELECT
|
||
StockDate = MovementDate,
|
||
ProductCode,
|
||
ColorCode,
|
||
YakaKodu,
|
||
NetQty = SUM(NetQty),
|
||
InQty = SUM(InQty),
|
||
OutQty = SUM(OutQty),
|
||
KpiInQty = SUM(CASE WHEN ProcessCode IN ('OP','BP','CI') THEN InQty ELSE 0 END),
|
||
KpiOutQty = SUM(CASE WHEN ProcessCode IN ('R','WS','OC','CO') THEN OutQty ELSE 0 END),
|
||
SalesMovementQty = SUM(CASE WHEN ProcessCode IN ('R','WS') THEN OutQty ELSE 0 END),
|
||
ProductionInQty = SUM(CASE WHEN ProcessCode = 'OP' THEN InQty ELSE 0 END),
|
||
PurchaseInQty = SUM(CASE WHEN ProcessCode = 'BP' THEN InQty ELSE 0 END),
|
||
ConsumptionOutQty = SUM(CASE WHEN ProcessCode = 'OC' THEN OutQty ELSE 0 END),
|
||
CountDiffQty = SUM(CASE WHEN ProcessCode IN ('CO','CI') THEN NetQty ELSE 0 END)
|
||
FROM Raw
|
||
WHERE MovementDate BETWEEN @p1 AND @p2
|
||
GROUP BY MovementDate, ProductCode, ColorCode, YakaKodu
|
||
),
|
||
Series AS (
|
||
SELECT * FROM Opening
|
||
UNION ALL
|
||
SELECT * FROM Daily
|
||
),
|
||
Collapsed AS (
|
||
SELECT
|
||
StockDate,
|
||
ProductCode,
|
||
ColorCode,
|
||
YakaKodu,
|
||
NetQty = SUM(NetQty),
|
||
InQty = SUM(InQty),
|
||
OutQty = SUM(OutQty),
|
||
KpiInQty = SUM(KpiInQty),
|
||
KpiOutQty = SUM(KpiOutQty),
|
||
SalesMovementQty = SUM(SalesMovementQty),
|
||
ProductionInQty = SUM(ProductionInQty),
|
||
PurchaseInQty = SUM(PurchaseInQty),
|
||
ConsumptionOutQty = SUM(ConsumptionOutQty),
|
||
CountDiffQty = SUM(CountDiffQty)
|
||
FROM Series
|
||
GROUP BY StockDate, ProductCode, ColorCode, YakaKodu
|
||
),
|
||
Running AS (
|
||
SELECT
|
||
StockDate,
|
||
ProductCode,
|
||
ColorCode,
|
||
YakaKodu,
|
||
StockQty = SUM(NetQty) OVER (
|
||
PARTITION BY ProductCode, ColorCode, YakaKodu
|
||
ORDER BY StockDate
|
||
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
|
||
),
|
||
InQty,
|
||
OutQty,
|
||
KpiInQty,
|
||
KpiOutQty,
|
||
SalesMovementQty,
|
||
ProductionInQty,
|
||
PurchaseInQty,
|
||
ConsumptionOutQty,
|
||
CountDiffQty
|
||
FROM Collapsed
|
||
),
|
||
CurrentSource AS (
|
||
SELECT
|
||
SourceTable = 'PickingStates',
|
||
WarehouseCode = LTRIM(RTRIM(P.WarehouseCode)),
|
||
ProductCode = UPPER(LTRIM(RTRIM(P.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(P.ColorCode, '')))),
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(P.ItemDim1Code, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(P.ItemDim2Code, '')))),
|
||
Dim3Code = UPPER(LTRIM(RTRIM(ISNULL(P.ItemDim3Code, '')))),
|
||
PickingQty1 = SUM(P.Qty1),
|
||
ReserveQty1 = CAST(0 AS decimal(18,4)),
|
||
DispOrderQty1 = CAST(0 AS decimal(18,4)),
|
||
InventoryQty1 = CAST(0 AS decimal(18,4))
|
||
FROM PickingStates P WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W ON W.WarehouseCode = LTRIM(RTRIM(P.WarehouseCode))
|
||
WHERE P.ItemTypeCode = 1
|
||
AND LEN(LTRIM(RTRIM(P.ItemCode))) = 13
|
||
AND (@p3 = '' OR UPPER(LTRIM(RTRIM(P.ItemCode))) LIKE @p3 + '%')
|
||
GROUP BY P.WarehouseCode, P.ItemCode, P.ColorCode, P.ItemDim1Code, P.ItemDim2Code, P.ItemDim3Code
|
||
UNION ALL
|
||
SELECT
|
||
SourceTable = 'ReserveStates',
|
||
WarehouseCode = LTRIM(RTRIM(R.WarehouseCode)),
|
||
ProductCode = UPPER(LTRIM(RTRIM(R.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(R.ColorCode, '')))),
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(R.ItemDim1Code, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(R.ItemDim2Code, '')))),
|
||
Dim3Code = UPPER(LTRIM(RTRIM(ISNULL(R.ItemDim3Code, '')))),
|
||
PickingQty1 = CAST(0 AS decimal(18,4)),
|
||
ReserveQty1 = SUM(R.Qty1),
|
||
DispOrderQty1 = CAST(0 AS decimal(18,4)),
|
||
InventoryQty1 = CAST(0 AS decimal(18,4))
|
||
FROM ReserveStates R WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W ON W.WarehouseCode = LTRIM(RTRIM(R.WarehouseCode))
|
||
WHERE R.ItemTypeCode = 1
|
||
AND LEN(LTRIM(RTRIM(R.ItemCode))) = 13
|
||
AND (@p3 = '' OR UPPER(LTRIM(RTRIM(R.ItemCode))) LIKE @p3 + '%')
|
||
GROUP BY R.WarehouseCode, R.ItemCode, R.ColorCode, R.ItemDim1Code, R.ItemDim2Code, R.ItemDim3Code
|
||
UNION ALL
|
||
SELECT
|
||
SourceTable = 'DispOrderStates',
|
||
WarehouseCode = LTRIM(RTRIM(D.WarehouseCode)),
|
||
ProductCode = UPPER(LTRIM(RTRIM(D.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(D.ColorCode, '')))),
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(D.ItemDim1Code, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(D.ItemDim2Code, '')))),
|
||
Dim3Code = UPPER(LTRIM(RTRIM(ISNULL(D.ItemDim3Code, '')))),
|
||
PickingQty1 = CAST(0 AS decimal(18,4)),
|
||
ReserveQty1 = CAST(0 AS decimal(18,4)),
|
||
DispOrderQty1 = SUM(D.Qty1),
|
||
InventoryQty1 = CAST(0 AS decimal(18,4))
|
||
FROM DispOrderStates D WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W ON W.WarehouseCode = LTRIM(RTRIM(D.WarehouseCode))
|
||
WHERE D.ItemTypeCode = 1
|
||
AND LEN(LTRIM(RTRIM(D.ItemCode))) = 13
|
||
AND (@p3 = '' OR UPPER(LTRIM(RTRIM(D.ItemCode))) LIKE @p3 + '%')
|
||
GROUP BY D.WarehouseCode, D.ItemCode, D.ColorCode, D.ItemDim1Code, D.ItemDim2Code, D.ItemDim3Code
|
||
UNION ALL
|
||
SELECT
|
||
SourceTable = 'trStock',
|
||
WarehouseCode = LTRIM(RTRIM(S.WarehouseCode)),
|
||
ProductCode = UPPER(LTRIM(RTRIM(S.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(S.ColorCode, '')))),
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(S.ItemDim1Code, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(S.ItemDim2Code, '')))),
|
||
Dim3Code = UPPER(LTRIM(RTRIM(ISNULL(S.ItemDim3Code, '')))),
|
||
PickingQty1 = CAST(0 AS decimal(18,4)),
|
||
ReserveQty1 = CAST(0 AS decimal(18,4)),
|
||
DispOrderQty1 = CAST(0 AS decimal(18,4)),
|
||
InventoryQty1 = SUM(S.In_Qty1 - S.Out_Qty1)
|
||
FROM trStock S WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W ON W.WarehouseCode = LTRIM(RTRIM(S.WarehouseCode))
|
||
WHERE S.ItemTypeCode = 1
|
||
AND LEN(LTRIM(RTRIM(S.ItemCode))) = 13
|
||
AND (@p3 = '' OR UPPER(LTRIM(RTRIM(S.ItemCode))) LIKE @p3 + '%')
|
||
AND S.DocumentDate < DATEADD(DAY, 1, @p2)
|
||
GROUP BY S.WarehouseCode, S.ItemCode, S.ColorCode, S.ItemDim1Code, S.ItemDim2Code, S.ItemDim3Code
|
||
),
|
||
CurrentInventory AS (
|
||
SELECT
|
||
ProductCode,
|
||
ColorCode,
|
||
SizeCode,
|
||
YakaKodu,
|
||
Dim3Code,
|
||
WarehouseCode,
|
||
PickingQty1 = SUM(PickingQty1),
|
||
ReserveQty1 = SUM(ReserveQty1),
|
||
DispOrderQty1 = SUM(DispOrderQty1),
|
||
InventoryQty1 = SUM(InventoryQty1)
|
||
FROM CurrentSource
|
||
GROUP BY WarehouseCode, ProductCode, ColorCode, SizeCode, YakaKodu, Dim3Code
|
||
),
|
||
CurrentAvailable AS (
|
||
SELECT
|
||
StockDate = @p2,
|
||
I.ProductCode,
|
||
I.ColorCode,
|
||
I.YakaKodu,
|
||
StockQty = CAST(ROUND(SUM(
|
||
ISNULL(I.InventoryQty1, 0)
|
||
- ISNULL(I.PickingQty1, 0)
|
||
- ISNULL(I.ReserveQty1, 0)
|
||
- ISNULL(I.DispOrderQty1, 0)),
|
||
2
|
||
) AS decimal(18,4)),
|
||
InQty = CAST(0 AS decimal(18,4)),
|
||
OutQty = CAST(0 AS decimal(18,4)),
|
||
KpiInQty = CAST(0 AS decimal(18,4)),
|
||
KpiOutQty = CAST(0 AS decimal(18,4)),
|
||
SalesMovementQty = CAST(0 AS decimal(18,4)),
|
||
ProductionInQty = CAST(0 AS decimal(18,4)),
|
||
PurchaseInQty = CAST(0 AS decimal(18,4)),
|
||
ConsumptionOutQty = CAST(0 AS decimal(18,4)),
|
||
CountDiffQty = CAST(0 AS decimal(18,4))
|
||
FROM CurrentInventory I
|
||
INNER JOIN cdItem WITH(NOLOCK)
|
||
ON cdItem.ItemTypeCode = 1
|
||
AND UPPER(LTRIM(RTRIM(cdItem.ItemCode))) = I.ProductCode
|
||
AND cdItem.IsBlocked = 0
|
||
WHERE I.InventoryQty1 >= 0
|
||
AND LEN(I.ProductCode) = 13
|
||
GROUP BY I.ProductCode, I.ColorCode, I.YakaKodu
|
||
)
|
||
SELECT
|
||
StockDate,
|
||
ProductCode,
|
||
ColorCode,
|
||
YakaKodu,
|
||
StockQty,
|
||
InQty,
|
||
OutQty,
|
||
KpiInQty,
|
||
KpiOutQty,
|
||
SalesMovementQty,
|
||
ProductionInQty,
|
||
PurchaseInQty,
|
||
ConsumptionOutQty,
|
||
CountDiffQty
|
||
FROM (
|
||
SELECT * FROM Running WHERE StockDate BETWEEN @p1 AND DATEADD(DAY, -1, @p2)
|
||
UNION ALL
|
||
SELECT * FROM CurrentAvailable
|
||
) X
|
||
ORDER BY StockDate, ProductCode, ColorCode, YakaKodu
|
||
`
|
||
}
|
||
|
||
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 ''`,
|
||
`
|
||
UPDATE mk_product_performance_sales_daily
|
||
SET urun_ilk_grubu = '', updated_at = now()
|
||
WHERE btrim(urun_ilk_grubu) = '-'
|
||
OR upper(translate(btrim(urun_ilk_grubu), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON')`,
|
||
`
|
||
DELETE FROM mk_product_performance_sales_daily
|
||
WHERE upper(btrim(COALESCE(urun_ilk_grubu,''))) IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')`,
|
||
`
|
||
UPDATE mk_product_performance_sales_daily
|
||
SET askili_yan = '', updated_at = now()
|
||
WHERE btrim(askili_yan) = '-'`,
|
||
`
|
||
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,
|
||
item_description TEXT NOT NULL DEFAULT '',
|
||
kategori 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 '',
|
||
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()
|
||
)`,
|
||
`ALTER TABLE mk_product_performance_price_dim ADD COLUMN IF NOT EXISTS item_description TEXT NOT NULL DEFAULT ''`,
|
||
`ALTER TABLE mk_product_performance_price_dim ADD COLUMN IF NOT EXISTS kategori TEXT NOT NULL DEFAULT ''`,
|
||
`ALTER TABLE mk_product_performance_price_dim ADD COLUMN IF NOT EXISTS askili_yan TEXT NOT NULL DEFAULT ''`,
|
||
`ALTER TABLE mk_product_performance_price_dim ADD COLUMN IF NOT EXISTS urun_ilk_grubu TEXT NOT NULL DEFAULT ''`,
|
||
`ALTER TABLE mk_product_performance_price_dim ADD COLUMN IF NOT EXISTS urun_ana_grubu TEXT NOT NULL DEFAULT ''`,
|
||
`ALTER TABLE mk_product_performance_price_dim ADD COLUMN IF NOT EXISTS urun_alt_grubu TEXT NOT NULL DEFAULT ''`,
|
||
`
|
||
UPDATE mk_product_performance_price_dim
|
||
SET
|
||
cost_price_usd = GREATEST(cost_price_usd, base_price_usd),
|
||
base_price_usd = LEAST(cost_price_usd, base_price_usd),
|
||
updated_at = now()
|
||
WHERE cost_price_usd > 0
|
||
AND base_price_usd > 0
|
||
AND cost_price_usd < base_price_usd`,
|
||
`
|
||
DELETE FROM mk_product_performance_price_dim
|
||
WHERE upper(btrim(COALESCE(urun_ilk_grubu,''))) IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')`,
|
||
`
|
||
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 ''`,
|
||
`
|
||
UPDATE mk_product_performance_kpi_daily
|
||
SET urun_ilk_grubu = '', updated_at = now()
|
||
WHERE btrim(urun_ilk_grubu) = '-'
|
||
OR upper(translate(btrim(urun_ilk_grubu), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON')`,
|
||
`
|
||
DELETE FROM mk_product_performance_kpi_daily
|
||
WHERE upper(btrim(COALESCE(urun_ilk_grubu,''))) IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')`,
|
||
`
|
||
UPDATE mk_product_performance_kpi_daily
|
||
SET
|
||
cost_price_usd = GREATEST(cost_price_usd, base_price_usd),
|
||
base_price_usd = LEAST(cost_price_usd, base_price_usd),
|
||
gross_profit_usd_90d = COALESCE(sales_usd_90d,0) - (COALESCE(sales_qty_90d,0) * GREATEST(cost_price_usd, base_price_usd)),
|
||
gross_profit_usd_180d = COALESCE(sales_usd_180d,0) - (COALESCE(sales_qty_180d,0) * GREATEST(cost_price_usd, base_price_usd)),
|
||
gross_margin_90d = CASE WHEN COALESCE(sales_usd_90d,0) = 0 THEN 0 ELSE (COALESCE(sales_usd_90d,0) - (COALESCE(sales_qty_90d,0) * GREATEST(cost_price_usd, base_price_usd))) / NULLIF(sales_usd_90d,0) END,
|
||
gross_margin_180d = CASE WHEN COALESCE(sales_usd_180d,0) = 0 THEN 0 ELSE (COALESCE(sales_usd_180d,0) - (COALESCE(sales_qty_180d,0) * GREATEST(cost_price_usd, base_price_usd))) / NULLIF(sales_usd_180d,0) END,
|
||
unit_profit_cost_90d = CASE WHEN COALESCE(sales_qty_90d,0) = 0 THEN 0 ELSE (COALESCE(sales_usd_90d,0) / NULLIF(sales_qty_90d,0)) - GREATEST(cost_price_usd, base_price_usd) END,
|
||
unit_profit_cost_180d = CASE WHEN COALESCE(sales_qty_180d,0) = 0 THEN 0 ELSE (COALESCE(sales_usd_180d,0) / NULLIF(sales_qty_180d,0)) - GREATEST(cost_price_usd, base_price_usd) END,
|
||
unit_profit_base_90d = CASE WHEN COALESCE(sales_qty_90d,0) = 0 THEN 0 ELSE (COALESCE(sales_usd_90d,0) / NULLIF(sales_qty_90d,0)) - LEAST(cost_price_usd, base_price_usd) END,
|
||
unit_profit_base_180d = CASE WHEN COALESCE(sales_qty_180d,0) = 0 THEN 0 ELSE (COALESCE(sales_usd_180d,0) / NULLIF(sales_qty_180d,0)) - LEAST(cost_price_usd, base_price_usd) END,
|
||
updated_at = now()
|
||
WHERE cost_price_usd > 0
|
||
AND base_price_usd > 0
|
||
AND cost_price_usd < base_price_usd`,
|
||
`
|
||
UPDATE mk_product_performance_kpi_daily
|
||
SET askili_yan = '', updated_at = now()
|
||
WHERE btrim(askili_yan) = '-'`,
|
||
`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_qty_total 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 sales_usd_total 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 avg_daily_sales_365d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
||
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS avg_daily_sales_total 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 stock_days_365d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
||
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS stock_days_total NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
||
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS stock_turnover_90d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
||
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS stock_turnover_180d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
||
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS stock_turnover_365d NUMERIC(18,6) NOT NULL DEFAULT 0`,
|
||
`ALTER TABLE mk_product_performance_kpi_daily ADD COLUMN IF NOT EXISTS stock_turnover_total 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)
|
||
productPrefix := productPerformanceProductPrefix(req.ProductPrefix)
|
||
log.Printf("[ProductPerformanceRefresh] start mode=%s stage=%s prefix=%s start=%s end=%s", req.Mode, stage, productPrefix, 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")
|
||
deleteSQL := `DELETE FROM mk_product_performance_sales_daily WHERE sales_date BETWEEN $1 AND $2`
|
||
deleteArgs := []any{req.StartDate, req.EndDate}
|
||
if productPrefix != "" {
|
||
deleteSQL += ` AND product_code ILIKE $3 || '%'`
|
||
deleteArgs = append(deleteArgs, productPrefix)
|
||
}
|
||
if _, err := tx.ExecContext(ctx, deleteSQL, deleteArgs...); 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, productPrefix)
|
||
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, productPrefix)
|
||
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, productPrefix); 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 productPerformanceProductPrefix(raw string) string {
|
||
return strings.ToUpper(strings.TrimSpace(raw))
|
||
}
|
||
|
||
func normalizeProductPerformanceProductCode(raw string) string {
|
||
return strings.ToUpper(strings.TrimSpace(raw))
|
||
}
|
||
|
||
func normalizeProductPerformanceCode(raw string) string {
|
||
return strings.ToUpper(strings.TrimSpace(raw))
|
||
}
|
||
|
||
func normalizeProductPerformanceVariantCodes(productCode, colorCode, yakaKodu *string) {
|
||
if productCode != nil {
|
||
*productCode = normalizeProductPerformanceProductCode(*productCode)
|
||
}
|
||
if colorCode != nil {
|
||
*colorCode = normalizeProductPerformanceCode(*colorCode)
|
||
}
|
||
if yakaKodu != nil {
|
||
*yakaKodu = normalizeProductPerformanceCode(*yakaKodu)
|
||
}
|
||
}
|
||
|
||
func productPerformanceColorDescriptions(ctx context.Context, colorCodes []string) map[string]string {
|
||
out := map[string]string{}
|
||
if db.MssqlDB == nil || len(colorCodes) == 0 {
|
||
return out
|
||
}
|
||
seen := map[string]bool{}
|
||
codes := make([]string, 0, len(colorCodes))
|
||
for _, raw := range colorCodes {
|
||
code := normalizeProductPerformanceCode(raw)
|
||
if code == "" || seen[code] {
|
||
continue
|
||
}
|
||
seen[code] = true
|
||
codes = append(codes, code)
|
||
}
|
||
const batchSize = 500
|
||
for start := 0; start < len(codes); start += batchSize {
|
||
end := start + batchSize
|
||
if end > len(codes) {
|
||
end = len(codes)
|
||
}
|
||
batch := codes[start:end]
|
||
placeholders := make([]string, len(batch))
|
||
args := make([]any, len(batch))
|
||
for i, code := range batch {
|
||
placeholders[i] = fmt.Sprintf("@p%d", i+1)
|
||
args[i] = code
|
||
}
|
||
query := fmt.Sprintf(`
|
||
SELECT
|
||
UPPER(LTRIM(RTRIM(ColorCode))) AS color_code,
|
||
MAX(LTRIM(RTRIM(ISNULL(ColorDescription, '')))) AS color_description
|
||
FROM cdColorDesc WITH(NOLOCK)
|
||
WHERE LangCode = 'TR'
|
||
AND UPPER(LTRIM(RTRIM(ColorCode))) IN (%s)
|
||
GROUP BY UPPER(LTRIM(RTRIM(ColorCode)))
|
||
`, strings.Join(placeholders, ","))
|
||
rows, err := db.MssqlDB.QueryContext(ctx, query, args...)
|
||
if err != nil {
|
||
log.Printf("[ProductPerformance] color descriptions failed: %v", err)
|
||
return out
|
||
}
|
||
for rows.Next() {
|
||
var code, desc string
|
||
if err := rows.Scan(&code, &desc); err != nil {
|
||
rows.Close()
|
||
log.Printf("[ProductPerformance] color description scan failed: %v", err)
|
||
return out
|
||
}
|
||
out[normalizeProductPerformanceCode(code)] = strings.TrimSpace(desc)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
rows.Close()
|
||
log.Printf("[ProductPerformance] color description rows failed: %v", err)
|
||
return out
|
||
}
|
||
rows.Close()
|
||
}
|
||
return out
|
||
}
|
||
|
||
func refreshProductPerformanceSales(ctx context.Context, tx *sql.Tx, startDate, endDate time.Time, productPrefix string) (int, error) {
|
||
log.Printf("[ProductPerformanceRefresh] sales mssql query start start=%s end=%s prefix=%s", startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), productPrefix)
|
||
rows, err := db.MssqlDB.QueryContext(ctx, productPerformanceSalesSQL(), startDate, endDate, productPrefix)
|
||
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
|
||
}
|
||
normalizeProductPerformanceVariantCodes(&r.ProductCode, &r.ColorCode, &r.YakaKodu)
|
||
r.AskiliYan = cleanProductPerformanceOptionalAttr(r.AskiliYan)
|
||
r.UrunIlkGrubu = cleanProductPerformanceFirstGroup(r.UrunIlkGrubu)
|
||
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, productPrefix string) (int, error) {
|
||
log.Printf("[ProductPerformanceRefresh] stock mssql query start start=%s end=%s prefix=%s", startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), productPrefix)
|
||
rows, err := db.MssqlDB.QueryContext(ctx, productPerformanceStockQuery(), startDate, endDate, productPrefix)
|
||
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
|
||
}
|
||
normalizeProductPerformanceVariantCodes(&r.ProductCode, &r.ColorCode, &r.YakaKodu)
|
||
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, productPrefix string) (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")
|
||
deleteSQL := `DELETE FROM mk_product_performance_stock_daily WHERE stock_date BETWEEN $1 AND $2`
|
||
deleteArgs := []any{startDate, endDate}
|
||
if productPrefix != "" {
|
||
deleteSQL += ` AND product_code ILIKE $3 || '%'`
|
||
deleteArgs = append(deleteArgs, productPrefix)
|
||
}
|
||
if _, err := deleteTx.ExecContext(ctx, deleteSQL, deleteArgs...); 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 prefix=%s", startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), productPrefix)
|
||
rows, err := db.MssqlDB.QueryContext(ctx, productPerformanceStockQuery(), startDate, endDate, productPrefix)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
defer rows.Close()
|
||
log.Printf("[ProductPerformanceRefresh] stock mssql query returned, postgres chunk upsert 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
|
||
}
|
||
normalizeProductPerformanceVariantCodes(&r.ProductCode, &r.ColorCode, &r.YakaKodu)
|
||
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 upserted_rows=%d scanned_rows=%d", count, seen)
|
||
if err := tx.Commit(); err != nil {
|
||
return count, err
|
||
}
|
||
log.Printf("[ProductPerformanceRefresh] stock chunk commit done upserted_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 upserted_rows=%d scanned_rows=%d", count, seen)
|
||
if err := tx.Commit(); err != nil {
|
||
return count, err
|
||
}
|
||
log.Printf("[ProductPerformanceRefresh] stock final chunk commit done upserted_rows=%d scanned_rows=%d elapsed=%s", count, seen, time.Since(started).Round(time.Second))
|
||
} else {
|
||
_ = tx.Rollback()
|
||
}
|
||
log.Printf("[ProductPerformanceRefresh] stock refresh done upserted_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 prepareProductPerformanceStockCopy(ctx context.Context, tx *sql.Tx) (*sql.Stmt, error) {
|
||
return tx.PrepareContext(ctx, pq.CopyIn(
|
||
"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",
|
||
))
|
||
}
|
||
|
||
func insertProductPerformanceStock(ctx context.Context, exec productPerformanceStockExec, r productPerformanceStockDaily) error {
|
||
normalizeProductPerformanceVariantCodes(&r.ProductCode, &r.ColorCode, &r.YakaKodu)
|
||
_, 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, productPrefix string) error {
|
||
log.Printf("[ProductPerformanceRefresh] price mssql query start prefix=%s", productPrefix)
|
||
rows, err := db.MssqlDB.QueryContext(ctx, productPerformancePriceSQL(), productPrefix)
|
||
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 itemDescription, kategori, askiliYan, urunIlkGrubu, urunAnaGrubu, urunAltGrubu string
|
||
var cost, usd, tryPrice float64
|
||
var lastPricing sql.NullTime
|
||
if err := rows.Scan(&code, &itemDescription, &kategori, &askiliYan, &urunIlkGrubu, &urunAnaGrubu, &urunAltGrubu, &cost, &usd, &tryPrice, &lastPricing); err != nil {
|
||
return err
|
||
}
|
||
code = normalizeProductPerformanceProductCode(code)
|
||
askiliYan = cleanProductPerformanceOptionalAttr(askiliYan)
|
||
urunIlkGrubu = cleanProductPerformanceFirstGroup(urunIlkGrubu)
|
||
cost, usd = normalizeProductPerformanceCostPair(cost, usd)
|
||
var lp any
|
||
if lastPricing.Valid {
|
||
lp = lastPricing.Time
|
||
}
|
||
if _, err := tx.ExecContext(ctx, `
|
||
INSERT INTO mk_product_performance_price_dim (
|
||
product_code, item_description, kategori, askili_yan, urun_ilk_grubu, urun_ana_grubu, urun_alt_grubu,
|
||
cost_price_usd, base_price_usd, base_price_try, last_pricing_date, updated_at
|
||
)
|
||
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,now())
|
||
ON CONFLICT (product_code) DO UPDATE SET
|
||
item_description=EXCLUDED.item_description,
|
||
kategori=EXCLUDED.kategori,
|
||
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,
|
||
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()
|
||
`, code, strings.TrimSpace(itemDescription), strings.TrimSpace(kategori), askiliYan, urunIlkGrubu, strings.TrimSpace(urunAnaGrubu), strings.TrimSpace(urunAltGrubu), 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
|
||
}
|
||
if _, err := exec.ExecContext(ctx, `
|
||
UPDATE mk_product_performance_kpi_daily k
|
||
SET
|
||
item_description = CASE WHEN btrim(COALESCE(k.item_description,'')) = '' THEN COALESCE(NULLIF(p.item_description,''), k.item_description) ELSE k.item_description END,
|
||
kategori = CASE WHEN btrim(COALESCE(k.kategori,'')) = '' OR btrim(COALESCE(k.kategori,'')) = '-' THEN COALESCE(NULLIF(p.kategori,''), '') ELSE k.kategori END,
|
||
askili_yan = CASE WHEN btrim(COALESCE(k.askili_yan,'')) = '' OR btrim(COALESCE(k.askili_yan,'')) = '-' THEN COALESCE(NULLIF(NULLIF(p.askili_yan,''), '-'), '') ELSE k.askili_yan END,
|
||
urun_ilk_grubu = CASE WHEN btrim(COALESCE(k.urun_ilk_grubu,'')) = '' OR btrim(COALESCE(k.urun_ilk_grubu,'')) = '-' THEN COALESCE(NULLIF(p.urun_ilk_grubu,''), '') ELSE k.urun_ilk_grubu END,
|
||
urun_ana_grubu = CASE WHEN btrim(COALESCE(k.urun_ana_grubu,'')) = '' THEN COALESCE(NULLIF(p.urun_ana_grubu,''), k.urun_ana_grubu) ELSE k.urun_ana_grubu END,
|
||
urun_alt_grubu = CASE WHEN btrim(COALESCE(k.urun_alt_grubu,'')) = '' THEN COALESCE(NULLIF(p.urun_alt_grubu,''), k.urun_alt_grubu) ELSE k.urun_alt_grubu END,
|
||
updated_at = now()
|
||
FROM mk_product_performance_price_dim p
|
||
WHERE k.kpi_date = $1
|
||
AND p.product_code = k.product_code
|
||
AND (
|
||
btrim(COALESCE(k.item_description,'')) = ''
|
||
OR btrim(COALESCE(k.kategori,'')) IN ('', '-')
|
||
OR btrim(COALESCE(k.askili_yan,'')) IN ('', '-')
|
||
OR btrim(COALESCE(k.urun_ilk_grubu,'')) IN ('', '-')
|
||
OR btrim(COALESCE(k.urun_ana_grubu,'')) = ''
|
||
OR btrim(COALESCE(k.urun_alt_grubu,'')) = ''
|
||
)
|
||
`, kpiDate); 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 = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
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_qty_total,
|
||
sales_usd_30d, sales_usd_90d, sales_usd_180d, sales_usd_365d, sales_usd_total,
|
||
avg_daily_sales_90d, avg_daily_sales_180d, avg_daily_sales_365d, avg_daily_sales_total,
|
||
stock_days_90d, stock_days_180d, stock_days_365d, stock_days_total,
|
||
stock_turnover_90d, stock_turnover_180d, stock_turnover_365d, stock_turnover_total,
|
||
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)
|
||
colorCodes := make([]string, 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.SalesQtyTotal,
|
||
&r.SalesUSD30, &r.SalesUSD90, &r.SalesUSD180, &r.SalesUSD365, &r.SalesUSDTotal,
|
||
&r.AvgDailySales90, &r.AvgDailySales180, &r.AvgDailySales365, &r.AvgDailySalesTotal,
|
||
&r.StockDays90, &r.StockDays180, &r.StockDays365, &r.StockDaysTotal,
|
||
&r.StockTurnover90, &r.StockTurnover180, &r.StockTurnover365, &r.StockTurnoverTotal,
|
||
&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
|
||
}
|
||
r.UrunIlkGrubu = cleanProductPerformanceFirstGroup(r.UrunIlkGrubu)
|
||
colorCodes = append(colorCodes, r.ColorCode)
|
||
out = append(out, r)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, 0, err
|
||
}
|
||
colorDescriptions := productPerformanceColorDescriptions(ctx, colorCodes)
|
||
for i := range out {
|
||
out[i].ColorDescription = colorDescriptions[normalizeProductPerformanceCode(out[i].ColorCode)]
|
||
}
|
||
return out, total, nil
|
||
}
|
||
|
||
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)
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
),
|
||
VariantStock AS (
|
||
SELECT
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
MAX(stock_qty) AS stock_qty,
|
||
MAX(cost_price_usd) AS cost_price_usd,
|
||
BOOL_OR(performance_bucket IN ('STOK_RISKI','TAKIP')) AS has_risk_bucket,
|
||
SUM(COALESCE(sales_qty_90d,0)) AS sales_qty_90d
|
||
FROM KPI
|
||
GROUP BY product_code, color_code, yaka_kodu
|
||
),
|
||
StockTotals AS (
|
||
SELECT
|
||
COALESCE(SUM(stock_qty),0) AS total_stock,
|
||
COALESCE(SUM(stock_qty * cost_price_usd),0) AS stock_cost_usd,
|
||
COALESCE(SUM(CASE WHEN has_risk_bucket AND COALESCE(sales_qty_90d,0)=0 THEN stock_qty * cost_price_usd ELSE 0 END),0) AS risk_cost_usd
|
||
FROM VariantStock
|
||
),
|
||
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)
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
)
|
||
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(MAX(StockTotals.total_stock),0),
|
||
COALESCE(MAX(StockTotals.stock_cost_usd),0),
|
||
COALESCE(MAX(StockTotals.risk_cost_usd),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
|
||
CROSS JOIN StockTotals
|
||
`).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 ListProductPerformanceGeneral(ctx context.Context, pg *sql.DB, limit int) ([]models.ProductPerformanceGeneralRow, error) {
|
||
if err := EnsureProductPerformanceTables(pg); err != nil {
|
||
return nil, err
|
||
}
|
||
if limit <= 0 {
|
||
limit = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
rows, err := pg.QueryContext(ctx, `
|
||
WITH Bounds AS (
|
||
SELECT
|
||
DATE '2022-01-01' AS period_start,
|
||
COALESCE(
|
||
(SELECT MAX(kpi_date) FROM mk_product_performance_kpi_daily),
|
||
(SELECT MAX(sales_date) FROM mk_product_performance_sales_daily),
|
||
current_date
|
||
) AS period_end
|
||
),
|
||
LatestStockDate AS (
|
||
SELECT MAX(stock_date) AS stock_date
|
||
FROM mk_product_performance_stock_daily
|
||
),
|
||
SalesAgg AS (
|
||
SELECT
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
market_key,
|
||
MAX(item_description) AS item_description,
|
||
MAX(kategori) AS kategori,
|
||
MAX(seri) AS seri,
|
||
MAX(yas_grubu) AS yas_grubu,
|
||
COALESCE(MAX(NULLIF(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,
|
||
MIN(sales_date) AS first_sale_date,
|
||
MAX(sales_date) AS last_sale_date,
|
||
MAX(last_ref_number) AS last_ref_number,
|
||
COALESCE(SUM(sales_qty),0) AS sales_qty_total,
|
||
COALESCE(SUM(sales_usd),0) AS sales_usd_total,
|
||
COALESCE(COUNT(DISTINCT NULLIF(customer_code, '-')),0)::integer AS customer_count_total,
|
||
COALESCE(SUM(invoice_count),0)::integer AS invoice_count_total
|
||
FROM mk_product_performance_sales_daily, Bounds
|
||
WHERE sales_date BETWEEN Bounds.period_start AND Bounds.period_end
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
GROUP BY product_code, color_code, yaka_kodu, market_key
|
||
),
|
||
StockAgg AS (
|
||
SELECT
|
||
s.product_code,
|
||
s.color_code,
|
||
s.yaka_kodu,
|
||
COALESCE(SUM(s.stock_qty),0) AS stock_qty
|
||
FROM mk_product_performance_stock_daily s
|
||
WHERE s.stock_date = (SELECT stock_date FROM LatestStockDate)
|
||
GROUP BY s.product_code, s.color_code, s.yaka_kodu
|
||
),
|
||
StockTotalStart AS (
|
||
SELECT DISTINCT ON (s.product_code, s.color_code, s.yaka_kodu)
|
||
s.product_code,
|
||
s.color_code,
|
||
s.yaka_kodu,
|
||
s.stock_qty
|
||
FROM mk_product_performance_stock_daily s
|
||
WHERE s.stock_date <= DATE '2022-01-01'
|
||
ORDER BY s.product_code, s.color_code, s.yaka_kodu, s.stock_date DESC
|
||
),
|
||
Dim AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
item_description,
|
||
COALESCE(kategori,'') AS kategori,
|
||
seri,
|
||
yas_grubu,
|
||
CASE WHEN btrim(COALESCE(askili_yan,'')) = '-' THEN '' ELSE COALESCE(askili_yan,'') END AS askili_yan,
|
||
urun_ilk_grubu,
|
||
urun_ana_grubu,
|
||
urun_alt_grubu
|
||
FROM (
|
||
SELECT
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
item_description,
|
||
kategori,
|
||
seri,
|
||
yas_grubu,
|
||
askili_yan,
|
||
urun_ilk_grubu,
|
||
urun_ana_grubu,
|
||
urun_alt_grubu,
|
||
1 AS src_rank
|
||
FROM mk_product_performance_kpi_daily
|
||
WHERE kpi_date = (SELECT MAX(kpi_date) FROM mk_product_performance_kpi_daily)
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
UNION ALL
|
||
SELECT
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
MAX(item_description) AS item_description,
|
||
MAX(kategori) AS kategori,
|
||
MAX(seri) AS seri,
|
||
MAX(yas_grubu) AS yas_grubu,
|
||
COALESCE(MAX(NULLIF(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,
|
||
2 AS src_rank
|
||
FROM mk_product_performance_sales_daily
|
||
WHERE upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
GROUP BY product_code, color_code, yaka_kodu
|
||
) x
|
||
ORDER BY product_code, color_code, yaka_kodu, src_rank
|
||
),
|
||
StockOnly AS (
|
||
SELECT
|
||
s.product_code,
|
||
s.color_code,
|
||
s.yaka_kodu,
|
||
'STOK'::text AS market_key,
|
||
COALESCE(MAX(d.item_description),'') AS item_description,
|
||
COALESCE(MAX(d.kategori),'') AS kategori,
|
||
COALESCE(MAX(d.seri),'') AS seri,
|
||
COALESCE(MAX(d.yas_grubu),'') AS yas_grubu,
|
||
COALESCE(MAX(NULLIF(d.askili_yan, '-')),'') AS askili_yan,
|
||
COALESCE(MAX(d.urun_ilk_grubu),'') AS urun_ilk_grubu,
|
||
COALESCE(MAX(d.urun_ana_grubu),'') AS urun_ana_grubu,
|
||
COALESCE(MAX(d.urun_alt_grubu),'') AS urun_alt_grubu,
|
||
NULL::date AS first_sale_date,
|
||
NULL::date AS last_sale_date,
|
||
''::text AS last_ref_number,
|
||
0::numeric AS sales_qty_total,
|
||
0::numeric AS sales_usd_total,
|
||
0::integer AS customer_count_total,
|
||
0::integer AS invoice_count_total
|
||
FROM mk_product_performance_stock_daily s
|
||
LEFT JOIN Dim d
|
||
ON d.product_code = s.product_code
|
||
AND d.color_code = s.color_code
|
||
AND d.yaka_kodu = s.yaka_kodu
|
||
WHERE s.stock_date = (SELECT stock_date FROM LatestStockDate)
|
||
AND upper(btrim(COALESCE(d.urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
AND NOT EXISTS (
|
||
SELECT 1
|
||
FROM SalesAgg a
|
||
WHERE a.product_code = s.product_code
|
||
AND a.color_code = s.color_code
|
||
AND a.yaka_kodu = s.yaka_kodu
|
||
)
|
||
GROUP BY s.product_code, s.color_code, s.yaka_kodu
|
||
),
|
||
BaseRows AS (
|
||
SELECT * FROM SalesAgg
|
||
UNION ALL
|
||
SELECT * FROM StockOnly
|
||
),
|
||
Spread AS (
|
||
SELECT
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
COUNT(DISTINCT NULLIF(market_key, 'STOK'))::integer AS market_count_total,
|
||
COUNT(DISTINCT NULLIF(customer_code, '-'))::integer AS customer_count_total_all
|
||
FROM mk_product_performance_sales_daily, Bounds
|
||
WHERE sales_date BETWEEN Bounds.period_start AND Bounds.period_end
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
GROUP BY product_code, color_code, yaka_kodu
|
||
),
|
||
Scored AS (
|
||
SELECT
|
||
Bounds.period_start,
|
||
Bounds.period_end,
|
||
b.product_code,
|
||
b.color_code,
|
||
b.yaka_kodu,
|
||
b.item_description,
|
||
b.kategori,
|
||
b.seri,
|
||
b.yas_grubu,
|
||
b.askili_yan,
|
||
b.urun_ilk_grubu,
|
||
b.urun_ana_grubu,
|
||
b.urun_alt_grubu,
|
||
b.market_key,
|
||
COALESCE(st.stock_qty, 0) AS stock_qty,
|
||
b.sales_qty_total,
|
||
b.sales_usd_total,
|
||
b.sales_qty_total / GREATEST(1, (Bounds.period_end - Bounds.period_start + 1)) AS avg_daily_sales_total,
|
||
CASE
|
||
WHEN b.sales_qty_total <= 0 THEN 9999
|
||
ELSE ((COALESCE(st_start.stock_qty, 0) + COALESCE(st.stock_qty, 0)) / 2.0) / NULLIF(b.sales_qty_total / GREATEST(1, (Bounds.period_end - Bounds.period_start + 1)), 0)
|
||
END AS stock_days_total,
|
||
CASE WHEN b.sales_qty_total <= 0 THEN 0 ELSE b.sales_usd_total / NULLIF(b.sales_qty_total,0) END AS avg_price_usd_total,
|
||
COALESCE(pd.cost_price_usd,0) AS cost_price_usd,
|
||
COALESCE(pd.base_price_usd,0) AS base_price_usd,
|
||
b.sales_usd_total - (b.sales_qty_total * COALESCE(pd.cost_price_usd,0)) AS gross_profit_usd_total,
|
||
CASE WHEN b.sales_usd_total <= 0 THEN 0 ELSE (b.sales_usd_total - (b.sales_qty_total * COALESCE(pd.cost_price_usd,0))) / NULLIF(b.sales_usd_total,0) END AS gross_margin_total,
|
||
CASE WHEN b.sales_qty_total <= 0 THEN 0 ELSE (b.sales_usd_total / NULLIF(b.sales_qty_total,0)) - COALESCE(pd.cost_price_usd,0) END AS unit_profit_cost_total,
|
||
CASE WHEN b.sales_qty_total <= 0 THEN 0 ELSE (b.sales_usd_total / NULLIF(b.sales_qty_total,0)) - COALESCE(pd.base_price_usd,0) END AS unit_profit_base_total,
|
||
COALESCE(sp.market_count_total,0) AS market_count_total,
|
||
COALESCE(sp.customer_count_total_all, b.customer_count_total) AS customer_count_total,
|
||
b.invoice_count_total,
|
||
CASE
|
||
WHEN AVG(b.sales_qty_total) OVER (PARTITION BY b.market_key, b.kategori, b.urun_ana_grubu) <= 0 THEN 0
|
||
ELSE b.sales_qty_total / NULLIF(AVG(b.sales_qty_total) OVER (PARTITION BY b.market_key, b.kategori, b.urun_ana_grubu),0)
|
||
END AS sales_index_total,
|
||
b.first_sale_date,
|
||
b.last_sale_date,
|
||
b.last_ref_number
|
||
FROM BaseRows b
|
||
CROSS JOIN Bounds
|
||
LEFT JOIN StockAgg st
|
||
ON st.product_code = b.product_code
|
||
AND st.color_code = b.color_code
|
||
AND st.yaka_kodu = b.yaka_kodu
|
||
LEFT JOIN StockTotalStart st_start
|
||
ON st_start.product_code = b.product_code
|
||
AND st_start.color_code = b.color_code
|
||
AND st_start.yaka_kodu = b.yaka_kodu
|
||
LEFT JOIN mk_product_performance_price_dim pd ON pd.product_code = b.product_code
|
||
LEFT JOIN Spread sp
|
||
ON sp.product_code = b.product_code
|
||
AND sp.color_code = b.color_code
|
||
AND sp.yaka_kodu = b.yaka_kodu
|
||
)
|
||
SELECT
|
||
to_char(period_start,'YYYY-MM-DD'),
|
||
to_char(period_end,'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_total, sales_usd_total, avg_daily_sales_total, stock_days_total, avg_price_usd_total,
|
||
cost_price_usd, base_price_usd, gross_profit_usd_total, gross_margin_total, unit_profit_cost_total, unit_profit_base_total,
|
||
market_count_total, customer_count_total, invoice_count_total, sales_index_total,
|
||
ROUND((
|
||
LEAST(35, GREATEST(0, sales_index_total) * 18)
|
||
+ LEAST(25, GREATEST(0, gross_margin_total) * 50)
|
||
+ LEAST(20, customer_count_total * 1.5)
|
||
+ LEAST(10, market_count_total * 2.5)
|
||
+ CASE
|
||
WHEN sales_qty_total > 0 AND stock_days_total BETWEEN 20 AND 180 THEN 10
|
||
WHEN sales_qty_total > 0 AND stock_days_total > 365 THEN -10
|
||
WHEN sales_qty_total = 0 AND stock_qty > 0 THEN -15
|
||
ELSE 0
|
||
END
|
||
)::numeric, 4) AS performance_score,
|
||
CASE
|
||
WHEN sales_qty_total > 0 AND stock_qty <= 0 AND sales_index_total >= 1 THEN 'STOKSUZ_TALEP'
|
||
WHEN sales_qty_total = 0 AND stock_qty > 0 THEN 'STOK_RISKI'
|
||
WHEN gross_margin_total < 0 THEN 'FIYAT_BASKISI'
|
||
WHEN sales_index_total >= 1.4 AND gross_margin_total >= 0.25 THEN 'YILDIZ_URUN'
|
||
WHEN gross_margin_total >= 0.35 AND sales_index_total < 0.8 THEN 'FIYAT_FIRSATI'
|
||
ELSE 'TAKIP'
|
||
END AS performance_bucket,
|
||
CASE
|
||
WHEN sales_qty_total > 0 AND stock_qty <= 0 THEN 'Talep var, stok yok. Uretim/satin alma onceligi ver.'
|
||
WHEN sales_qty_total = 0 AND stock_qty > 0 THEN 'Satis yok, stok maliyeti tasiyor. Piyasa/fiyat aksiyonu gerekli.'
|
||
WHEN gross_margin_total < 0 THEN 'Ciplak maliyet altinda satis var. Fiyat veya maliyet kontrol edilmeli.'
|
||
WHEN sales_index_total >= 1.4 AND gross_margin_total >= 0.25 THEN 'Genel donemde guclu urun. Stok ve fiyat korunmali.'
|
||
WHEN gross_margin_total >= 0.35 AND sales_index_total < 0.8 THEN 'Karli ama yavas. Dogru piyasada satis firsati var.'
|
||
ELSE 'Izleme ve piyasa bazli aksiyon.'
|
||
END AS recommendation,
|
||
COALESCE(to_char(first_sale_date,'YYYY-MM-DD'),''),
|
||
COALESCE(to_char(last_sale_date,'YYYY-MM-DD'),''),
|
||
COALESCE(last_ref_number,'')
|
||
FROM Scored
|
||
ORDER BY performance_score DESC, sales_usd_total DESC, product_code ASC, color_code ASC, yaka_kodu ASC
|
||
LIMIT $1
|
||
`, limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
out := make([]models.ProductPerformanceGeneralRow, 0, limit)
|
||
colorCodes := make([]string, 0, limit)
|
||
for rows.Next() {
|
||
var r models.ProductPerformanceGeneralRow
|
||
if err := rows.Scan(
|
||
&r.PeriodStart, &r.PeriodEnd, &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.SalesQtyTotal, &r.SalesUSDTotal, &r.AvgDailySalesTotal, &r.StockDaysTotal, &r.AvgPriceUSDTotal,
|
||
&r.CostPriceUSD, &r.BasePriceUSD, &r.GrossProfitUSDTotal, &r.GrossMarginTotal, &r.UnitProfitCostTotal, &r.UnitProfitBaseTotal,
|
||
&r.MarketCountTotal, &r.CustomerCountTotal, &r.InvoiceCountTotal, &r.SalesIndexTotal, &r.PerformanceScore,
|
||
&r.PerformanceBucket, &r.Recommendation, &r.FirstSaleDate, &r.LastSaleDate, &r.LastRefNumber,
|
||
); err != nil {
|
||
return nil, err
|
||
}
|
||
r.UrunIlkGrubu = cleanProductPerformanceFirstGroup(r.UrunIlkGrubu)
|
||
colorCodes = append(colorCodes, r.ColorCode)
|
||
out = append(out, r)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
colorDescriptions := productPerformanceColorDescriptions(ctx, colorCodes)
|
||
for i := range out {
|
||
out[i].ColorDescription = colorDescriptions[normalizeProductPerformanceCode(out[i].ColorCode)]
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func ListProductPerformanceOrderAnalysis(ctx context.Context, pg *sql.DB, limit int) ([]models.ProductPerformanceOrderAnalysisRow, error) {
|
||
if db.MssqlDB == nil {
|
||
return nil, fmt.Errorf("mssql db nil")
|
||
}
|
||
if err := EnsureProductPerformanceTables(pg); err != nil {
|
||
return nil, err
|
||
}
|
||
if limit <= 0 {
|
||
limit = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
|
||
rows, err := db.MssqlDB.QueryContext(ctx, `
|
||
WITH OpenOrderLines AS (
|
||
SELECT
|
||
OrderDate = CAST(h.OrderDate AS date),
|
||
DueDate = CAST(ISNULL(l.DeliveryDate, h.AverageDueDate) AS date),
|
||
h.OrderHeaderID,
|
||
h.OrderNumber,
|
||
h.CurrAccCode,
|
||
ProductCode = UPPER(LTRIM(RTRIM(l.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(l.ColorCode, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(l.ItemDim2Code, '')))),
|
||
ItemDescription = dbo.HG_Temizlik(ISNULL((
|
||
SELECT ItemDescription
|
||
FROM cdItemDesc WITH(NOLOCK)
|
||
WHERE cdItemDesc.ItemTypeCode = l.ItemTypeCode
|
||
AND cdItemDesc.ItemCode = l.ItemCode
|
||
AND cdItemDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
Kategori = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription
|
||
FROM cdItemAttributeDesc WITH(NOLOCK)
|
||
WHERE cdItemAttributeDesc.ItemTypeCode = l.ItemTypeCode
|
||
AND cdItemAttributeDesc.AttributeTypeCode = 44
|
||
AND cdItemAttributeDesc.AttributeCode = (
|
||
SELECT TOP 1 AttributeCode
|
||
FROM prItemAttribute WITH(NOLOCK)
|
||
WHERE AttributeTypeCode = 44
|
||
AND prItemAttribute.ItemTypeCode = l.ItemTypeCode
|
||
AND prItemAttribute.ItemCode = l.ItemCode
|
||
)
|
||
AND cdItemAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
Seri = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription
|
||
FROM cdItemAttributeDesc WITH(NOLOCK)
|
||
WHERE cdItemAttributeDesc.ItemTypeCode = l.ItemTypeCode
|
||
AND cdItemAttributeDesc.AttributeTypeCode = 2
|
||
AND cdItemAttributeDesc.AttributeCode = (
|
||
SELECT TOP 1 AttributeCode
|
||
FROM prItemAttribute WITH(NOLOCK)
|
||
WHERE AttributeTypeCode = 2
|
||
AND prItemAttribute.ItemTypeCode = l.ItemTypeCode
|
||
AND prItemAttribute.ItemCode = l.ItemCode
|
||
)
|
||
AND cdItemAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
YasGrubu = '',
|
||
UrunIlkGrubu = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription
|
||
FROM cdItemAttributeDesc WITH(NOLOCK)
|
||
WHERE cdItemAttributeDesc.ItemTypeCode = l.ItemTypeCode
|
||
AND cdItemAttributeDesc.AttributeTypeCode = 42
|
||
AND cdItemAttributeDesc.AttributeCode = (
|
||
SELECT TOP 1 AttributeCode
|
||
FROM prItemAttribute WITH(NOLOCK)
|
||
WHERE AttributeTypeCode = 42
|
||
AND prItemAttribute.ItemTypeCode = l.ItemTypeCode
|
||
AND prItemAttribute.ItemCode = l.ItemCode
|
||
)
|
||
AND cdItemAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
AskiliYan = dbo.HG_Temizlik(ISNULL((
|
||
SELECT TOP 1 ProductAtt45
|
||
FROM ProductAttributesFilter WITH(NOLOCK)
|
||
WHERE ProductAttributesFilter.ItemCode = l.ItemCode
|
||
), SPACE(0))),
|
||
UrunAnaGrubu = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription
|
||
FROM cdItemAttributeDesc WITH(NOLOCK)
|
||
WHERE cdItemAttributeDesc.ItemTypeCode = l.ItemTypeCode
|
||
AND cdItemAttributeDesc.AttributeTypeCode = 1
|
||
AND cdItemAttributeDesc.AttributeCode = (
|
||
SELECT TOP 1 AttributeCode
|
||
FROM prItemAttribute WITH(NOLOCK)
|
||
WHERE AttributeTypeCode = 1
|
||
AND prItemAttribute.ItemTypeCode = l.ItemTypeCode
|
||
AND prItemAttribute.ItemCode = l.ItemCode
|
||
)
|
||
AND cdItemAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
UrunAltGrubu = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription
|
||
FROM cdItemAttributeDesc WITH(NOLOCK)
|
||
WHERE cdItemAttributeDesc.ItemTypeCode = l.ItemTypeCode
|
||
AND cdItemAttributeDesc.AttributeTypeCode = 2
|
||
AND cdItemAttributeDesc.AttributeCode = (
|
||
SELECT TOP 1 AttributeCode
|
||
FROM prItemAttribute WITH(NOLOCK)
|
||
WHERE AttributeTypeCode = 2
|
||
AND prItemAttribute.ItemTypeCode = l.ItemTypeCode
|
||
AND prItemAttribute.ItemCode = l.ItemCode
|
||
)
|
||
AND cdItemAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
MarketKey = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription
|
||
FROM cdCurrAccAttributeDesc WITH(NOLOCK)
|
||
WHERE cdCurrAccAttributeDesc.CurrAccTypeCode = 3
|
||
AND cdCurrAccAttributeDesc.AttributeTypeCode = 1
|
||
AND cdCurrAccAttributeDesc.AttributeCode = caf.CustomerAtt01
|
||
AND cdCurrAccAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
Qty = ISNULL(l.Qty1, 0),
|
||
AmountUSD = CASE
|
||
WHEN h.DocCurrencyCode = 'USD' THEN ISNULL(c.NetAmount, 0)
|
||
WHEN h.DocCurrencyCode = 'TRY' AND usd.Rate > 0 THEN ISNULL(c.NetAmount, 0) / usd.Rate
|
||
WHEN h.DocCurrencyCode IN ('EUR', 'GBP') AND cur.Rate > 0 AND usd.Rate > 0 THEN (ISNULL(c.NetAmount, 0) * cur.Rate) / usd.Rate
|
||
ELSE 0
|
||
END
|
||
FROM dbo.trOrderHeader h WITH(NOLOCK)
|
||
INNER JOIN dbo.trOrderLine l WITH(NOLOCK)
|
||
ON l.OrderHeaderID = h.OrderHeaderID
|
||
LEFT JOIN dbo.trOrderLineCurrency c WITH(NOLOCK)
|
||
ON c.OrderLineID = l.OrderLineID
|
||
AND c.CurrencyCode = ISNULL(h.DocCurrencyCode, 'TRY')
|
||
LEFT JOIN dbo.CustomerAttributesFilter caf WITH(NOLOCK)
|
||
ON caf.CurrAccTypeCode = h.CurrAccTypeCode
|
||
AND caf.CurrAccCode = h.CurrAccCode
|
||
OUTER APPLY (
|
||
SELECT TOP 1 Rate
|
||
FROM dbo.AllExchangeRates WITH(NOLOCK)
|
||
WHERE CurrencyCode = 'USD'
|
||
AND RelationCurrencyCode = 'TRY'
|
||
AND ExchangeTypeCode = 6
|
||
AND Rate > 0
|
||
AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date)
|
||
ORDER BY Date DESC
|
||
) usd
|
||
OUTER APPLY (
|
||
SELECT TOP 1 Rate
|
||
FROM dbo.AllExchangeRates WITH(NOLOCK)
|
||
WHERE CurrencyCode = h.DocCurrencyCode
|
||
AND RelationCurrencyCode = 'TRY'
|
||
AND ExchangeTypeCode = 6
|
||
AND Rate > 0
|
||
AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date)
|
||
ORDER BY Date DESC
|
||
) cur
|
||
WHERE ISNULL(h.IsCancelOrder, 0) = 0
|
||
AND ISNULL(h.IsClosed, 0) = 0
|
||
AND h.OrderTypeCode = 1
|
||
AND h.ProcessCode = 'WS'
|
||
AND ISNULL(l.IsClosed, 0) = 0
|
||
AND l.ItemTypeCode = 1
|
||
AND ISNULL(l.Qty1, 0) > 0
|
||
AND LEN(LTRIM(RTRIM(l.ItemCode))) = 13
|
||
),
|
||
Spread AS (
|
||
SELECT
|
||
ProductCode,
|
||
ColorCode,
|
||
YakaKodu,
|
||
MarketCount = COUNT(DISTINCT NULLIF(MarketKey, '')),
|
||
CustomerCount = COUNT(DISTINCT NULLIF(CurrAccCode, ''))
|
||
FROM OpenOrderLines
|
||
GROUP BY ProductCode, ColorCode, YakaKodu
|
||
)
|
||
SELECT TOP (@p1)
|
||
o.ProductCode,
|
||
o.ColorCode,
|
||
o.YakaKodu,
|
||
ItemDescription = MAX(o.ItemDescription),
|
||
Kategori = MAX(o.Kategori),
|
||
Seri = MAX(o.Seri),
|
||
YasGrubu = MAX(o.YasGrubu),
|
||
AskiliYan = ISNULL(NULLIF(MAX(o.AskiliYan), '-'), ''),
|
||
UrunIlkGrubu = MAX(o.UrunIlkGrubu),
|
||
UrunAnaGrubu = MAX(o.UrunAnaGrubu),
|
||
UrunAltGrubu = MAX(o.UrunAltGrubu),
|
||
o.MarketKey,
|
||
OrderQty = SUM(o.Qty),
|
||
OrderUSD = SUM(o.AmountUSD),
|
||
AvgOrderPriceUSD = CASE WHEN SUM(o.Qty) = 0 THEN 0 ELSE SUM(o.AmountUSD) / NULLIF(SUM(o.Qty), 0) END,
|
||
MarketCount = MAX(s.MarketCount),
|
||
CustomerCount = COUNT(DISTINCT NULLIF(o.CurrAccCode, '')),
|
||
OrderCount = COUNT(DISTINCT o.OrderHeaderID),
|
||
LineCount = COUNT(*),
|
||
FirstOrderDate = CONVERT(varchar, MIN(o.OrderDate), 23),
|
||
LastOrderDate = CONVERT(varchar, MAX(o.OrderDate), 23),
|
||
EarliestDueDate = CONVERT(varchar, MIN(o.DueDate), 23),
|
||
OverdueQty = SUM(CASE WHEN o.DueDate < CAST(GETDATE() AS date) THEN o.Qty ELSE 0 END)
|
||
FROM OpenOrderLines o
|
||
LEFT JOIN Spread s
|
||
ON s.ProductCode = o.ProductCode
|
||
AND s.ColorCode = o.ColorCode
|
||
AND s.YakaKodu = o.YakaKodu
|
||
GROUP BY o.ProductCode, o.ColorCode, o.YakaKodu, o.MarketKey
|
||
ORDER BY SUM(o.AmountUSD) DESC, SUM(o.Qty) DESC, o.ProductCode, o.ColorCode, o.YakaKodu
|
||
`, limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
|
||
out := make([]models.ProductPerformanceOrderAnalysisRow, 0, limit)
|
||
productCodes := make([]string, 0, limit)
|
||
stockKeys := make([]string, 0, limit)
|
||
colorCodes := make([]string, 0, limit)
|
||
seenProducts := map[string]bool{}
|
||
seenStockKeys := map[string]bool{}
|
||
for rows.Next() {
|
||
var r models.ProductPerformanceOrderAnalysisRow
|
||
if err := rows.Scan(
|
||
&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.OrderQty, &r.OrderUSD, &r.AvgOrderPriceUSD,
|
||
&r.MarketCount, &r.CustomerCount, &r.OrderCount, &r.LineCount, &r.FirstOrderDate, &r.LastOrderDate, &r.EarliestDueDate, &r.OverdueQty,
|
||
); err != nil {
|
||
return nil, err
|
||
}
|
||
normalizeProductPerformanceVariantCodes(&r.ProductCode, &r.ColorCode, &r.YakaKodu)
|
||
r.AskiliYan = cleanProductPerformanceOptionalAttr(r.AskiliYan)
|
||
colorCodes = append(colorCodes, r.ColorCode)
|
||
out = append(out, r)
|
||
if !seenProducts[r.ProductCode] {
|
||
seenProducts[r.ProductCode] = true
|
||
productCodes = append(productCodes, r.ProductCode)
|
||
}
|
||
key := productPerformanceVariantKey(r.ProductCode, r.ColorCode, r.YakaKodu)
|
||
if !seenStockKeys[key] {
|
||
seenStockKeys[key] = true
|
||
stockKeys = append(stockKeys, key)
|
||
}
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
priceByProduct, err := productPerformancePriceLookup(ctx, pg, productCodes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
stockByKey, err := productPerformanceStockLookup(ctx, pg, stockKeys)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
attrByKey, err := productPerformanceAttrLookup(ctx, pg, stockKeys)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
colorDescriptions := productPerformanceColorDescriptions(ctx, colorCodes)
|
||
filtered := out[:0]
|
||
for i := range out {
|
||
row := &out[i]
|
||
price := priceByProduct[normalizeProductPerformanceProductCode(row.ProductCode)]
|
||
attr := attrByKey[productPerformanceVariantKey(row.ProductCode, row.ColorCode, row.YakaKodu)]
|
||
if isExcludedProductPerformanceFirstGroup(attr.urunIlkGrubu) {
|
||
continue
|
||
}
|
||
if strings.TrimSpace(row.ItemDescription) == "" {
|
||
row.ItemDescription = attr.itemDescription
|
||
}
|
||
if strings.TrimSpace(row.Kategori) == "" {
|
||
row.Kategori = attr.kategori
|
||
}
|
||
row.AskiliYan = cleanProductPerformanceOptionalAttr(row.AskiliYan)
|
||
if strings.TrimSpace(row.AskiliYan) == "" {
|
||
row.AskiliYan = cleanProductPerformanceOptionalAttr(attr.askiliYan)
|
||
}
|
||
if strings.TrimSpace(row.UrunIlkGrubu) == "" {
|
||
row.UrunIlkGrubu = attr.urunIlkGrubu
|
||
}
|
||
if strings.TrimSpace(row.UrunAnaGrubu) == "" {
|
||
row.UrunAnaGrubu = attr.urunAnaGrubu
|
||
}
|
||
if strings.TrimSpace(row.UrunAltGrubu) == "" {
|
||
row.UrunAltGrubu = attr.urunAltGrubu
|
||
}
|
||
row.CostPriceUSD = price.cost
|
||
row.BasePriceUSD = price.base
|
||
row.StockQty = stockByKey[productPerformanceVariantKey(row.ProductCode, row.ColorCode, row.YakaKodu)]
|
||
row.NetStockAfterOrder = row.StockQty - row.OrderQty
|
||
row.UnitProfitCostUSD = row.AvgOrderPriceUSD - row.CostPriceUSD
|
||
row.UnitProfitBaseUSD = row.AvgOrderPriceUSD - row.BasePriceUSD
|
||
row.ExpectedProfitCostUSD = row.UnitProfitCostUSD * row.OrderQty
|
||
row.ExpectedProfitBaseUSD = row.UnitProfitBaseUSD * row.OrderQty
|
||
if row.OrderUSD != 0 {
|
||
row.ExpectedMarginCost = row.ExpectedProfitCostUSD / row.OrderUSD
|
||
}
|
||
row.ColorDescription = colorDescriptions[normalizeProductPerformanceCode(row.ColorCode)]
|
||
row.PerformanceBucket, row.Recommendation = productPerformanceOrderRecommendation(*row)
|
||
filtered = append(filtered, *row)
|
||
}
|
||
return filtered, nil
|
||
}
|
||
|
||
func ListProductPerformanceOrderGroups(ctx context.Context, pg *sql.DB, breakdown string, limit int) ([]models.ProductPerformanceOrderGroupRow, error) {
|
||
if db.MssqlDB == nil {
|
||
return nil, fmt.Errorf("mssql db nil")
|
||
}
|
||
if err := EnsureProductPerformanceTables(pg); err != nil {
|
||
return nil, err
|
||
}
|
||
mode := strings.ToLower(strings.TrimSpace(breakdown))
|
||
if mode != "customer" {
|
||
mode = "market"
|
||
}
|
||
if limit <= 0 {
|
||
limit = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
|
||
rows, err := db.MssqlDB.QueryContext(ctx, `
|
||
WITH OpenOrderLines AS (
|
||
SELECT
|
||
h.OrderHeaderID,
|
||
h.CurrAccCode,
|
||
CustomerName = ISNULL(cad.CurrAccDescription, ''),
|
||
ProductCode = UPPER(LTRIM(RTRIM(l.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(l.ColorCode, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(l.ItemDim2Code, '')))),
|
||
MarketKey = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription
|
||
FROM cdCurrAccAttributeDesc WITH(NOLOCK)
|
||
WHERE cdCurrAccAttributeDesc.CurrAccTypeCode = 3
|
||
AND cdCurrAccAttributeDesc.AttributeTypeCode = 1
|
||
AND cdCurrAccAttributeDesc.AttributeCode = caf.CustomerAtt01
|
||
AND cdCurrAccAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
Qty = ISNULL(l.Qty1, 0),
|
||
AmountUSD = CASE
|
||
WHEN h.DocCurrencyCode = 'USD' THEN ISNULL(c.NetAmount, 0)
|
||
WHEN h.DocCurrencyCode = 'TRY' AND usd.Rate > 0 THEN ISNULL(c.NetAmount, 0) / usd.Rate
|
||
WHEN h.DocCurrencyCode IN ('EUR', 'GBP') AND cur.Rate > 0 AND usd.Rate > 0 THEN (ISNULL(c.NetAmount, 0) * cur.Rate) / usd.Rate
|
||
ELSE 0
|
||
END,
|
||
DueDate = CAST(ISNULL(l.DeliveryDate, h.AverageDueDate) AS date)
|
||
FROM dbo.trOrderHeader h WITH(NOLOCK)
|
||
INNER JOIN dbo.trOrderLine l WITH(NOLOCK)
|
||
ON l.OrderHeaderID = h.OrderHeaderID
|
||
LEFT JOIN dbo.trOrderLineCurrency c WITH(NOLOCK)
|
||
ON c.OrderLineID = l.OrderLineID
|
||
AND c.CurrencyCode = ISNULL(h.DocCurrencyCode, 'TRY')
|
||
LEFT JOIN dbo.CustomerAttributesFilter caf WITH(NOLOCK)
|
||
ON caf.CurrAccTypeCode = h.CurrAccTypeCode
|
||
AND caf.CurrAccCode = h.CurrAccCode
|
||
LEFT JOIN dbo.cdCurrAccDesc cad WITH(NOLOCK)
|
||
ON cad.CurrAccTypeCode = h.CurrAccTypeCode
|
||
AND cad.CurrAccCode = h.CurrAccCode
|
||
AND cad.LangCode = 'TR'
|
||
OUTER APPLY (
|
||
SELECT TOP 1 Rate
|
||
FROM dbo.AllExchangeRates WITH(NOLOCK)
|
||
WHERE CurrencyCode = 'USD'
|
||
AND RelationCurrencyCode = 'TRY'
|
||
AND ExchangeTypeCode = 6
|
||
AND Rate > 0
|
||
AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date)
|
||
ORDER BY Date DESC
|
||
) usd
|
||
OUTER APPLY (
|
||
SELECT TOP 1 Rate
|
||
FROM dbo.AllExchangeRates WITH(NOLOCK)
|
||
WHERE CurrencyCode = h.DocCurrencyCode
|
||
AND RelationCurrencyCode = 'TRY'
|
||
AND ExchangeTypeCode = 6
|
||
AND Rate > 0
|
||
AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date)
|
||
ORDER BY Date DESC
|
||
) cur
|
||
WHERE ISNULL(h.IsCancelOrder, 0) = 0
|
||
AND ISNULL(h.IsClosed, 0) = 0
|
||
AND h.OrderTypeCode = 1
|
||
AND h.ProcessCode = 'WS'
|
||
AND ISNULL(l.IsClosed, 0) = 0
|
||
AND l.ItemTypeCode = 1
|
||
AND ISNULL(l.Qty1, 0) > 0
|
||
AND LEN(LTRIM(RTRIM(l.ItemCode))) = 13
|
||
)
|
||
SELECT TOP (@p1)
|
||
ProductCode,
|
||
ColorCode,
|
||
YakaKodu,
|
||
MarketKey,
|
||
CurrAccCode,
|
||
CustomerName,
|
||
OrderQty = SUM(Qty),
|
||
OrderUSD = SUM(AmountUSD),
|
||
OrderCount = COUNT(DISTINCT OrderHeaderID),
|
||
LineCount = COUNT(*),
|
||
OverdueQty = SUM(CASE WHEN DueDate < CAST(GETDATE() AS date) THEN Qty ELSE 0 END)
|
||
FROM OpenOrderLines
|
||
GROUP BY ProductCode, ColorCode, YakaKodu, MarketKey, CurrAccCode, CustomerName
|
||
ORDER BY SUM(AmountUSD) DESC, SUM(Qty) DESC
|
||
`, limit*4)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
|
||
type detail struct {
|
||
productCode string
|
||
colorCode string
|
||
yakaKodu string
|
||
marketKey string
|
||
customerCode string
|
||
customerName string
|
||
orderQty float64
|
||
orderUSD float64
|
||
orderCount int
|
||
lineCount int
|
||
overdueQty float64
|
||
}
|
||
details := make([]detail, 0, limit*2)
|
||
productCodes := make([]string, 0, limit)
|
||
stockKeys := make([]string, 0, limit)
|
||
seenProducts := map[string]bool{}
|
||
seenStockKeys := map[string]bool{}
|
||
for rows.Next() {
|
||
var d detail
|
||
if err := rows.Scan(&d.productCode, &d.colorCode, &d.yakaKodu, &d.marketKey, &d.customerCode, &d.customerName, &d.orderQty, &d.orderUSD, &d.orderCount, &d.lineCount, &d.overdueQty); err != nil {
|
||
return nil, err
|
||
}
|
||
normalizeProductPerformanceVariantCodes(&d.productCode, &d.colorCode, &d.yakaKodu)
|
||
details = append(details, d)
|
||
if !seenProducts[d.productCode] {
|
||
seenProducts[d.productCode] = true
|
||
productCodes = append(productCodes, d.productCode)
|
||
}
|
||
key := productPerformanceVariantKey(d.productCode, d.colorCode, d.yakaKodu)
|
||
if !seenStockKeys[key] {
|
||
seenStockKeys[key] = true
|
||
stockKeys = append(stockKeys, key)
|
||
}
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
priceByProduct, err := productPerformancePriceLookup(ctx, pg, productCodes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
stockByKey, err := productPerformanceStockLookup(ctx, pg, stockKeys)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
grouped := map[string]*models.ProductPerformanceOrderGroupRow{}
|
||
productSets := map[string]map[string]bool{}
|
||
marketSets := map[string]map[string]bool{}
|
||
customerSets := map[string]map[string]bool{}
|
||
stockVariantSets := map[string]map[string]bool{}
|
||
for _, d := range details {
|
||
groupKey := strings.TrimSpace(d.marketKey)
|
||
customerCode := ""
|
||
customerName := ""
|
||
if mode == "customer" {
|
||
groupKey = strings.TrimSpace(d.customerCode)
|
||
customerCode = strings.TrimSpace(d.customerCode)
|
||
customerName = strings.TrimSpace(d.customerName)
|
||
}
|
||
if groupKey == "" {
|
||
groupKey = "-"
|
||
}
|
||
row := grouped[groupKey]
|
||
if row == nil {
|
||
row = &models.ProductPerformanceOrderGroupRow{
|
||
Breakdown: mode,
|
||
GroupKey: groupKey,
|
||
MarketKey: strings.TrimSpace(d.marketKey),
|
||
CustomerCode: customerCode,
|
||
CustomerName: customerName,
|
||
}
|
||
grouped[groupKey] = row
|
||
productSets[groupKey] = map[string]bool{}
|
||
marketSets[groupKey] = map[string]bool{}
|
||
customerSets[groupKey] = map[string]bool{}
|
||
stockVariantSets[groupKey] = map[string]bool{}
|
||
}
|
||
price := priceByProduct[normalizeProductPerformanceProductCode(d.productCode)]
|
||
variantKey := productPerformanceVariantKey(d.productCode, d.colorCode, d.yakaKodu)
|
||
row.OrderQty += d.orderQty
|
||
row.OrderUSD += d.orderUSD
|
||
row.BaseCostUSD += d.orderQty * price.base
|
||
row.CostAmountUSD += d.orderQty * price.cost
|
||
if !stockVariantSets[groupKey][variantKey] {
|
||
row.StockQty += stockByKey[variantKey]
|
||
stockVariantSets[groupKey][variantKey] = true
|
||
}
|
||
row.OrderCount += d.orderCount
|
||
row.LineCount += d.lineCount
|
||
row.OverdueQty += d.overdueQty
|
||
productSets[groupKey][d.productCode] = true
|
||
if strings.TrimSpace(d.marketKey) != "" {
|
||
marketSets[groupKey][strings.TrimSpace(d.marketKey)] = true
|
||
}
|
||
if strings.TrimSpace(d.customerCode) != "" {
|
||
customerSets[groupKey][strings.TrimSpace(d.customerCode)] = true
|
||
}
|
||
}
|
||
|
||
out := make([]models.ProductPerformanceOrderGroupRow, 0, len(grouped))
|
||
for key, row := range grouped {
|
||
row.ProductCount = len(productSets[key])
|
||
row.MarketCount = len(marketSets[key])
|
||
row.CustomerCount = len(customerSets[key])
|
||
row.NetStockAfterOrder = row.StockQty - row.OrderQty
|
||
if row.OrderQty != 0 {
|
||
row.AvgOrderPriceUSD = row.OrderUSD / row.OrderQty
|
||
}
|
||
row.ExpectedProfitBaseUSD = row.OrderUSD - row.BaseCostUSD
|
||
row.ExpectedProfitCostUSD = row.OrderUSD - row.CostAmountUSD
|
||
if row.OrderUSD != 0 {
|
||
row.ExpectedMarginBase = row.ExpectedProfitBaseUSD / row.OrderUSD
|
||
row.ExpectedMarginCost = row.ExpectedProfitCostUSD / row.OrderUSD
|
||
}
|
||
row.PerformanceBucket, row.Recommendation = productPerformanceOrderGroupRecommendation(*row)
|
||
out = append(out, *row)
|
||
}
|
||
sort.Slice(out, func(i, j int) bool {
|
||
if out[i].ExpectedProfitCostUSD < 0 && out[j].ExpectedProfitCostUSD >= 0 {
|
||
return true
|
||
}
|
||
if out[i].ExpectedProfitCostUSD >= 0 && out[j].ExpectedProfitCostUSD < 0 {
|
||
return false
|
||
}
|
||
return out[i].OrderUSD > out[j].OrderUSD
|
||
})
|
||
if len(out) > limit {
|
||
out = out[:limit]
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func ListProductPerformanceOrderProductCustomers(ctx context.Context, pg *sql.DB, limit int) ([]models.ProductPerformanceOrderProductCustomerRow, error) {
|
||
if db.MssqlDB == nil {
|
||
return nil, fmt.Errorf("mssql db nil")
|
||
}
|
||
if err := EnsureProductPerformanceTables(pg); err != nil {
|
||
return nil, err
|
||
}
|
||
if limit <= 0 {
|
||
limit = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
rows, err := db.MssqlDB.QueryContext(ctx, `
|
||
WITH OpenOrderLines AS (
|
||
SELECT
|
||
h.OrderHeaderID,
|
||
h.CurrAccCode,
|
||
CustomerName = ISNULL(cad.CurrAccDescription, ''),
|
||
ProductCode = UPPER(LTRIM(RTRIM(l.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(l.ColorCode, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(l.ItemDim2Code, '')))),
|
||
ItemDescription = dbo.HG_Temizlik(ISNULL((SELECT ItemDescription FROM cdItemDesc WITH(NOLOCK) WHERE cdItemDesc.ItemTypeCode = l.ItemTypeCode AND cdItemDesc.ItemCode = l.ItemCode AND cdItemDesc.LangCode = 'TR'), SPACE(0))),
|
||
MarketKey = dbo.HG_Temizlik(ISNULL((
|
||
SELECT AttributeDescription FROM cdCurrAccAttributeDesc WITH(NOLOCK)
|
||
WHERE cdCurrAccAttributeDesc.CurrAccTypeCode = 3
|
||
AND cdCurrAccAttributeDesc.AttributeTypeCode = 1
|
||
AND cdCurrAccAttributeDesc.AttributeCode = caf.CustomerAtt01
|
||
AND cdCurrAccAttributeDesc.LangCode = 'TR'
|
||
), SPACE(0))),
|
||
Qty = ISNULL(l.Qty1, 0),
|
||
AmountUSD = CASE
|
||
WHEN h.DocCurrencyCode = 'USD' THEN ISNULL(c.NetAmount, 0)
|
||
WHEN h.DocCurrencyCode = 'TRY' AND usd.Rate > 0 THEN ISNULL(c.NetAmount, 0) / usd.Rate
|
||
WHEN h.DocCurrencyCode IN ('EUR', 'GBP') AND cur.Rate > 0 AND usd.Rate > 0 THEN (ISNULL(c.NetAmount, 0) * cur.Rate) / usd.Rate
|
||
ELSE 0
|
||
END,
|
||
DueDate = CAST(ISNULL(l.DeliveryDate, h.AverageDueDate) AS date)
|
||
FROM dbo.trOrderHeader h WITH(NOLOCK)
|
||
INNER JOIN dbo.trOrderLine l WITH(NOLOCK) ON l.OrderHeaderID = h.OrderHeaderID
|
||
LEFT JOIN dbo.trOrderLineCurrency c WITH(NOLOCK) ON c.OrderLineID = l.OrderLineID AND c.CurrencyCode = ISNULL(h.DocCurrencyCode, 'TRY')
|
||
LEFT JOIN dbo.CustomerAttributesFilter caf WITH(NOLOCK) ON caf.CurrAccTypeCode = h.CurrAccTypeCode AND caf.CurrAccCode = h.CurrAccCode
|
||
LEFT JOIN dbo.cdCurrAccDesc cad WITH(NOLOCK) ON cad.CurrAccTypeCode = h.CurrAccTypeCode AND cad.CurrAccCode = h.CurrAccCode AND cad.LangCode = 'TR'
|
||
OUTER APPLY (SELECT TOP 1 Rate FROM dbo.AllExchangeRates WITH(NOLOCK) WHERE CurrencyCode = 'USD' AND RelationCurrencyCode = 'TRY' AND ExchangeTypeCode = 6 AND Rate > 0 AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date) ORDER BY Date DESC) usd
|
||
OUTER APPLY (SELECT TOP 1 Rate FROM dbo.AllExchangeRates WITH(NOLOCK) WHERE CurrencyCode = h.DocCurrencyCode AND RelationCurrencyCode = 'TRY' AND ExchangeTypeCode = 6 AND Rate > 0 AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date) ORDER BY Date DESC) cur
|
||
WHERE ISNULL(h.IsCancelOrder, 0) = 0
|
||
AND ISNULL(h.IsClosed, 0) = 0
|
||
AND h.OrderTypeCode = 1
|
||
AND h.ProcessCode = 'WS'
|
||
AND ISNULL(l.IsClosed, 0) = 0
|
||
AND l.ItemTypeCode = 1
|
||
AND ISNULL(l.Qty1, 0) > 0
|
||
AND LEN(LTRIM(RTRIM(l.ItemCode))) = 13
|
||
)
|
||
SELECT TOP (@p1)
|
||
ProductCode, ColorCode, YakaKodu, MAX(ItemDescription), MarketKey, CurrAccCode, CustomerName,
|
||
SUM(Qty), SUM(AmountUSD), CASE WHEN SUM(Qty)=0 THEN 0 ELSE SUM(AmountUSD)/NULLIF(SUM(Qty),0) END,
|
||
COUNT(DISTINCT OrderHeaderID), COUNT(*), SUM(CASE WHEN DueDate < CAST(GETDATE() AS date) THEN Qty ELSE 0 END)
|
||
FROM OpenOrderLines
|
||
GROUP BY ProductCode, ColorCode, YakaKodu, MarketKey, CurrAccCode, CustomerName
|
||
ORDER BY SUM(AmountUSD) DESC, SUM(Qty) DESC
|
||
`, limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
out := make([]models.ProductPerformanceOrderProductCustomerRow, 0, limit)
|
||
productCodes := make([]string, 0, limit)
|
||
stockKeys := make([]string, 0, limit)
|
||
colorCodes := make([]string, 0, limit)
|
||
seenProducts := map[string]bool{}
|
||
seenStockKeys := map[string]bool{}
|
||
for rows.Next() {
|
||
var r models.ProductPerformanceOrderProductCustomerRow
|
||
if err := rows.Scan(&r.ProductCode, &r.ColorCode, &r.YakaKodu, &r.ItemDescription, &r.MarketKey, &r.CustomerCode, &r.CustomerName, &r.OrderQty, &r.OrderUSD, &r.AvgOrderPriceUSD, &r.OrderCount, &r.LineCount, &r.OverdueQty); err != nil {
|
||
return nil, err
|
||
}
|
||
normalizeProductPerformanceVariantCodes(&r.ProductCode, &r.ColorCode, &r.YakaKodu)
|
||
colorCodes = append(colorCodes, r.ColorCode)
|
||
out = append(out, r)
|
||
if !seenProducts[r.ProductCode] {
|
||
seenProducts[r.ProductCode] = true
|
||
productCodes = append(productCodes, r.ProductCode)
|
||
}
|
||
key := productPerformanceVariantKey(r.ProductCode, r.ColorCode, r.YakaKodu)
|
||
if !seenStockKeys[key] {
|
||
seenStockKeys[key] = true
|
||
stockKeys = append(stockKeys, key)
|
||
}
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
priceByProduct, err := productPerformancePriceLookup(ctx, pg, productCodes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
stockByKey, err := productPerformanceStockLookup(ctx, pg, stockKeys)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
attrByKey, err := productPerformanceAttrLookup(ctx, pg, stockKeys)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
colorDescriptions := productPerformanceColorDescriptions(ctx, colorCodes)
|
||
filtered := out[:0]
|
||
for i := range out {
|
||
row := &out[i]
|
||
price := priceByProduct[normalizeProductPerformanceProductCode(row.ProductCode)]
|
||
attr := attrByKey[productPerformanceVariantKey(row.ProductCode, row.ColorCode, row.YakaKodu)]
|
||
if isExcludedProductPerformanceFirstGroup(attr.urunIlkGrubu) {
|
||
continue
|
||
}
|
||
if strings.TrimSpace(row.ItemDescription) == "" {
|
||
row.ItemDescription = attr.itemDescription
|
||
}
|
||
row.Kategori = attr.kategori
|
||
row.AskiliYan = cleanProductPerformanceOptionalAttr(attr.askiliYan)
|
||
row.UrunIlkGrubu = attr.urunIlkGrubu
|
||
row.UrunAnaGrubu = attr.urunAnaGrubu
|
||
row.UrunAltGrubu = attr.urunAltGrubu
|
||
row.CostPriceUSD = price.cost
|
||
row.BasePriceUSD = price.base
|
||
row.StockQty = stockByKey[productPerformanceVariantKey(row.ProductCode, row.ColorCode, row.YakaKodu)]
|
||
row.NetStockAfterOrder = row.StockQty - row.OrderQty
|
||
row.ExpectedProfitBaseUSD = row.OrderUSD - row.OrderQty*row.BasePriceUSD
|
||
row.ExpectedProfitCostUSD = row.OrderUSD - row.OrderQty*row.CostPriceUSD
|
||
if row.OrderUSD != 0 {
|
||
row.ExpectedMarginBase = row.ExpectedProfitBaseUSD / row.OrderUSD
|
||
row.ExpectedMarginCost = row.ExpectedProfitCostUSD / row.OrderUSD
|
||
}
|
||
row.ColorDescription = colorDescriptions[normalizeProductPerformanceCode(row.ColorCode)]
|
||
row.PerformanceBucket, row.Recommendation = productPerformanceOrderProductCustomerRecommendation(*row)
|
||
filtered = append(filtered, *row)
|
||
}
|
||
return filtered, nil
|
||
}
|
||
|
||
func ListProductPerformanceOrderMarketDetails(ctx context.Context, pg *sql.DB, limit int) ([]models.ProductPerformanceOrderMarketDetailRow, error) {
|
||
if db.MssqlDB == nil {
|
||
return nil, fmt.Errorf("mssql db nil")
|
||
}
|
||
if err := EnsureProductPerformanceTables(pg); err != nil {
|
||
return nil, err
|
||
}
|
||
if limit <= 0 {
|
||
limit = 800
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
rows, err := db.MssqlDB.QueryContext(ctx, `
|
||
WITH OpenOrderLines AS (
|
||
SELECT
|
||
MarketKey = dbo.HG_Temizlik(ISNULL((SELECT AttributeDescription FROM cdCurrAccAttributeDesc WITH(NOLOCK) WHERE cdCurrAccAttributeDesc.CurrAccTypeCode = 3 AND cdCurrAccAttributeDesc.AttributeTypeCode = 1 AND cdCurrAccAttributeDesc.AttributeCode = caf.CustomerAtt01 AND cdCurrAccAttributeDesc.LangCode = 'TR'), SPACE(0))),
|
||
h.CurrAccCode,
|
||
CustomerName = ISNULL(cad.CurrAccDescription, ''),
|
||
h.OrderNumber,
|
||
OrderDate = CAST(h.OrderDate AS date),
|
||
DueDate = CAST(ISNULL(l.DeliveryDate, h.AverageDueDate) AS date),
|
||
ProductCode = UPPER(LTRIM(RTRIM(l.ItemCode))),
|
||
ColorCode = UPPER(LTRIM(RTRIM(ISNULL(l.ColorCode, '')))),
|
||
YakaKodu = UPPER(LTRIM(RTRIM(ISNULL(l.ItemDim2Code, '')))),
|
||
ItemDescription = dbo.HG_Temizlik(ISNULL((SELECT ItemDescription FROM cdItemDesc WITH(NOLOCK) WHERE cdItemDesc.ItemTypeCode = l.ItemTypeCode AND cdItemDesc.ItemCode = l.ItemCode AND cdItemDesc.LangCode = 'TR'), SPACE(0))),
|
||
Qty = ISNULL(l.Qty1, 0),
|
||
AmountUSD = CASE
|
||
WHEN h.DocCurrencyCode = 'USD' THEN ISNULL(c.NetAmount, 0)
|
||
WHEN h.DocCurrencyCode = 'TRY' AND usd.Rate > 0 THEN ISNULL(c.NetAmount, 0) / usd.Rate
|
||
WHEN h.DocCurrencyCode IN ('EUR', 'GBP') AND cur.Rate > 0 AND usd.Rate > 0 THEN (ISNULL(c.NetAmount, 0) * cur.Rate) / usd.Rate
|
||
ELSE 0
|
||
END
|
||
FROM dbo.trOrderHeader h WITH(NOLOCK)
|
||
INNER JOIN dbo.trOrderLine l WITH(NOLOCK) ON l.OrderHeaderID = h.OrderHeaderID
|
||
LEFT JOIN dbo.trOrderLineCurrency c WITH(NOLOCK) ON c.OrderLineID = l.OrderLineID AND c.CurrencyCode = ISNULL(h.DocCurrencyCode, 'TRY')
|
||
LEFT JOIN dbo.CustomerAttributesFilter caf WITH(NOLOCK) ON caf.CurrAccTypeCode = h.CurrAccTypeCode AND caf.CurrAccCode = h.CurrAccCode
|
||
LEFT JOIN dbo.cdCurrAccDesc cad WITH(NOLOCK) ON cad.CurrAccTypeCode = h.CurrAccTypeCode AND cad.CurrAccCode = h.CurrAccCode AND cad.LangCode = 'TR'
|
||
OUTER APPLY (SELECT TOP 1 Rate FROM dbo.AllExchangeRates WITH(NOLOCK) WHERE CurrencyCode = 'USD' AND RelationCurrencyCode = 'TRY' AND ExchangeTypeCode = 6 AND Rate > 0 AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date) ORDER BY Date DESC) usd
|
||
OUTER APPLY (SELECT TOP 1 Rate FROM dbo.AllExchangeRates WITH(NOLOCK) WHERE CurrencyCode = h.DocCurrencyCode AND RelationCurrencyCode = 'TRY' AND ExchangeTypeCode = 6 AND Rate > 0 AND Date <= CAST(ISNULL(h.OrderDate, GETDATE()) AS date) ORDER BY Date DESC) cur
|
||
WHERE ISNULL(h.IsCancelOrder, 0) = 0
|
||
AND ISNULL(h.IsClosed, 0) = 0
|
||
AND h.OrderTypeCode = 1
|
||
AND h.ProcessCode = 'WS'
|
||
AND ISNULL(l.IsClosed, 0) = 0
|
||
AND l.ItemTypeCode = 1
|
||
AND ISNULL(l.Qty1, 0) > 0
|
||
AND LEN(LTRIM(RTRIM(l.ItemCode))) = 13
|
||
)
|
||
SELECT TOP (@p1)
|
||
MarketKey, CurrAccCode, CustomerName, OrderNumber, CONVERT(varchar, OrderDate, 23), CONVERT(varchar, DueDate, 23),
|
||
ProductCode, ColorCode, YakaKodu, MAX(ItemDescription),
|
||
SUM(Qty), SUM(AmountUSD), CASE WHEN SUM(Qty)=0 THEN 0 ELSE SUM(AmountUSD)/NULLIF(SUM(Qty),0) END,
|
||
CASE WHEN MIN(DueDate) < CAST(GETDATE() AS date) THEN CAST(1 AS bit) ELSE CAST(0 AS bit) END
|
||
FROM OpenOrderLines
|
||
GROUP BY MarketKey, CurrAccCode, CustomerName, OrderNumber, OrderDate, DueDate, ProductCode, ColorCode, YakaKodu
|
||
ORDER BY MarketKey, CustomerName, OrderDate DESC, OrderNumber, SUM(AmountUSD) DESC
|
||
`, limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
out := make([]models.ProductPerformanceOrderMarketDetailRow, 0, limit)
|
||
productCodes := make([]string, 0, limit)
|
||
stockKeys := make([]string, 0, limit)
|
||
colorCodes := make([]string, 0, limit)
|
||
seenProducts := map[string]bool{}
|
||
seenStockKeys := map[string]bool{}
|
||
for rows.Next() {
|
||
var r models.ProductPerformanceOrderMarketDetailRow
|
||
if err := rows.Scan(&r.MarketKey, &r.CustomerCode, &r.CustomerName, &r.OrderNumber, &r.OrderDate, &r.DueDate, &r.ProductCode, &r.ColorCode, &r.YakaKodu, &r.ItemDescription, &r.OrderQty, &r.OrderUSD, &r.AvgOrderPriceUSD, &r.IsOverdue); err != nil {
|
||
return nil, err
|
||
}
|
||
normalizeProductPerformanceVariantCodes(&r.ProductCode, &r.ColorCode, &r.YakaKodu)
|
||
colorCodes = append(colorCodes, r.ColorCode)
|
||
out = append(out, r)
|
||
if !seenProducts[r.ProductCode] {
|
||
seenProducts[r.ProductCode] = true
|
||
productCodes = append(productCodes, r.ProductCode)
|
||
}
|
||
key := productPerformanceVariantKey(r.ProductCode, r.ColorCode, r.YakaKodu)
|
||
if !seenStockKeys[key] {
|
||
seenStockKeys[key] = true
|
||
stockKeys = append(stockKeys, key)
|
||
}
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
priceByProduct, err := productPerformancePriceLookup(ctx, pg, productCodes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
stockByKey, err := productPerformanceStockLookup(ctx, pg, stockKeys)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
attrByKey, err := productPerformanceAttrLookup(ctx, pg, stockKeys)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
colorDescriptions := productPerformanceColorDescriptions(ctx, colorCodes)
|
||
filtered := out[:0]
|
||
for i := range out {
|
||
row := &out[i]
|
||
price := priceByProduct[normalizeProductPerformanceProductCode(row.ProductCode)]
|
||
attr := attrByKey[productPerformanceVariantKey(row.ProductCode, row.ColorCode, row.YakaKodu)]
|
||
if isExcludedProductPerformanceFirstGroup(attr.urunIlkGrubu) {
|
||
continue
|
||
}
|
||
row.CostPriceUSD = price.cost
|
||
row.BasePriceUSD = price.base
|
||
row.StockQty = stockByKey[productPerformanceVariantKey(row.ProductCode, row.ColorCode, row.YakaKodu)]
|
||
row.NetStockAfterOrder = row.StockQty - row.OrderQty
|
||
row.ExpectedProfitBaseUSD = row.OrderUSD - row.OrderQty*row.BasePriceUSD
|
||
row.ExpectedProfitCostUSD = row.OrderUSD - row.OrderQty*row.CostPriceUSD
|
||
if row.OrderUSD != 0 {
|
||
row.ExpectedMarginBase = row.ExpectedProfitBaseUSD / row.OrderUSD
|
||
row.ExpectedMarginCost = row.ExpectedProfitCostUSD / row.OrderUSD
|
||
}
|
||
row.ColorDescription = colorDescriptions[normalizeProductPerformanceCode(row.ColorCode)]
|
||
row.PerformanceBucket, row.Recommendation = productPerformanceOrderMarketDetailRecommendation(*row)
|
||
filtered = append(filtered, *row)
|
||
}
|
||
return filtered, nil
|
||
}
|
||
|
||
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 = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
rows, err := pg.QueryContext(ctx, `
|
||
SELECT
|
||
market_key,
|
||
MAX(kategori) AS kategori,
|
||
MAX(seri) AS seri,
|
||
MAX(yas_grubu) AS yas_grubu,
|
||
COALESCE(MAX(NULLIF(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)
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
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
|
||
}
|
||
r.UrunIlkGrubu = cleanProductPerformanceFirstGroup(r.UrunIlkGrubu)
|
||
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 = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
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'
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
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 = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
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,'') <> ''
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
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 ListProductPerformanceSalesBreakdown(ctx context.Context, pg *sql.DB, breakdown string, limit int) ([]models.ProductPerformanceSalesBreakdownRow, error) {
|
||
if err := EnsureProductPerformanceTables(pg); err != nil {
|
||
return nil, err
|
||
}
|
||
if limit <= 0 {
|
||
limit = 50000
|
||
} else if limit > 50000 {
|
||
limit = 50000
|
||
}
|
||
mode := strings.ToLower(strings.TrimSpace(breakdown))
|
||
fields := map[string]string{
|
||
"product_code": "s.product_code",
|
||
"color_code": "s.color_code",
|
||
"yaka_kodu": "s.yaka_kodu",
|
||
"item_description": "MAX(s.item_description)",
|
||
"kategori": "COALESCE(MAX(s.kategori),'')",
|
||
"askili_yan": "COALESCE(MAX(CASE WHEN btrim(COALESCE(s.askili_yan,'')) = '-' THEN '' ELSE s.askili_yan END),'')",
|
||
"urun_ilk_grubu": "COALESCE(MAX(CASE WHEN btrim(COALESCE(s.urun_ilk_grubu,'')) = '-' THEN '' WHEN upper(translate(btrim(COALESCE(s.urun_ilk_grubu,'')), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON') THEN '' ELSE s.urun_ilk_grubu END),'')",
|
||
"urun_ana_grubu": "COALESCE(MAX(s.urun_ana_grubu),'')",
|
||
"urun_alt_grubu": "MAX(s.urun_alt_grubu)",
|
||
"market_key": "s.market_key",
|
||
"country": "s.customer_country",
|
||
"customer_segment": "s.customer_segment",
|
||
"customer_code": "s.customer_code",
|
||
"customer_name": "MAX(s.customer_name)",
|
||
}
|
||
selected := map[string]bool{}
|
||
groupCols := []string{}
|
||
switch mode {
|
||
case "color_yaka_market_customer":
|
||
selected["product_code"] = true
|
||
selected["color_code"] = true
|
||
selected["yaka_kodu"] = true
|
||
selected["item_description"] = true
|
||
selected["kategori"] = true
|
||
selected["askili_yan"] = true
|
||
selected["urun_ilk_grubu"] = true
|
||
selected["urun_ana_grubu"] = true
|
||
selected["urun_alt_grubu"] = true
|
||
selected["country"] = true
|
||
selected["customer_segment"] = true
|
||
selected["market_key"] = true
|
||
selected["customer_code"] = true
|
||
selected["customer_name"] = true
|
||
groupCols = []string{"CASE WHEN btrim(COALESCE(s.urun_ilk_grubu,'')) = '-' THEN '' WHEN upper(translate(btrim(COALESCE(s.urun_ilk_grubu,'')), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON') THEN '' ELSE s.urun_ilk_grubu END", "s.color_code", "s.yaka_kodu", "CASE WHEN btrim(COALESCE(s.askili_yan,'')) = '-' THEN '' ELSE s.askili_yan END", "s.kategori", "s.urun_ana_grubu", "s.urun_alt_grubu", "s.product_code", "s.customer_country", "s.market_key", "s.customer_segment", "s.customer_code"}
|
||
case "product_country_segment_market_customer":
|
||
selected["product_code"] = true
|
||
selected["item_description"] = true
|
||
selected["kategori"] = true
|
||
selected["askili_yan"] = true
|
||
selected["urun_ilk_grubu"] = true
|
||
selected["urun_ana_grubu"] = true
|
||
selected["urun_alt_grubu"] = true
|
||
selected["color_code"] = true
|
||
selected["yaka_kodu"] = true
|
||
selected["country"] = true
|
||
selected["customer_segment"] = true
|
||
selected["market_key"] = true
|
||
selected["customer_code"] = true
|
||
selected["customer_name"] = true
|
||
groupCols = []string{"s.market_key", "s.customer_code", "s.product_code", "s.color_code", "s.yaka_kodu", "s.customer_country", "s.customer_segment"}
|
||
case "market_customer_product":
|
||
selected["market_key"] = true
|
||
selected["customer_code"] = true
|
||
selected["customer_name"] = true
|
||
selected["product_code"] = true
|
||
selected["color_code"] = true
|
||
selected["yaka_kodu"] = true
|
||
selected["item_description"] = true
|
||
selected["kategori"] = true
|
||
selected["askili_yan"] = true
|
||
selected["urun_ilk_grubu"] = true
|
||
selected["urun_ana_grubu"] = true
|
||
selected["urun_alt_grubu"] = true
|
||
groupCols = []string{"s.market_key", "s.customer_code", "s.product_code", "s.color_code", "s.yaka_kodu"}
|
||
case "country_segment_market_customer_product":
|
||
selected["country"] = true
|
||
selected["customer_segment"] = true
|
||
selected["market_key"] = true
|
||
selected["customer_code"] = true
|
||
selected["customer_name"] = true
|
||
selected["product_code"] = true
|
||
selected["color_code"] = true
|
||
selected["yaka_kodu"] = true
|
||
selected["item_description"] = true
|
||
selected["kategori"] = true
|
||
selected["askili_yan"] = true
|
||
selected["urun_ilk_grubu"] = true
|
||
selected["urun_ana_grubu"] = true
|
||
selected["urun_alt_grubu"] = true
|
||
groupCols = []string{"s.customer_country", "s.customer_segment", "s.market_key", "s.customer_code", "s.product_code", "s.color_code", "s.yaka_kodu"}
|
||
default:
|
||
mode = "color_yaka_market_customer"
|
||
selected["product_code"] = true
|
||
selected["color_code"] = true
|
||
selected["yaka_kodu"] = true
|
||
selected["item_description"] = true
|
||
selected["kategori"] = true
|
||
selected["askili_yan"] = true
|
||
selected["urun_ilk_grubu"] = true
|
||
selected["urun_ana_grubu"] = true
|
||
selected["urun_alt_grubu"] = true
|
||
selected["country"] = true
|
||
selected["customer_segment"] = true
|
||
selected["market_key"] = true
|
||
selected["customer_code"] = true
|
||
selected["customer_name"] = true
|
||
groupCols = []string{"CASE WHEN btrim(COALESCE(s.urun_ilk_grubu,'')) = '-' THEN '' WHEN upper(translate(btrim(COALESCE(s.urun_ilk_grubu,'')), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON') THEN '' ELSE s.urun_ilk_grubu END", "s.color_code", "s.yaka_kodu", "CASE WHEN btrim(COALESCE(s.askili_yan,'')) = '-' THEN '' ELSE s.askili_yan END", "s.kategori", "s.urun_ana_grubu", "s.urun_alt_grubu", "s.product_code", "s.customer_country", "s.market_key", "s.customer_segment", "s.customer_code"}
|
||
}
|
||
|
||
selectExpr := func(name string) string {
|
||
if selected[name] {
|
||
return fields[name] + " AS " + name
|
||
}
|
||
return "''::text AS " + name
|
||
}
|
||
|
||
query := fmt.Sprintf(`
|
||
WITH LatestKPI AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
COALESCE(kategori,'') AS kategori,
|
||
CASE WHEN btrim(COALESCE(askili_yan,'')) = '-' THEN '' ELSE COALESCE(askili_yan,'') END AS askili_yan,
|
||
CASE
|
||
WHEN btrim(COALESCE(urun_ilk_grubu,'')) = '-' THEN ''
|
||
WHEN upper(translate(btrim(COALESCE(urun_ilk_grubu,'')), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON') THEN ''
|
||
ELSE COALESCE(urun_ilk_grubu,'')
|
||
END AS urun_ilk_grubu,
|
||
COALESCE(urun_ana_grubu,'') AS urun_ana_grubu,
|
||
urun_alt_grubu
|
||
FROM mk_product_performance_kpi_daily
|
||
WHERE kpi_date = (SELECT MAX(kpi_date) FROM mk_product_performance_kpi_daily)
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
ORDER BY product_code, color_code, yaka_kodu, performance_score DESC
|
||
),
|
||
StockAgg AS (
|
||
SELECT
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
COALESCE(SUM(stock_qty),0) AS stock_qty
|
||
FROM mk_product_performance_stock_daily
|
||
WHERE stock_date = (SELECT MAX(stock_date) FROM mk_product_performance_stock_daily)
|
||
GROUP BY product_code, color_code, yaka_kodu
|
||
),
|
||
Stock90Start AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
stock_qty
|
||
FROM mk_product_performance_stock_daily
|
||
WHERE stock_date <= current_date - INTERVAL '89 days'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
Stock180Start AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
stock_qty
|
||
FROM mk_product_performance_stock_daily
|
||
WHERE stock_date <= current_date - INTERVAL '179 days'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
Stock365Start AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
stock_qty
|
||
FROM mk_product_performance_stock_daily
|
||
WHERE stock_date <= current_date - INTERVAL '359 days'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
StockTotalStart AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
stock_qty
|
||
FROM mk_product_performance_stock_daily
|
||
WHERE stock_date <= DATE '2022-01-01'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
Agg AS (
|
||
SELECT
|
||
$2::text AS breakdown,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
%s,
|
||
COUNT(DISTINCT product_code) AS product_count,
|
||
COALESCE(MAX(stock_qty),0) AS stock_qty,
|
||
COALESCE(MAX(avg_stock_90d),0) AS avg_stock_90d,
|
||
COALESCE(MAX(avg_stock_180d),0) AS avg_stock_180d,
|
||
COALESCE(MAX(avg_stock_365d),0) AS avg_stock_365d,
|
||
COALESCE(MAX(avg_stock_total),0) AS avg_stock_total,
|
||
COUNT(DISTINCT customer_code) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days' AND COALESCE(customer_code,'') <> '')::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 '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,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '89 days'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_qty * base_price_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 base_price_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_qty * cost_price_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 cost_price_usd_90d,
|
||
COUNT(DISTINCT customer_code) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days' AND COALESCE(customer_code,'') <> '')::integer AS customer_count_180d,
|
||
COALESCE(SUM(invoice_count) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)::integer AS invoice_count_180d,
|
||
COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0) AS sales_qty_180d,
|
||
COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0) AS sales_usd_180d,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)
|
||
END AS avg_price_usd_180d,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_qty * base_price_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)
|
||
END AS base_price_usd_180d,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_qty * cost_price_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '179 days'),0)
|
||
END AS cost_price_usd_180d,
|
||
COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0) AS sales_qty_365d,
|
||
COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0) AS sales_usd_365d,
|
||
COUNT(DISTINCT customer_code) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days' AND COALESCE(customer_code,'') <> '')::integer AS customer_count_365d,
|
||
COALESCE(SUM(invoice_count) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)::integer AS invoice_count_365d,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)
|
||
END AS avg_price_usd_365d,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_qty * base_price_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)
|
||
END AS base_price_usd_365d,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_qty * cost_price_usd) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= current_date - INTERVAL '359 days'),0)
|
||
END AS cost_price_usd_365d,
|
||
COUNT(DISTINCT customer_code) FILTER (WHERE sales_date >= DATE '2022-01-01' AND COALESCE(customer_code,'') <> '')::integer AS customer_count_total,
|
||
COALESCE(SUM(invoice_count) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)::integer AS invoice_count_total,
|
||
COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= DATE '2022-01-01'),0) AS sales_qty_total,
|
||
COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= DATE '2022-01-01'),0) AS sales_usd_total,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_usd) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)
|
||
END AS avg_price_usd_total,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_qty * base_price_usd) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)
|
||
END AS base_price_usd_total,
|
||
CASE WHEN COALESCE(SUM(sales_qty) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)=0 THEN 0
|
||
ELSE COALESCE(SUM(sales_qty * cost_price_usd) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)
|
||
/ NULLIF(SUM(sales_qty) FILTER (WHERE sales_date >= DATE '2022-01-01'),0)
|
||
END AS cost_price_usd_total,
|
||
COALESCE(to_char(MAX(sales_date),'YYYY-MM-DD'),'') AS last_sale_date
|
||
FROM (
|
||
SELECT
|
||
s.*,
|
||
COALESCE(pd.base_price_usd,0) AS base_price_usd,
|
||
COALESCE(pd.cost_price_usd,0) AS cost_price_usd,
|
||
COALESCE(st.stock_qty,0) AS stock_qty,
|
||
(COALESCE(s90.stock_qty,0) + COALESCE(st.stock_qty,0)) / 2.0 AS avg_stock_90d,
|
||
(COALESCE(s180.stock_qty,0) + COALESCE(st.stock_qty,0)) / 2.0 AS avg_stock_180d,
|
||
(COALESCE(s365.stock_qty,0) + COALESCE(st.stock_qty,0)) / 2.0 AS avg_stock_365d,
|
||
(COALESCE(stotal.stock_qty,0) + COALESCE(st.stock_qty,0)) / 2.0 AS avg_stock_total
|
||
FROM mk_product_performance_sales_daily s
|
||
LEFT JOIN mk_product_performance_price_dim pd ON pd.product_code = s.product_code
|
||
LEFT JOIN LatestKPI k ON k.product_code = s.product_code AND k.color_code = s.color_code AND k.yaka_kodu = s.yaka_kodu
|
||
LEFT JOIN StockAgg st ON st.product_code = s.product_code AND st.color_code = s.color_code AND st.yaka_kodu = s.yaka_kodu
|
||
LEFT JOIN Stock90Start s90 ON s90.product_code = s.product_code AND s90.color_code = s.color_code AND s90.yaka_kodu = s.yaka_kodu
|
||
LEFT JOIN Stock180Start s180 ON s180.product_code = s.product_code AND s180.color_code = s.color_code AND s180.yaka_kodu = s.yaka_kodu
|
||
LEFT JOIN Stock365Start s365 ON s365.product_code = s.product_code AND s365.color_code = s.color_code AND s365.yaka_kodu = s.yaka_kodu
|
||
LEFT JOIN StockTotalStart stotal ON stotal.product_code = s.product_code AND stotal.color_code = s.color_code AND stotal.yaka_kodu = s.yaka_kodu
|
||
) s
|
||
WHERE sales_date >= DATE '2022-01-01'
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
GROUP BY %s
|
||
),
|
||
Enriched AS (
|
||
SELECT
|
||
Agg.*,
|
||
sales_usd_90d - (sales_qty_90d * base_price_usd_90d) AS gross_profit_base_usd_90d,
|
||
sales_usd_90d - (sales_qty_90d * cost_price_usd_90d) AS gross_profit_cost_usd_90d,
|
||
CASE WHEN sales_usd_90d <= 0 THEN 0 ELSE (sales_usd_90d - (sales_qty_90d * base_price_usd_90d)) / NULLIF(sales_usd_90d,0) END AS gross_margin_base_90d,
|
||
CASE WHEN sales_usd_90d <= 0 THEN 0 ELSE (sales_usd_90d - (sales_qty_90d * cost_price_usd_90d)) / NULLIF(sales_usd_90d,0) END AS gross_margin_cost_90d,
|
||
sales_usd_180d - (sales_qty_180d * base_price_usd_180d) AS gross_profit_base_usd_180d,
|
||
sales_usd_180d - (sales_qty_180d * cost_price_usd_180d) AS gross_profit_cost_usd_180d,
|
||
CASE WHEN sales_usd_180d <= 0 THEN 0 ELSE (sales_usd_180d - (sales_qty_180d * base_price_usd_180d)) / NULLIF(sales_usd_180d,0) END AS gross_margin_base_180d,
|
||
CASE WHEN sales_usd_180d <= 0 THEN 0 ELSE (sales_usd_180d - (sales_qty_180d * cost_price_usd_180d)) / NULLIF(sales_usd_180d,0) END AS gross_margin_cost_180d,
|
||
sales_usd_365d - (sales_qty_365d * base_price_usd_365d) AS gross_profit_base_usd_365d,
|
||
sales_usd_365d - (sales_qty_365d * cost_price_usd_365d) AS gross_profit_cost_usd_365d,
|
||
CASE WHEN sales_usd_365d <= 0 THEN 0 ELSE (sales_usd_365d - (sales_qty_365d * base_price_usd_365d)) / NULLIF(sales_usd_365d,0) END AS gross_margin_base_365d,
|
||
CASE WHEN sales_usd_365d <= 0 THEN 0 ELSE (sales_usd_365d - (sales_qty_365d * cost_price_usd_365d)) / NULLIF(sales_usd_365d,0) END AS gross_margin_cost_365d,
|
||
sales_usd_total - (sales_qty_total * base_price_usd_total) AS gross_profit_base_usd_total,
|
||
sales_usd_total - (sales_qty_total * cost_price_usd_total) AS gross_profit_cost_usd_total,
|
||
CASE WHEN sales_usd_total <= 0 THEN 0 ELSE (sales_usd_total - (sales_qty_total * base_price_usd_total)) / NULLIF(sales_usd_total,0) END AS gross_margin_base_total,
|
||
CASE WHEN sales_usd_total <= 0 THEN 0 ELSE (sales_usd_total - (sales_qty_total * cost_price_usd_total)) / NULLIF(sales_usd_total,0) END AS gross_margin_cost_total,
|
||
(base_price_usd_total > 0 AND cost_price_usd_total > 0) AS has_cost
|
||
FROM Agg
|
||
),
|
||
Scored AS (
|
||
SELECT
|
||
Enriched.*,
|
||
CASE WHEN AVG(NULLIF(sales_usd_90d,0)) OVER () IS NULL THEN 0
|
||
ELSE sales_usd_90d / NULLIF(AVG(NULLIF(sales_usd_90d,0)) OVER (),0)
|
||
END AS sales_index_90d
|
||
FROM Enriched
|
||
)
|
||
SELECT
|
||
breakdown,
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
item_description,
|
||
kategori,
|
||
askili_yan,
|
||
urun_ilk_grubu,
|
||
urun_ana_grubu,
|
||
urun_alt_grubu,
|
||
market_key,
|
||
country,
|
||
customer_segment,
|
||
customer_code,
|
||
customer_name,
|
||
product_count,
|
||
stock_qty,
|
||
customer_count_90d,
|
||
invoice_count_90d,
|
||
sales_qty_90d,
|
||
sales_usd_90d,
|
||
avg_price_usd_90d,
|
||
base_price_usd_90d,
|
||
cost_price_usd_90d,
|
||
gross_profit_base_usd_90d,
|
||
gross_profit_cost_usd_90d,
|
||
gross_margin_base_90d,
|
||
gross_margin_cost_90d,
|
||
customer_count_180d,
|
||
invoice_count_180d,
|
||
sales_qty_180d,
|
||
sales_usd_180d,
|
||
avg_price_usd_180d,
|
||
base_price_usd_180d,
|
||
cost_price_usd_180d,
|
||
gross_profit_base_usd_180d,
|
||
gross_profit_cost_usd_180d,
|
||
gross_margin_base_180d,
|
||
gross_margin_cost_180d,
|
||
sales_qty_365d,
|
||
sales_usd_365d,
|
||
avg_price_usd_365d,
|
||
base_price_usd_365d,
|
||
cost_price_usd_365d,
|
||
gross_profit_base_usd_365d,
|
||
gross_profit_cost_usd_365d,
|
||
gross_margin_base_365d,
|
||
gross_margin_cost_365d,
|
||
customer_count_365d,
|
||
invoice_count_365d,
|
||
customer_count_total,
|
||
invoice_count_total,
|
||
sales_qty_total,
|
||
sales_usd_total,
|
||
avg_price_usd_total,
|
||
base_price_usd_total,
|
||
cost_price_usd_total,
|
||
gross_profit_base_usd_total,
|
||
gross_profit_cost_usd_total,
|
||
gross_margin_base_total,
|
||
gross_margin_cost_total,
|
||
CASE WHEN avg_stock_90d > 0 THEN sales_qty_90d / NULLIF(avg_stock_90d,0) ELSE 0 END AS stock_turnover_90d,
|
||
CASE WHEN avg_stock_180d > 0 THEN sales_qty_180d / NULLIF(avg_stock_180d,0) ELSE 0 END AS stock_turnover_180d,
|
||
CASE WHEN avg_stock_365d > 0 THEN sales_qty_365d / NULLIF(avg_stock_365d,0) ELSE 0 END AS stock_turnover_365d,
|
||
CASE WHEN avg_stock_total > 0 THEN sales_qty_total / NULLIF(avg_stock_total,0) ELSE 0 END AS stock_turnover_total,
|
||
has_cost,
|
||
sales_index_90d,
|
||
CASE WHEN NOT has_cost THEN 0 ELSE
|
||
ROUND((
|
||
LEAST(35, sales_usd_90d / 1000)
|
||
+ LEAST(25, GREATEST(gross_margin_cost_90d,0) * 55)
|
||
+ LEAST(20, invoice_count_90d * 2)
|
||
+ LEAST(10, sales_qty_90d / 10)
|
||
+ LEAST(10, product_count)
|
||
)::numeric, 4)
|
||
END AS customer_score_90d,
|
||
CASE WHEN NOT has_cost THEN 0 ELSE
|
||
ROUND((
|
||
LEAST(35, sales_usd_180d / 1000)
|
||
+ LEAST(25, GREATEST(gross_margin_cost_180d,0) * 55)
|
||
+ LEAST(20, invoice_count_180d * 2)
|
||
+ LEAST(10, sales_qty_180d / 10)
|
||
+ LEAST(10, product_count)
|
||
)::numeric, 4)
|
||
END AS customer_score_180d,
|
||
CASE WHEN NOT has_cost THEN 0 ELSE
|
||
ROUND((
|
||
LEAST(35, sales_usd_365d / 1000)
|
||
+ LEAST(25, GREATEST(gross_margin_cost_365d,0) * 55)
|
||
+ LEAST(20, invoice_count_365d * 2)
|
||
+ LEAST(10, sales_qty_365d / 10)
|
||
+ LEAST(10, product_count)
|
||
)::numeric, 4)
|
||
END AS customer_score_365d,
|
||
CASE WHEN NOT has_cost THEN 0 ELSE
|
||
ROUND((
|
||
LEAST(35, sales_usd_total / 1000)
|
||
+ LEAST(25, GREATEST(gross_margin_cost_total,0) * 55)
|
||
+ LEAST(20, invoice_count_total * 2)
|
||
+ LEAST(10, sales_qty_total / 10)
|
||
+ LEAST(10, product_count)
|
||
)::numeric, 4)
|
||
END AS customer_score_total,
|
||
CASE WHEN NOT has_cost THEN 0 ELSE
|
||
ROUND(
|
||
LEAST(35, sales_index_90d * 18)
|
||
+ LEAST(30, GREATEST(gross_margin_cost_90d,0) * 60)
|
||
+ LEAST(15, invoice_count_90d * 1.5)
|
||
+ LEAST(10, sales_qty_90d / 10)
|
||
+ LEAST(10, (CASE WHEN avg_stock_90d > 0 THEN sales_qty_90d / NULLIF(avg_stock_90d,0) ELSE 0 END) * 5),
|
||
4
|
||
)
|
||
END AS performance_score,
|
||
CASE
|
||
WHEN NOT has_cost THEN 'MALIYET_YOK'
|
||
WHEN sales_index_90d >= 1.25 AND customer_count_90d >= 2 THEN 'YILDIZ_URUN'
|
||
WHEN sales_qty_90d = 0 AND sales_qty_365d > 0 THEN 'STOK_RISKI'
|
||
WHEN gross_margin_cost_90d < 0 THEN 'FIYAT_BASKISI'
|
||
WHEN sales_index_90d < 0.75 THEN 'TAKIP'
|
||
ELSE 'TAKIP'
|
||
END AS performance_bucket,
|
||
CASE
|
||
WHEN sales_index_90d >= 1.25 AND customer_count_90d >= 2 THEN 'Güçlü satış kırılımı'
|
||
WHEN sales_qty_90d = 0 AND sales_qty_365d > 0 THEN 'Son 90 gün zayıf, kontrol et'
|
||
ELSE 'Takip'
|
||
END AS recommendation,
|
||
last_sale_date
|
||
FROM Scored
|
||
ORDER BY sales_usd_90d DESC, sales_qty_90d DESC
|
||
LIMIT $1
|
||
`,
|
||
selectExpr("product_code"),
|
||
selectExpr("color_code"),
|
||
selectExpr("yaka_kodu"),
|
||
selectExpr("item_description"),
|
||
selectExpr("kategori"),
|
||
selectExpr("askili_yan"),
|
||
selectExpr("urun_ilk_grubu"),
|
||
selectExpr("urun_ana_grubu"),
|
||
selectExpr("urun_alt_grubu"),
|
||
selectExpr("market_key"),
|
||
selectExpr("country"),
|
||
selectExpr("customer_segment"),
|
||
selectExpr("customer_code"),
|
||
selectExpr("customer_name"),
|
||
strings.Join(groupCols, ", "),
|
||
)
|
||
|
||
rows, err := pg.QueryContext(ctx, query, limit, mode)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
out := make([]models.ProductPerformanceSalesBreakdownRow, 0, limit)
|
||
colorCodes := make([]string, 0, limit)
|
||
for rows.Next() {
|
||
var r models.ProductPerformanceSalesBreakdownRow
|
||
if err := rows.Scan(
|
||
&r.Breakdown, &r.ProductCode, &r.ColorCode, &r.YakaKodu, &r.ItemDescription,
|
||
&r.Kategori, &r.AskiliYan, &r.UrunIlkGrubu, &r.UrunAnaGrubu, &r.UrunAltGrubu,
|
||
&r.MarketKey, &r.Country, &r.CustomerSegment, &r.CustomerCode, &r.CustomerName,
|
||
&r.ProductCount, &r.StockQty, &r.CustomerCount90, &r.InvoiceCount90, &r.SalesQty90, &r.SalesUSD90,
|
||
&r.AvgPriceUSD90, &r.BasePriceUSD90, &r.CostPriceUSD90, &r.GrossProfitBase90,
|
||
&r.GrossProfitCost90, &r.GrossMarginBase90, &r.GrossMarginCost90, &r.CustomerCount180,
|
||
&r.InvoiceCount180, &r.SalesQty180, &r.SalesUSD180, &r.AvgPriceUSD180, &r.BasePriceUSD180,
|
||
&r.CostPriceUSD180, &r.GrossProfitBase180, &r.GrossProfitCost180, &r.GrossMarginBase180,
|
||
&r.GrossMarginCost180, &r.SalesQty365, &r.SalesUSD365, &r.AvgPriceUSD365, &r.BasePriceUSD365,
|
||
&r.CostPriceUSD365, &r.GrossProfitBase365, &r.GrossProfitCost365, &r.GrossMarginBase365,
|
||
&r.GrossMarginCost365, &r.CustomerCount365, &r.InvoiceCount365, &r.CustomerCountTotal, &r.InvoiceCountTotal, &r.SalesQtyTotal, &r.SalesUSDTotal,
|
||
&r.AvgPriceUSDTotal, &r.BasePriceUSDTotal, &r.CostPriceUSDTotal, &r.GrossProfitBaseTotal,
|
||
&r.GrossProfitCostTotal, &r.GrossMarginBaseTotal, &r.GrossMarginCostTotal,
|
||
&r.StockTurnover90, &r.StockTurnover180, &r.StockTurnover365, &r.StockTurnoverTotal, &r.HasCost,
|
||
&r.SalesIndex90, &r.CustomerScore90, &r.CustomerScore180, &r.CustomerScore365, &r.CustomerScoreTotal, &r.PerformanceScore,
|
||
&r.PerformanceBucket, &r.Recommendation, &r.LastSaleDate,
|
||
); err != nil {
|
||
return nil, err
|
||
}
|
||
colorCodes = append(colorCodes, r.ColorCode)
|
||
out = append(out, r)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
colorDescriptions := productPerformanceColorDescriptions(ctx, colorCodes)
|
||
for i := range out {
|
||
out[i].ColorDescription = colorDescriptions[normalizeProductPerformanceCode(out[i].ColorCode)]
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
type ProductPerformanceGroupedRequest struct {
|
||
Mode string
|
||
GroupLevels []string
|
||
ExpandedKeys map[string]bool
|
||
Limit int
|
||
MainGroup string
|
||
}
|
||
|
||
func ListProductPerformanceGrouped(ctx context.Context, pg *sql.DB, req ProductPerformanceGroupedRequest) ([]map[string]any, error) {
|
||
if req.Limit <= 0 || req.Limit > 50000 {
|
||
req.Limit = 50000
|
||
}
|
||
levels := sanitizeProductPerformanceGroupLevels(req.GroupLevels)
|
||
if len(levels) == 0 {
|
||
levels = defaultProductPerformanceGroupLevels(req.Mode)
|
||
}
|
||
|
||
if out, ok, err := listProductPerformanceGroupedSQL(ctx, pg, req, levels); ok || err != nil {
|
||
return out, err
|
||
}
|
||
|
||
sourceRows, err := productPerformanceGroupedSourceRows(ctx, pg, req.Mode, req.Limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := make([]map[string]any, 0, len(sourceRows))
|
||
appendProductPerformanceGroupedRows(&out, sourceRows, levels, 0, 0, []string{"tab:" + req.Mode}, req.ExpandedKeys)
|
||
return out, nil
|
||
}
|
||
|
||
type productPerformanceSQLGroupFilter struct {
|
||
Field string
|
||
Value string
|
||
}
|
||
|
||
func listProductPerformanceGroupedSQL(ctx context.Context, pg *sql.DB, req ProductPerformanceGroupedRequest, levels []string) ([]map[string]any, bool, error) {
|
||
mode := strings.TrimSpace(req.Mode)
|
||
if mode != "products" && mode != "product_detail" && mode != "idle" {
|
||
return nil, false, nil
|
||
}
|
||
if err := EnsureProductPerformanceTables(pg); err != nil {
|
||
return nil, true, err
|
||
}
|
||
out := make([]map[string]any, 0, 512)
|
||
filters := productPerformanceGroupedBaseFilters(req)
|
||
err := appendProductPerformanceGroupedSQLRows(ctx, pg, &out, mode, levels, 0, 0, []string{"tab:" + mode}, filters, req.ExpandedKeys, req.Limit)
|
||
return out, true, err
|
||
}
|
||
|
||
func productPerformanceGroupedBaseFilters(req ProductPerformanceGroupedRequest) []productPerformanceSQLGroupFilter {
|
||
mainGroup := strings.TrimSpace(req.MainGroup)
|
||
if strings.TrimSpace(req.Mode) != "product_detail" || mainGroup == "" {
|
||
return nil
|
||
}
|
||
return []productPerformanceSQLGroupFilter{{Field: "urun_ana_grubu", Value: mainGroup}}
|
||
}
|
||
|
||
func appendProductPerformanceGroupedSQLRows(ctx context.Context, pg *sql.DB, out *[]map[string]any, mode string, levels []string, level int, visualLevel int, parentKeys []string, filters []productPerformanceSQLGroupFilter, expandedKeys map[string]bool, limit int) error {
|
||
if level >= len(levels) {
|
||
rows, err := queryProductPerformanceSQLLeafRows(ctx, pg, mode, filters, limit)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
*out = append(*out, rows...)
|
||
return nil
|
||
}
|
||
|
||
field := levels[level]
|
||
rows, err := queryProductPerformanceSQLGroupRows(ctx, pg, mode, field, level, parentKeys, filters)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
for _, row := range rows {
|
||
value := stringFromMap(row, "group_value")
|
||
if shouldSkipProductPerformanceGroupValue(field, value) {
|
||
nextFilters := append(append([]productPerformanceSQLGroupFilter{}, filters...), productPerformanceSQLGroupFilter{Field: field, Value: value})
|
||
if err := appendProductPerformanceGroupedSQLRows(ctx, pg, out, mode, levels, level+1, visualLevel, parentKeys, nextFilters, expandedKeys, limit); err != nil {
|
||
return err
|
||
}
|
||
continue
|
||
}
|
||
keyPart := field + ":" + value
|
||
key := strings.Join(append(parentKeys, keyPart), "|")
|
||
row["row_key"] = "group|" + key
|
||
row["key"] = key
|
||
row["level"] = visualLevel
|
||
row["group_field"] = field
|
||
row["group_value"] = value
|
||
row["label"] = value
|
||
row["__group"] = true
|
||
row[field] = value
|
||
*out = append(*out, row)
|
||
if expandedKeys[key] {
|
||
nextFilters := append(append([]productPerformanceSQLGroupFilter{}, filters...), productPerformanceSQLGroupFilter{Field: field, Value: value})
|
||
if err := appendProductPerformanceGroupedSQLRows(ctx, pg, out, mode, levels, level+1, visualLevel+1, append(parentKeys, keyPart), nextFilters, expandedKeys, limit); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func queryProductPerformanceSQLGroupRows(ctx context.Context, pg *sql.DB, mode, field string, level int, parentKeys []string, filters []productPerformanceSQLGroupFilter) ([]map[string]any, error) {
|
||
groupExpr, ok := productPerformanceSQLGroupExpr(field)
|
||
if !ok {
|
||
return nil, fmt.Errorf("unsupported product performance group field: %s", field)
|
||
}
|
||
whereSQL, args, err := productPerformanceSQLFilterWhere(filters)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
query := productPerformanceSQLSourceCTE(mode) + fmt.Sprintf(`
|
||
SELECT jsonb_build_object(
|
||
'group_value', group_value,
|
||
'label', group_value,
|
||
'count', row_count,
|
||
'recommendation', CASE WHEN recommendation <> '' THEN recommendation ELSE row_count::text || ' satir' END,
|
||
'image_product_code', image_product_code,
|
||
'image_color_code', image_color_code,
|
||
'image_yaka_kodu', image_yaka_kodu,
|
||
'product_code', CASE WHEN $%d = 'product_code' THEN group_value ELSE product_code END,
|
||
'color_code', CASE WHEN $%d = 'color_code' THEN group_value ELSE color_code END,
|
||
'yaka_kodu', CASE WHEN $%d = 'yaka_kodu' THEN group_value ELSE yaka_kodu END,
|
||
'item_description', item_description,
|
||
'kategori', CASE WHEN $%d = 'kategori' THEN group_value ELSE kategori END,
|
||
'askili_yan', CASE WHEN $%d = 'askili_yan' THEN group_value ELSE askili_yan END,
|
||
'urun_ilk_grubu', CASE WHEN $%d = 'urun_ilk_grubu' THEN group_value ELSE urun_ilk_grubu END,
|
||
'urun_ana_grubu', CASE WHEN $%d = 'urun_ana_grubu' THEN group_value ELSE urun_ana_grubu END,
|
||
'urun_alt_grubu', CASE WHEN $%d = 'urun_alt_grubu' THEN group_value ELSE urun_alt_grubu END,
|
||
'market_key', CASE WHEN $%d = 'market_key' THEN group_value ELSE market_key END,
|
||
'stock_qty', stock_qty,
|
||
'sales_qty_90d', sales_qty_90d,
|
||
'sales_qty_180d', sales_qty_180d,
|
||
'sales_qty_365d', sales_qty_365d,
|
||
'sales_qty_total', sales_qty_total,
|
||
'sales_usd_90d', sales_usd_90d,
|
||
'sales_usd_180d', sales_usd_180d,
|
||
'sales_usd_365d', sales_usd_365d,
|
||
'sales_usd_total', sales_usd_total,
|
||
'avg_price_usd_90d', avg_price_usd_90d,
|
||
'avg_price_usd_180d', avg_price_usd_180d,
|
||
'cost_price_usd', cost_price_usd,
|
||
'base_price_usd', base_price_usd,
|
||
'base_price_try', base_price_try,
|
||
'gross_profit_usd_90d', gross_profit_usd_90d,
|
||
'gross_profit_usd_180d', gross_profit_usd_180d,
|
||
'gross_margin_90d', gross_margin_90d,
|
||
'gross_margin_180d', gross_margin_180d,
|
||
'unit_profit_cost_90d', unit_profit_cost_90d,
|
||
'unit_profit_cost_180d', unit_profit_cost_180d,
|
||
'unit_profit_base_90d', unit_profit_base_90d,
|
||
'unit_profit_base_180d', unit_profit_base_180d,
|
||
'market_count_90d', market_count_90d,
|
||
'customer_count_90d', customer_count_90d,
|
||
'sales_index_90d', sales_index_90d,
|
||
'price_index_90d', price_index_90d,
|
||
'margin_index_90d', margin_index_90d,
|
||
'performance_score', performance_score,
|
||
'performance_bucket', performance_bucket,
|
||
'idle_cost_usd', idle_cost_usd,
|
||
'stock_days_90d', stock_days_90d,
|
||
'stock_days_180d', stock_days_180d,
|
||
'stock_days_365d', stock_days_365d,
|
||
'stock_days_total', stock_days_total,
|
||
'stock_turnover_90d', CASE WHEN avg_stock_90d > 0 THEN sales_qty_90d / NULLIF(avg_stock_90d,0) ELSE 0 END,
|
||
'stock_turnover_180d', CASE WHEN avg_stock_180d > 0 THEN sales_qty_180d / NULLIF(avg_stock_180d,0) ELSE 0 END,
|
||
'stock_turnover_365d', CASE WHEN avg_stock_365d > 0 THEN sales_qty_365d / NULLIF(avg_stock_365d,0) ELSE 0 END,
|
||
'stock_turnover_total', CASE WHEN avg_stock_total > 0 THEN sales_qty_total / NULLIF(avg_stock_total,0) ELSE 0 END
|
||
) AS row_json
|
||
FROM (
|
||
SELECT
|
||
COALESCE(%s, '') AS group_value,
|
||
COUNT(*)::integer AS row_count,
|
||
(ARRAY_AGG(product_code ORDER BY performance_score DESC NULLS LAST))[1] AS image_product_code,
|
||
(ARRAY_AGG(color_code ORDER BY performance_score DESC NULLS LAST))[1] AS image_color_code,
|
||
(ARRAY_AGG(yaka_kodu ORDER BY performance_score DESC NULLS LAST))[1] AS image_yaka_kodu,
|
||
COALESCE((ARRAY_AGG(NULLIF(product_code,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS product_code,
|
||
COALESCE((ARRAY_AGG(NULLIF(color_code,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS color_code,
|
||
COALESCE((ARRAY_AGG(NULLIF(yaka_kodu,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS yaka_kodu,
|
||
COALESCE((ARRAY_AGG(NULLIF(item_description,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS item_description,
|
||
COALESCE((ARRAY_AGG(NULLIF(kategori,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS kategori,
|
||
COALESCE((ARRAY_AGG(NULLIF(NULLIF(askili_yan,''), '-') ORDER BY performance_score DESC NULLS LAST))[1], '') AS askili_yan,
|
||
COALESCE((ARRAY_AGG(NULLIF(urun_ilk_grubu,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS urun_ilk_grubu,
|
||
COALESCE((ARRAY_AGG(NULLIF(urun_ana_grubu,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS urun_ana_grubu,
|
||
COALESCE((ARRAY_AGG(NULLIF(urun_alt_grubu,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS urun_alt_grubu,
|
||
COALESCE((ARRAY_AGG(NULLIF(market_key,'') ORDER BY performance_score DESC NULLS LAST))[1], '') AS market_key,
|
||
COALESCE(SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0) AS stock_qty,
|
||
COALESCE(SUM(CASE WHEN stock_variant_rank = 1 THEN avg_stock_90d ELSE 0 END),0) AS avg_stock_90d,
|
||
COALESCE(SUM(CASE WHEN stock_variant_rank = 1 THEN avg_stock_180d ELSE 0 END),0) AS avg_stock_180d,
|
||
COALESCE(SUM(CASE WHEN stock_variant_rank = 1 THEN avg_stock_365d ELSE 0 END),0) AS avg_stock_365d,
|
||
COALESCE(SUM(CASE WHEN stock_variant_rank = 1 THEN avg_stock_total ELSE 0 END),0) AS avg_stock_total,
|
||
COALESCE(SUM(sales_qty_90d),0) AS sales_qty_90d,
|
||
COALESCE(SUM(sales_qty_180d),0) AS sales_qty_180d,
|
||
COALESCE(SUM(sales_qty_365d),0) AS sales_qty_365d,
|
||
COALESCE(SUM(sales_qty_total),0) AS sales_qty_total,
|
||
COALESCE(SUM(sales_usd_90d),0) AS sales_usd_90d,
|
||
COALESCE(SUM(sales_usd_180d),0) AS sales_usd_180d,
|
||
COALESCE(SUM(sales_usd_365d),0) AS sales_usd_365d,
|
||
COALESCE(SUM(sales_usd_total),0) AS sales_usd_total,
|
||
CASE WHEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END) > 0 THEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_days_90d * stock_qty ELSE 0 END) / NULLIF(SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0) ELSE 0 END AS stock_days_90d,
|
||
CASE WHEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END) > 0 THEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_days_180d * stock_qty ELSE 0 END) / NULLIF(SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0) ELSE 0 END AS stock_days_180d,
|
||
CASE WHEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END) > 0 THEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_days_365d * stock_qty ELSE 0 END) / NULLIF(SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0) ELSE 0 END AS stock_days_365d,
|
||
CASE WHEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END) > 0 THEN SUM(CASE WHEN stock_variant_rank = 1 THEN stock_days_total * stock_qty ELSE 0 END) / NULLIF(SUM(CASE WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0) ELSE 0 END AS stock_days_total,
|
||
CASE WHEN SUM(sales_qty_90d) > 0 THEN SUM(sales_usd_90d) / NULLIF(SUM(sales_qty_90d),0) ELSE 0 END AS avg_price_usd_90d,
|
||
CASE WHEN SUM(sales_qty_180d) > 0 THEN SUM(sales_usd_180d) / NULLIF(SUM(sales_qty_180d),0) ELSE 0 END AS avg_price_usd_180d,
|
||
CASE
|
||
WHEN SUM(CASE WHEN sales_qty_total > 0 THEN sales_qty_total WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END) > 0
|
||
THEN SUM(CASE WHEN sales_qty_total > 0 THEN cost_price_usd * sales_qty_total WHEN stock_variant_rank = 1 THEN cost_price_usd * stock_qty ELSE 0 END)
|
||
/ NULLIF(SUM(CASE WHEN sales_qty_total > 0 THEN sales_qty_total WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0)
|
||
ELSE 0
|
||
END AS cost_price_usd,
|
||
CASE
|
||
WHEN SUM(CASE WHEN sales_qty_total > 0 THEN sales_qty_total WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END) > 0
|
||
THEN SUM(CASE WHEN sales_qty_total > 0 THEN base_price_usd * sales_qty_total WHEN stock_variant_rank = 1 THEN base_price_usd * stock_qty ELSE 0 END)
|
||
/ NULLIF(SUM(CASE WHEN sales_qty_total > 0 THEN sales_qty_total WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0)
|
||
ELSE 0
|
||
END AS base_price_usd,
|
||
CASE
|
||
WHEN SUM(CASE WHEN sales_qty_total > 0 THEN sales_qty_total WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END) > 0
|
||
THEN SUM(CASE WHEN sales_qty_total > 0 THEN base_price_try * sales_qty_total WHEN stock_variant_rank = 1 THEN base_price_try * stock_qty ELSE 0 END)
|
||
/ NULLIF(SUM(CASE WHEN sales_qty_total > 0 THEN sales_qty_total WHEN stock_variant_rank = 1 THEN stock_qty ELSE 0 END),0)
|
||
ELSE 0
|
||
END AS base_price_try,
|
||
COALESCE(SUM(gross_profit_usd_90d),0) AS gross_profit_usd_90d,
|
||
COALESCE(SUM(gross_profit_usd_180d),0) AS gross_profit_usd_180d,
|
||
CASE WHEN SUM(sales_usd_90d) > 0 THEN SUM(gross_profit_usd_90d) / NULLIF(SUM(sales_usd_90d),0) ELSE 0 END AS gross_margin_90d,
|
||
CASE WHEN SUM(sales_usd_180d) > 0 THEN SUM(gross_profit_usd_180d) / NULLIF(SUM(sales_usd_180d),0) ELSE 0 END AS gross_margin_180d,
|
||
CASE WHEN SUM(sales_qty_90d) > 0 THEN SUM(unit_profit_cost_90d * sales_qty_90d) / NULLIF(SUM(sales_qty_90d),0) ELSE 0 END AS unit_profit_cost_90d,
|
||
CASE WHEN SUM(sales_qty_180d) > 0 THEN SUM(unit_profit_cost_180d * sales_qty_180d) / NULLIF(SUM(sales_qty_180d),0) ELSE 0 END AS unit_profit_cost_180d,
|
||
CASE WHEN SUM(sales_qty_90d) > 0 THEN SUM(unit_profit_base_90d * sales_qty_90d) / NULLIF(SUM(sales_qty_90d),0) ELSE 0 END AS unit_profit_base_90d,
|
||
CASE WHEN SUM(sales_qty_180d) > 0 THEN SUM(unit_profit_base_180d * sales_qty_180d) / NULLIF(SUM(sales_qty_180d),0) ELSE 0 END AS unit_profit_base_180d,
|
||
COALESCE(SUM(market_count_90d),0)::integer AS market_count_90d,
|
||
COALESCE(SUM(customer_count_90d),0)::integer AS customer_count_90d,
|
||
CASE WHEN SUM(sales_qty_90d) > 0 THEN SUM(sales_index_90d * sales_qty_90d) / NULLIF(SUM(sales_qty_90d),0) ELSE 0 END AS sales_index_90d,
|
||
CASE WHEN SUM(sales_qty_90d) > 0 THEN SUM(price_index_90d * sales_qty_90d) / NULLIF(SUM(sales_qty_90d),0) ELSE 0 END AS price_index_90d,
|
||
CASE WHEN SUM(sales_qty_90d) > 0 THEN SUM(margin_index_90d * sales_qty_90d) / NULLIF(SUM(sales_qty_90d),0) ELSE 0 END AS margin_index_90d,
|
||
CASE WHEN SUM(sales_qty_90d) > 0 THEN SUM(performance_score * sales_qty_90d) / NULLIF(SUM(sales_qty_90d),0) ELSE 0 END AS performance_score,
|
||
MODE() WITHIN GROUP (ORDER BY performance_bucket) AS performance_bucket,
|
||
COALESCE(MODE() WITHIN GROUP (ORDER BY NULLIF(recommendation,'')), '') AS recommendation,
|
||
COALESCE(SUM(CASE WHEN stock_variant_rank = 1 THEN idle_cost_usd ELSE 0 END),0) AS idle_cost_usd
|
||
FROM (
|
||
SELECT
|
||
Source.*,
|
||
ROW_NUMBER() OVER (
|
||
PARTITION BY COALESCE(%s, ''), product_code, color_code, yaka_kodu
|
||
ORDER BY performance_score DESC NULLS LAST
|
||
) AS stock_variant_rank
|
||
FROM Source
|
||
%s
|
||
) s
|
||
GROUP BY COALESCE(%s, '')
|
||
) g
|
||
ORDER BY group_value
|
||
`, len(args)+1, len(args)+1, len(args)+1, len(args)+1, len(args)+1, len(args)+1, len(args)+1, len(args)+1, len(args)+1, groupExpr, groupExpr, whereSQL, groupExpr)
|
||
args = append(args, field)
|
||
return queryProductPerformanceJSONRows(ctx, pg, query, args...)
|
||
}
|
||
|
||
func queryProductPerformanceSQLLeafRows(ctx context.Context, pg *sql.DB, mode string, filters []productPerformanceSQLGroupFilter, limit int) ([]map[string]any, error) {
|
||
whereSQL, args, err := productPerformanceSQLFilterWhere(filters)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
args = append(args, limit)
|
||
query := productPerformanceSQLSourceCTE(mode) + fmt.Sprintf(`
|
||
SELECT to_jsonb(t) || jsonb_build_object(
|
||
'row_key', 'leaf|' || product_code || '|' || color_code || '|' || yaka_kodu || '|' || market_key,
|
||
'stock_turnover_90d', CASE WHEN avg_stock_90d > 0 THEN sales_qty_90d / NULLIF(avg_stock_90d,0) ELSE 0 END,
|
||
'stock_turnover_180d', CASE WHEN avg_stock_180d > 0 THEN sales_qty_180d / NULLIF(avg_stock_180d,0) ELSE 0 END,
|
||
'stock_turnover_365d', CASE WHEN avg_stock_365d > 0 THEN sales_qty_365d / NULLIF(avg_stock_365d,0) ELSE 0 END,
|
||
'stock_turnover_total', CASE WHEN avg_stock_total > 0 THEN sales_qty_total / NULLIF(avg_stock_total,0) ELSE 0 END
|
||
) AS row_json
|
||
FROM Source t
|
||
%s
|
||
ORDER BY performance_score DESC, sales_usd_90d DESC
|
||
LIMIT $%d
|
||
`, whereSQL, len(args))
|
||
return queryProductPerformanceJSONRows(ctx, pg, query, args...)
|
||
}
|
||
|
||
func queryProductPerformanceJSONRows(ctx context.Context, pg *sql.DB, query string, args ...any) ([]map[string]any, error) {
|
||
rows, err := pg.QueryContext(ctx, query, args...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
out := []map[string]any{}
|
||
colorCodes := []string{}
|
||
for rows.Next() {
|
||
var raw []byte
|
||
if err := rows.Scan(&raw); err != nil {
|
||
return nil, err
|
||
}
|
||
row := map[string]any{}
|
||
if err := json.Unmarshal(raw, &row); err != nil {
|
||
return nil, err
|
||
}
|
||
colorCodes = append(colorCodes, stringFromMap(row, "color_code"))
|
||
out = append(out, row)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, err
|
||
}
|
||
colorDescriptions := productPerformanceColorDescriptions(ctx, colorCodes)
|
||
for _, row := range out {
|
||
row["color_description"] = colorDescriptions[normalizeProductPerformanceCode(stringFromMap(row, "color_code"))]
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func productPerformanceSQLSourceCTE(mode string) string {
|
||
idleWhere := ""
|
||
if mode == "idle" {
|
||
idleWhere = `
|
||
AND stock_qty > 0
|
||
AND (performance_bucket = 'STOK_RISKI' OR COALESCE(sales_qty_90d,0) = 0 OR COALESCE(stock_days_90d,0) > 180)`
|
||
}
|
||
return `
|
||
WITH LatestKPIDate AS (
|
||
SELECT MAX(kpi_date) AS kpi_date
|
||
FROM mk_product_performance_kpi_daily
|
||
),
|
||
Stock90Start AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code, color_code, yaka_kodu, stock_qty
|
||
FROM mk_product_performance_stock_daily, LatestKPIDate
|
||
WHERE stock_date <= LatestKPIDate.kpi_date - INTERVAL '89 days'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
Stock180Start AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code, color_code, yaka_kodu, stock_qty
|
||
FROM mk_product_performance_stock_daily, LatestKPIDate
|
||
WHERE stock_date <= LatestKPIDate.kpi_date - INTERVAL '179 days'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
Stock365Start AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code, color_code, yaka_kodu, stock_qty
|
||
FROM mk_product_performance_stock_daily, LatestKPIDate
|
||
WHERE stock_date <= LatestKPIDate.kpi_date - INTERVAL '359 days'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
StockTotalStart AS (
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code, color_code, yaka_kodu, stock_qty
|
||
FROM mk_product_performance_stock_daily
|
||
WHERE stock_date <= DATE '2022-01-01'
|
||
ORDER BY product_code, color_code, yaka_kodu, stock_date DESC
|
||
),
|
||
Source AS (
|
||
SELECT
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
item_description,
|
||
kategori,
|
||
seri,
|
||
yas_grubu,
|
||
CASE WHEN btrim(COALESCE(askili_yan,'')) = '-' THEN '' ELSE COALESCE(askili_yan,'') END AS askili_yan,
|
||
CASE
|
||
WHEN btrim(COALESCE(urun_ilk_grubu,'')) = '-' THEN ''
|
||
WHEN upper(translate(btrim(COALESCE(urun_ilk_grubu,'')), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON') THEN ''
|
||
ELSE COALESCE(urun_ilk_grubu,'')
|
||
END AS urun_ilk_grubu,
|
||
COALESCE(urun_ana_grubu,'') AS urun_ana_grubu,
|
||
urun_alt_grubu,
|
||
market_key,
|
||
COALESCE(stock_qty,0) AS stock_qty,
|
||
(COALESCE((SELECT s.stock_qty FROM Stock90Start s WHERE s.product_code = mk_product_performance_kpi_daily.product_code AND s.color_code = mk_product_performance_kpi_daily.color_code AND s.yaka_kodu = mk_product_performance_kpi_daily.yaka_kodu),0) + COALESCE(stock_qty,0)) / 2.0 AS avg_stock_90d,
|
||
(COALESCE((SELECT s.stock_qty FROM Stock180Start s WHERE s.product_code = mk_product_performance_kpi_daily.product_code AND s.color_code = mk_product_performance_kpi_daily.color_code AND s.yaka_kodu = mk_product_performance_kpi_daily.yaka_kodu),0) + COALESCE(stock_qty,0)) / 2.0 AS avg_stock_180d,
|
||
(COALESCE((SELECT s.stock_qty FROM Stock365Start s WHERE s.product_code = mk_product_performance_kpi_daily.product_code AND s.color_code = mk_product_performance_kpi_daily.color_code AND s.yaka_kodu = mk_product_performance_kpi_daily.yaka_kodu),0) + COALESCE(stock_qty,0)) / 2.0 AS avg_stock_365d,
|
||
(COALESCE((SELECT s.stock_qty FROM StockTotalStart s WHERE s.product_code = mk_product_performance_kpi_daily.product_code AND s.color_code = mk_product_performance_kpi_daily.color_code AND s.yaka_kodu = mk_product_performance_kpi_daily.yaka_kodu),0) + COALESCE(stock_qty,0)) / 2.0 AS avg_stock_total,
|
||
COALESCE(sales_qty_90d,0) AS sales_qty_90d,
|
||
COALESCE(sales_qty_180d,0) AS sales_qty_180d,
|
||
COALESCE(sales_qty_365d,0) AS sales_qty_365d,
|
||
COALESCE(sales_qty_total,0) AS sales_qty_total,
|
||
COALESCE(sales_usd_90d,0) AS sales_usd_90d,
|
||
COALESCE(sales_usd_180d,0) AS sales_usd_180d,
|
||
COALESCE(sales_usd_365d,0) AS sales_usd_365d,
|
||
COALESCE(sales_usd_total,0) AS sales_usd_total,
|
||
COALESCE(stock_days_90d,0) AS stock_days_90d,
|
||
COALESCE(stock_days_180d,0) AS stock_days_180d,
|
||
COALESCE(stock_days_365d,0) AS stock_days_365d,
|
||
COALESCE(stock_days_total,0) AS stock_days_total,
|
||
COALESCE(avg_price_usd_90d,0) AS avg_price_usd_90d,
|
||
COALESCE(avg_price_usd_180d,0) AS avg_price_usd_180d,
|
||
COALESCE(cost_price_usd,0) AS cost_price_usd,
|
||
COALESCE(base_price_usd,0) AS base_price_usd,
|
||
COALESCE(base_price_try,0) AS base_price_try,
|
||
COALESCE(gross_profit_usd_90d,0) AS gross_profit_usd_90d,
|
||
COALESCE(gross_profit_usd_180d,0) AS gross_profit_usd_180d,
|
||
COALESCE(gross_margin_90d,0) AS gross_margin_90d,
|
||
COALESCE(gross_margin_180d,0) AS gross_margin_180d,
|
||
COALESCE(unit_profit_cost_90d,0) AS unit_profit_cost_90d,
|
||
COALESCE(unit_profit_cost_180d,0) AS unit_profit_cost_180d,
|
||
COALESCE(unit_profit_base_90d,0) AS unit_profit_base_90d,
|
||
COALESCE(unit_profit_base_180d,0) AS unit_profit_base_180d,
|
||
COALESCE(market_count_90d,0) AS market_count_90d,
|
||
COALESCE(customer_count_90d,0) AS customer_count_90d,
|
||
COALESCE(sales_index_90d,0) AS sales_index_90d,
|
||
COALESCE(price_index_90d,0) AS price_index_90d,
|
||
COALESCE(margin_index_90d,0) AS margin_index_90d,
|
||
COALESCE(performance_score,0) AS performance_score,
|
||
COALESCE(performance_bucket,'') AS performance_bucket,
|
||
COALESCE(recommendation,'') AS recommendation,
|
||
COALESCE(stock_qty,0) * COALESCE(cost_price_usd,0) AS idle_cost_usd
|
||
FROM mk_product_performance_kpi_daily
|
||
WHERE kpi_date = (SELECT MAX(kpi_date) FROM mk_product_performance_kpi_daily)
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')` + idleWhere + `
|
||
)`
|
||
}
|
||
|
||
func productPerformanceSQLGroupExpr(field string) (string, bool) {
|
||
switch field {
|
||
case "urun_ilk_grubu":
|
||
return "CASE WHEN btrim(COALESCE(urun_ilk_grubu,'')) = '-' THEN '' WHEN upper(translate(btrim(COALESCE(urun_ilk_grubu,'')), 'İŞĞÜÖÇ', 'ISGUOC')) IN ('YETISKIN', 'YETISKIN/GARSON', 'GARSON') THEN '' ELSE COALESCE(urun_ilk_grubu,'') END", true
|
||
case "askili_yan":
|
||
return "CASE WHEN btrim(COALESCE(askili_yan,'')) = '-' THEN '' ELSE COALESCE(askili_yan,'') END", true
|
||
case "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu":
|
||
return field, true
|
||
case "color_yaka":
|
||
return "concat_ws('/', NULLIF(btrim(COALESCE(color_code,'')), ''), NULLIF(btrim(COALESCE(yaka_kodu,'')), ''))", true
|
||
case "market_key":
|
||
return "btrim(regexp_replace(COALESCE(market_key,''), '^.*\\|', ''))", true
|
||
default:
|
||
return "", false
|
||
}
|
||
}
|
||
|
||
func shouldSkipProductPerformanceGroupValue(field, value string) bool {
|
||
switch field {
|
||
case "urun_ilk_grubu", "askili_yan":
|
||
return strings.TrimSpace(value) == ""
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func productPerformanceSQLFilterWhere(filters []productPerformanceSQLGroupFilter) (string, []any, error) {
|
||
if len(filters) == 0 {
|
||
return "", nil, nil
|
||
}
|
||
parts := make([]string, 0, len(filters))
|
||
args := make([]any, 0, len(filters))
|
||
for _, filter := range filters {
|
||
expr, ok := productPerformanceSQLGroupExpr(filter.Field)
|
||
if !ok {
|
||
return "", nil, fmt.Errorf("unsupported product performance filter field: %s", filter.Field)
|
||
}
|
||
args = append(args, normalizeProductPerformanceGroupValue(filter.Value))
|
||
parts = append(parts, fmt.Sprintf("COALESCE(%s, '') = $%d", expr, len(args)))
|
||
}
|
||
return "WHERE " + strings.Join(parts, " AND "), args, nil
|
||
}
|
||
|
||
func productPerformanceGroupedSourceRows(ctx context.Context, pg *sql.DB, mode string, limit int) ([]map[string]any, error) {
|
||
switch mode {
|
||
case "products":
|
||
rows, _, err := ListProductPerformance(ctx, pg, ProductPerformanceFilters{Limit: limit, Page: 1, SortBy: "performance_score", Descending: true})
|
||
return structsToMaps(rows), err
|
||
case "idle":
|
||
rows, _, err := ListProductPerformance(ctx, pg, ProductPerformanceFilters{Limit: limit, Page: 1, SortBy: "performance_score", Descending: true})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return productPerformanceIdleSourceRows(structsToMaps(rows)), nil
|
||
case "sales_color_yaka_market_customer", "sales_product_country_segment_market_customer", "sales_market_customer_product", "sales_country_segment_market_customer_product":
|
||
rows, err := ListProductPerformanceSalesBreakdown(ctx, pg, productPerformanceSalesBreakdownMode(mode), limit)
|
||
return structsToMaps(rows), err
|
||
case "order_product_customers":
|
||
rows, err := ListProductPerformanceOrderProductCustomers(ctx, pg, limit)
|
||
return structsToMaps(rows), err
|
||
case "order_market_details":
|
||
rows, err := ListProductPerformanceOrderMarketDetails(ctx, pg, limit)
|
||
return structsToMaps(rows), err
|
||
default:
|
||
rows, _, err := ListProductPerformance(ctx, pg, ProductPerformanceFilters{Limit: limit, Page: 1, SortBy: "performance_score", Descending: true})
|
||
return structsToMaps(rows), err
|
||
}
|
||
}
|
||
|
||
func productPerformanceSalesBreakdownMode(mode string) string {
|
||
switch strings.TrimSpace(mode) {
|
||
case "sales_color_yaka_market_customer":
|
||
return "color_yaka_market_customer"
|
||
case "sales_product_country_segment_market_customer":
|
||
return "product_country_segment_market_customer"
|
||
case "sales_market_customer_product":
|
||
return "market_customer_product"
|
||
case "sales_country_segment_market_customer_product":
|
||
return "country_segment_market_customer_product"
|
||
default:
|
||
return mode
|
||
}
|
||
}
|
||
|
||
func productPerformanceIdleSourceRows(rows []map[string]any) []map[string]any {
|
||
out := make([]map[string]any, 0, len(rows))
|
||
for _, row := range rows {
|
||
stockQty := floatFromMap(row, "stock_qty")
|
||
salesQty90 := floatFromMap(row, "sales_qty_90d")
|
||
stockDays90 := floatFromMap(row, "stock_days_90d")
|
||
if stockQty <= 0 {
|
||
continue
|
||
}
|
||
if stringFromMap(row, "performance_bucket") != "STOK_RISKI" && salesQty90 != 0 && stockDays90 <= 180 {
|
||
continue
|
||
}
|
||
next := cloneMap(row)
|
||
next["idle_cost_usd"] = stockQty * floatFromMap(row, "cost_price_usd")
|
||
out = append(out, next)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func appendProductPerformanceGroupedRows(out *[]map[string]any, sourceRows []map[string]any, levels []string, level int, visualLevel int, parentKeys []string, expandedKeys map[string]bool) {
|
||
if level >= len(levels) {
|
||
*out = append(*out, sourceRows...)
|
||
return
|
||
}
|
||
|
||
field := levels[level]
|
||
grouped := make(map[string][]map[string]any)
|
||
for _, row := range sourceRows {
|
||
value := normalizeProductPerformanceGroupValue(mapGroupValue(row, field))
|
||
grouped[value] = append(grouped[value], row)
|
||
}
|
||
|
||
values := make([]string, 0, len(grouped))
|
||
for value := range grouped {
|
||
values = append(values, value)
|
||
}
|
||
sort.Slice(values, func(i, j int) bool {
|
||
return strings.Compare(values[i], values[j]) < 0
|
||
})
|
||
|
||
for _, value := range values {
|
||
groupRows := grouped[value]
|
||
if shouldSkipProductPerformanceGroupValue(field, value) {
|
||
appendProductPerformanceGroupedRows(out, groupRows, levels, level+1, visualLevel, parentKeys, expandedKeys)
|
||
continue
|
||
}
|
||
keyPart := field + ":" + value
|
||
key := strings.Join(append(parentKeys, keyPart), "|")
|
||
*out = append(*out, makeProductPerformanceGroupedRow(key, visualLevel, field, value, groupRows))
|
||
if expandedKeys[key] {
|
||
appendProductPerformanceGroupedRows(out, groupRows, levels, level+1, visualLevel+1, append(parentKeys, keyPart), expandedKeys)
|
||
}
|
||
}
|
||
}
|
||
|
||
func makeProductPerformanceGroupedRow(key string, level int, field, value string, rows []map[string]any) map[string]any {
|
||
row := aggregateProductPerformanceRows(rows, field)
|
||
row["__group"] = true
|
||
row["row_key"] = "group|" + key
|
||
row["key"] = key
|
||
row["level"] = level
|
||
row["group_field"] = field
|
||
row["group_value"] = value
|
||
row["label"] = value
|
||
row["count"] = len(rows)
|
||
row[field] = value
|
||
row["recommendation"] = fmt.Sprintf("%d satır", len(rows))
|
||
|
||
image := firstProductPerformanceImageSource(rows)
|
||
row["image_product_code"] = stringFromMap(image, "product_code")
|
||
row["image_color_code"] = stringFromMap(image, "color_code")
|
||
row["image_yaka_kodu"] = stringFromMap(image, "yaka_kodu")
|
||
return row
|
||
}
|
||
|
||
func aggregateProductPerformanceRows(rows []map[string]any, groupField string) map[string]any {
|
||
out := map[string]any{}
|
||
for _, row := range rows {
|
||
for key, value := range row {
|
||
if key == "row_key" || key == "key" {
|
||
continue
|
||
}
|
||
if key == "stock_qty" {
|
||
out[key] = distinctProductPerformanceVariantStockQty(rows)
|
||
continue
|
||
}
|
||
if key == "idle_cost_usd" {
|
||
out[key] = distinctProductPerformanceVariantStockCost(rows)
|
||
continue
|
||
}
|
||
if shouldSumProductPerformanceField(key) {
|
||
out[key] = floatFromAny(out[key]) + floatFromAny(value)
|
||
} else if _, ok := out[key]; !ok && !shouldAverageProductPerformanceField(key) {
|
||
out[key] = value
|
||
}
|
||
}
|
||
}
|
||
for _, row := range rows {
|
||
for key := range row {
|
||
if shouldAverageProductPerformanceField(key) {
|
||
out[key] = weightedAverageProductPerformanceRows(rows, key, productPerformanceMetricWeightField(key))
|
||
}
|
||
}
|
||
}
|
||
deriveProductPerformanceGroupMetrics(out, groupField)
|
||
out["performance_bucket"] = dominantProductPerformanceValue(rows, "performance_bucket")
|
||
return out
|
||
}
|
||
|
||
func distinctProductPerformanceVariantStockQty(rows []map[string]any) float64 {
|
||
seen := map[string]bool{}
|
||
total := 0.0
|
||
hasKey := false
|
||
for _, row := range rows {
|
||
key := productPerformanceMapVariantKey(row)
|
||
if key == "" {
|
||
continue
|
||
}
|
||
hasKey = true
|
||
if seen[key] {
|
||
continue
|
||
}
|
||
seen[key] = true
|
||
total += floatFromMap(row, "stock_qty")
|
||
}
|
||
if hasKey {
|
||
return total
|
||
}
|
||
for _, row := range rows {
|
||
total += floatFromMap(row, "stock_qty")
|
||
}
|
||
return total
|
||
}
|
||
|
||
func distinctProductPerformanceVariantStockCost(rows []map[string]any) float64 {
|
||
seen := map[string]bool{}
|
||
total := 0.0
|
||
hasKey := false
|
||
for _, row := range rows {
|
||
key := productPerformanceMapVariantKey(row)
|
||
if key == "" {
|
||
continue
|
||
}
|
||
hasKey = true
|
||
if seen[key] {
|
||
continue
|
||
}
|
||
seen[key] = true
|
||
total += floatFromMap(row, "stock_qty") * floatFromMap(row, "cost_price_usd")
|
||
}
|
||
if hasKey {
|
||
return total
|
||
}
|
||
for _, row := range rows {
|
||
total += floatFromMap(row, "idle_cost_usd")
|
||
}
|
||
return total
|
||
}
|
||
|
||
func productPerformanceMapVariantKey(row map[string]any) string {
|
||
productCode := stringFromMap(row, "product_code")
|
||
colorCode := stringFromMap(row, "color_code")
|
||
yakaKodu := stringFromMap(row, "yaka_kodu")
|
||
if productCode == "" && colorCode == "" && yakaKodu == "" {
|
||
return ""
|
||
}
|
||
return productPerformanceVariantKey(productCode, colorCode, yakaKodu)
|
||
}
|
||
|
||
func deriveProductPerformanceGroupMetrics(out map[string]any, groupField string) {
|
||
for _, suffix := range []string{"90d", "180d", "365d", "total"} {
|
||
sales := floatFromMap(out, "sales_usd_"+suffix)
|
||
qty := floatFromMap(out, "sales_qty_"+suffix)
|
||
stockQty := floatFromMap(out, "stock_qty")
|
||
if _, exists := out["stock_turnover_"+suffix]; !exists && stockQty > 0 {
|
||
out["stock_turnover_"+suffix] = qty / stockQty
|
||
}
|
||
if qty > 0 {
|
||
out["avg_price_usd_"+suffix] = sales / qty
|
||
}
|
||
if sales > 0 {
|
||
if _, ok := out["gross_profit_base_usd_"+suffix]; ok {
|
||
out["gross_margin_base_"+suffix] = floatFromMap(out, "gross_profit_base_usd_"+suffix) / sales
|
||
}
|
||
if _, ok := out["gross_profit_cost_usd_"+suffix]; ok {
|
||
out["gross_margin_cost_"+suffix] = floatFromMap(out, "gross_profit_cost_usd_"+suffix) / sales
|
||
}
|
||
if _, ok := out["gross_profit_usd_"+suffix]; ok {
|
||
out["gross_margin_"+suffix] = floatFromMap(out, "gross_profit_usd_"+suffix) / sales
|
||
}
|
||
}
|
||
}
|
||
orderUSD := floatFromMap(out, "order_usd")
|
||
if orderUSD > 0 {
|
||
out["expected_margin_base"] = floatFromMap(out, "expected_profit_base_usd") / orderUSD
|
||
out["expected_margin_cost"] = floatFromMap(out, "expected_profit_cost_usd") / orderUSD
|
||
}
|
||
orderQty := floatFromMap(out, "order_qty")
|
||
if orderQty > 0 {
|
||
out["avg_order_price_usd"] = orderUSD / orderQty
|
||
}
|
||
if _, ok := out["net_stock_after_order"]; ok || orderQty > 0 {
|
||
out["net_stock_after_order"] = floatFromMap(out, "stock_qty") - orderQty
|
||
}
|
||
out["customer_score_90d"] = productPerformanceCustomerSalesPeriodScore(rowPeriodMetricMap(out, "90d"))
|
||
out["customer_score_180d"] = productPerformanceCustomerSalesPeriodScore(rowPeriodMetricMap(out, "180d"))
|
||
out["customer_score_365d"] = productPerformanceCustomerSalesPeriodScore(rowPeriodMetricMap(out, "365d"))
|
||
out["customer_score_total"] = productPerformanceCustomerSalesPeriodScore(rowPeriodMetricMap(out, "total"))
|
||
out["performance_score"] = productPerformanceGroupScore(out, groupField)
|
||
}
|
||
|
||
func productPerformanceGroupScore(row map[string]any, groupField string) float64 {
|
||
if floatFromMap(row, "order_qty") > 0 || floatFromMap(row, "order_usd") > 0 {
|
||
return productPerformanceOrderGroupScore(row)
|
||
}
|
||
if isProductPerformanceCustomerGroup(groupField) {
|
||
return productPerformanceCustomerSalesGroupScore(row)
|
||
}
|
||
return productPerformanceSalesGroupScore(row)
|
||
}
|
||
|
||
func isProductPerformanceCustomerGroup(groupField string) bool {
|
||
switch strings.TrimSpace(groupField) {
|
||
case "customer_code", "customer_name":
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func productPerformanceSalesGroupScore(row map[string]any) float64 {
|
||
salesIndex := floatFromMap(row, "sales_index_90d")
|
||
margin := floatFromMap(row, "gross_margin_cost_90d")
|
||
invoiceCount := floatFromMap(row, "invoice_count_90d")
|
||
salesQty := floatFromMap(row, "sales_qty_90d")
|
||
stockTurnover := floatFromMap(row, "stock_turnover_90d")
|
||
if stockTurnover == 0 {
|
||
if stockQty := floatFromMap(row, "stock_qty"); stockQty > 0 {
|
||
stockTurnover = salesQty / stockQty
|
||
}
|
||
}
|
||
score := minFloat(35, maxFloat(0, salesIndex)*18) +
|
||
minFloat(30, maxFloat(0, margin)*60) +
|
||
minFloat(15, invoiceCount*1.5) +
|
||
minFloat(10, salesQty/10) +
|
||
minFloat(10, maxFloat(0, stockTurnover)*5)
|
||
return score
|
||
}
|
||
|
||
func productPerformanceCustomerSalesGroupScore(row map[string]any) float64 {
|
||
scores := []float64{
|
||
floatFromMap(row, "customer_score_90d"),
|
||
floatFromMap(row, "customer_score_180d"),
|
||
floatFromMap(row, "customer_score_365d"),
|
||
floatFromMap(row, "customer_score_total"),
|
||
}
|
||
total := 0.0
|
||
count := 0.0
|
||
for _, score := range scores {
|
||
if score <= 0 {
|
||
continue
|
||
}
|
||
total += score
|
||
count++
|
||
}
|
||
if count == 0 {
|
||
return 0
|
||
}
|
||
return total / count
|
||
}
|
||
|
||
func productPerformanceCustomerSalesPeriodScore(row map[string]any) float64 {
|
||
salesUSD := floatFromMap(row, "sales_usd")
|
||
margin := floatFromMap(row, "gross_margin_cost")
|
||
invoiceCount := floatFromMap(row, "invoice_count")
|
||
salesQty := floatFromMap(row, "sales_qty")
|
||
productCount := floatFromMap(row, "product_count")
|
||
return minFloat(35, salesUSD/1000) +
|
||
minFloat(25, maxFloat(0, margin)*55) +
|
||
minFloat(20, invoiceCount*2) +
|
||
minFloat(10, salesQty/10) +
|
||
minFloat(10, productCount)
|
||
}
|
||
|
||
func rowPeriodMetricMap(row map[string]any, suffix string) map[string]any {
|
||
return map[string]any{
|
||
"sales_usd": floatFromMap(row, "sales_usd_"+suffix),
|
||
"gross_margin_cost": floatFromMap(row, "gross_margin_cost_"+suffix),
|
||
"gross_margin": floatFromMap(row, "gross_margin_"+suffix),
|
||
"invoice_count": floatFromMap(row, "invoice_count_"+suffix),
|
||
"sales_qty": floatFromMap(row, "sales_qty_"+suffix),
|
||
"product_count": floatFromMap(row, "product_count"),
|
||
}
|
||
}
|
||
|
||
func productPerformanceOrderGroupScore(row map[string]any) float64 {
|
||
orderUSD := floatFromMap(row, "order_usd")
|
||
margin := floatFromMap(row, "expected_margin_cost")
|
||
orderCount := floatFromMap(row, "order_count")
|
||
orderQty := floatFromMap(row, "order_qty")
|
||
netStockAfterOrder := floatFromMap(row, "net_stock_after_order")
|
||
score := minFloat(35, orderUSD/1000) +
|
||
minFloat(25, maxFloat(0, margin)*60) +
|
||
minFloat(15, orderCount*2) +
|
||
minFloat(15, orderQty/10)
|
||
if netStockAfterOrder >= 0 {
|
||
score += 10
|
||
}
|
||
return score
|
||
}
|
||
|
||
func minFloat(a, b float64) float64 {
|
||
if a < b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
|
||
func maxFloat(a, b float64) float64 {
|
||
if a > b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
|
||
func sanitizeProductPerformanceGroupLevels(levels []string) []string {
|
||
allowed := map[string]bool{
|
||
"kategori": true, "askili_yan": true, "urun_ilk_grubu": true, "urun_ana_grubu": true, "urun_alt_grubu": true,
|
||
"product_code": true, "item_description": true, "color_code": true, "yaka_kodu": true, "color_yaka": true, "market_key": true, "customer_code": true,
|
||
"customer_name": true, "country": true, "customer_segment": true,
|
||
}
|
||
out := make([]string, 0, len(levels))
|
||
seen := map[string]bool{}
|
||
for _, level := range levels {
|
||
level = strings.TrimSpace(level)
|
||
if allowed[level] && !seen[level] {
|
||
out = append(out, level)
|
||
seen[level] = true
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func defaultProductPerformanceGroupLevels(mode string) []string {
|
||
switch mode {
|
||
case "sales_color_yaka_market_customer":
|
||
return []string{"color_yaka", "urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "country", "market_key", "customer_segment", "customer_code", "customer_name"}
|
||
case "product_detail":
|
||
return []string{"urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_yaka", "market_key"}
|
||
case "idle":
|
||
return []string{"urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu"}
|
||
case "sales_product_country_segment_market_customer":
|
||
return []string{"market_key", "customer_code", "customer_name", "urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu"}
|
||
case "sales_market_customer_product":
|
||
return []string{"market_key", "customer_code", "customer_name", "urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu"}
|
||
case "sales_country_segment_market_customer_product":
|
||
return []string{"market_key", "customer_code", "customer_name", "urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu"}
|
||
case "order_product_customers":
|
||
return []string{"market_key", "customer_code", "customer_name", "urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu"}
|
||
case "order_market_details":
|
||
return []string{"market_key", "customer_code", "customer_name", "urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu"}
|
||
default:
|
||
return []string{"urun_ilk_grubu", "askili_yan", "kategori", "urun_ana_grubu", "urun_alt_grubu", "product_code", "item_description", "color_code", "yaka_kodu", "market_key"}
|
||
}
|
||
}
|
||
|
||
func mapGroupValue(row map[string]any, field string) string {
|
||
switch field {
|
||
case "urun_ilk_grubu":
|
||
return cleanProductPerformanceFirstGroup(stringFromMap(row, "urun_ilk_grubu"))
|
||
case "market_key":
|
||
return displayProductPerformanceMarketName(stringFromMap(row, "market_key"))
|
||
case "color_yaka":
|
||
parts := make([]string, 0, 2)
|
||
if color := strings.TrimSpace(stringFromMap(row, "color_code")); color != "" {
|
||
parts = append(parts, color)
|
||
}
|
||
if yaka := strings.TrimSpace(stringFromMap(row, "yaka_kodu")); yaka != "" {
|
||
parts = append(parts, yaka)
|
||
}
|
||
return strings.Join(parts, "/")
|
||
default:
|
||
return stringFromMap(row, field)
|
||
}
|
||
}
|
||
|
||
func shouldSumProductPerformanceField(field string) bool {
|
||
return strings.HasSuffix(field, "_qty") ||
|
||
strings.HasSuffix(field, "_usd") ||
|
||
strings.HasSuffix(field, "_count") ||
|
||
strings.HasSuffix(field, "_value_usd") ||
|
||
field == "stock_qty" ||
|
||
field == "line_count" ||
|
||
field == "invoice_count" ||
|
||
field == "order_count" ||
|
||
field == "product_count" ||
|
||
field == "market_count" ||
|
||
field == "customer_count" ||
|
||
field == "overdue_qty" ||
|
||
field == "net_stock_after_order" ||
|
||
field == "idle_cost_usd"
|
||
}
|
||
|
||
func shouldAverageProductPerformanceField(field string) bool {
|
||
return strings.HasPrefix(field, "avg_") ||
|
||
strings.HasPrefix(field, "unit_") ||
|
||
strings.HasPrefix(field, "base_price") ||
|
||
strings.HasPrefix(field, "cost_price") ||
|
||
strings.HasPrefix(field, "gross_margin") ||
|
||
strings.HasPrefix(field, "expected_margin") ||
|
||
strings.HasPrefix(field, "sales_index") ||
|
||
strings.HasPrefix(field, "performance_score") ||
|
||
strings.HasPrefix(field, "stock_days") ||
|
||
strings.HasPrefix(field, "stock_turnover")
|
||
}
|
||
|
||
func productPerformanceMetricWeightField(field string) string {
|
||
if strings.Contains(field, "_180d") {
|
||
return "sales_qty_180d"
|
||
}
|
||
if strings.Contains(field, "_365d") {
|
||
return "sales_qty_365d"
|
||
}
|
||
if strings.Contains(field, "_total") {
|
||
return "sales_qty_total"
|
||
}
|
||
if strings.Contains(field, "order") || strings.Contains(field, "expected_") {
|
||
return "order_qty"
|
||
}
|
||
if strings.Contains(field, "stock") {
|
||
return "stock_qty"
|
||
}
|
||
return "sales_qty_90d"
|
||
}
|
||
|
||
func weightedAverageProductPerformanceRows(rows []map[string]any, valueField, qtyField string) float64 {
|
||
var weighted, qty float64
|
||
for _, row := range rows {
|
||
value := floatFromMap(row, valueField)
|
||
weight := floatFromMap(row, qtyField)
|
||
if weight > 0 {
|
||
weighted += value * weight
|
||
qty += weight
|
||
}
|
||
}
|
||
if qty > 0 {
|
||
return weighted / qty
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func dominantProductPerformanceValue(rows []map[string]any, field string) string {
|
||
counts := map[string]int{}
|
||
for _, row := range rows {
|
||
value := stringFromMap(row, field)
|
||
if field == "urun_ilk_grubu" {
|
||
value = cleanProductPerformanceFirstGroup(value)
|
||
}
|
||
if value != "" {
|
||
counts[value]++
|
||
}
|
||
}
|
||
var best string
|
||
var bestCount int
|
||
for value, count := range counts {
|
||
if count > bestCount {
|
||
best = value
|
||
bestCount = count
|
||
}
|
||
}
|
||
return best
|
||
}
|
||
|
||
func firstProductPerformanceImageSource(rows []map[string]any) map[string]any {
|
||
for _, row := range rows {
|
||
if stringFromMap(row, "product_code") != "" {
|
||
return row
|
||
}
|
||
}
|
||
if len(rows) > 0 {
|
||
return rows[0]
|
||
}
|
||
return map[string]any{}
|
||
}
|
||
|
||
func structsToMaps[T any](rows []T) []map[string]any {
|
||
raw, err := json.Marshal(rows)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
var out []map[string]any
|
||
if err := json.Unmarshal(raw, &out); err != nil {
|
||
return nil
|
||
}
|
||
return out
|
||
}
|
||
|
||
func cloneMap(row map[string]any) map[string]any {
|
||
out := make(map[string]any, len(row))
|
||
for key, value := range row {
|
||
out[key] = value
|
||
}
|
||
return out
|
||
}
|
||
|
||
func normalizeProductPerformanceGroupValue(value string) string {
|
||
return strings.TrimSpace(value)
|
||
}
|
||
|
||
func displayProductPerformanceMarketName(value string) string {
|
||
parts := strings.Split(value, "|")
|
||
for i := len(parts) - 1; i >= 0; i-- {
|
||
part := strings.TrimSpace(parts[i])
|
||
if part != "" {
|
||
return part
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func stringFromMap(row map[string]any, field string) string {
|
||
value, ok := row[field]
|
||
if !ok || value == nil {
|
||
return ""
|
||
}
|
||
return strings.TrimSpace(fmt.Sprint(value))
|
||
}
|
||
|
||
func cleanProductPerformanceFirstGroup(value string) string {
|
||
value = strings.TrimSpace(value)
|
||
if value == "-" {
|
||
return ""
|
||
}
|
||
normalized := strings.ToUpper(value)
|
||
normalized = strings.NewReplacer("İ", "I", "Ş", "S", "Ğ", "G", "Ü", "U", "Ö", "O", "Ç", "C").Replace(normalized)
|
||
switch normalized {
|
||
case "YETISKIN", "YETISKIN/GARSON", "GARSON":
|
||
return ""
|
||
default:
|
||
return value
|
||
}
|
||
}
|
||
|
||
func cleanProductPerformanceOptionalAttr(value string) string {
|
||
value = strings.TrimSpace(value)
|
||
if value == "-" {
|
||
return ""
|
||
}
|
||
return value
|
||
}
|
||
|
||
func floatFromMap(row map[string]any, field string) float64 {
|
||
return floatFromAny(row[field])
|
||
}
|
||
|
||
func floatFromAny(value any) float64 {
|
||
switch v := value.(type) {
|
||
case float64:
|
||
return v
|
||
case float32:
|
||
return float64(v)
|
||
case int:
|
||
return float64(v)
|
||
case int64:
|
||
return float64(v)
|
||
case json.Number:
|
||
f, _ := v.Float64()
|
||
return f
|
||
default:
|
||
return 0
|
||
}
|
||
}
|
||
|
||
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
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
ORDER BY sales_usd DESC, sales_date 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")
|
||
}
|
||
productCode = normalizeProductPerformanceProductCode(productCode)
|
||
colorCode = normalizeProductPerformanceCode(colorCode)
|
||
yakaKodu = normalizeProductPerformanceCode(yakaKodu)
|
||
rows, err := db.MssqlDB.QueryContext(ctx, `
|
||
;WITH ActiveWarehouses AS (
|
||
SELECT WarehouseCode
|
||
FROM (VALUES
|
||
('1-0-14'),('1-0-10'),('1-0-8'),('1-2-5'),('1-2-4'),('1-0-12'),('100'),('1-0-28'),
|
||
('1-0-24'),('1-2-6'),('1-1-14'),('1-0-2'),('1-0-52'),('1-1-2'),('1-0-21'),('1-1-3'),
|
||
('1-0-33'),('101'),('1-014'),('1-0-49'),('1-0-36'),('1-0-4'),('1-0-29')
|
||
) W(WarehouseCode)
|
||
),
|
||
Stock AS (
|
||
SELECT
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(S.ItemDim1Code, '')))),
|
||
WarehouseCode = LTRIM(RTRIM(S.WarehouseCode)),
|
||
InventoryQty1 = SUM(S.In_Qty1 - S.Out_Qty1)
|
||
FROM trStock S WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W
|
||
ON W.WarehouseCode = LTRIM(RTRIM(S.WarehouseCode))
|
||
WHERE S.ItemTypeCode = 1
|
||
AND UPPER(LTRIM(RTRIM(S.ItemCode))) = @p1
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(S.ColorCode, '')))) = @p2
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(S.ItemDim2Code, '')))) = @p3
|
||
GROUP BY UPPER(LTRIM(RTRIM(ISNULL(S.ItemDim1Code, '')))), LTRIM(RTRIM(S.WarehouseCode))
|
||
),
|
||
Pick AS (
|
||
SELECT
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(P.ItemDim1Code, '')))),
|
||
WarehouseCode = LTRIM(RTRIM(P.WarehouseCode)),
|
||
PickingQty1 = SUM(P.Qty1)
|
||
FROM PickingStates P WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W
|
||
ON W.WarehouseCode = LTRIM(RTRIM(P.WarehouseCode))
|
||
WHERE P.ItemTypeCode = 1
|
||
AND UPPER(LTRIM(RTRIM(P.ItemCode))) = @p1
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(P.ColorCode, '')))) = @p2
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(P.ItemDim2Code, '')))) = @p3
|
||
GROUP BY UPPER(LTRIM(RTRIM(ISNULL(P.ItemDim1Code, '')))), LTRIM(RTRIM(P.WarehouseCode))
|
||
),
|
||
Reserve AS (
|
||
SELECT
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(R.ItemDim1Code, '')))),
|
||
WarehouseCode = LTRIM(RTRIM(R.WarehouseCode)),
|
||
ReserveQty1 = SUM(R.Qty1)
|
||
FROM ReserveStates R WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W
|
||
ON W.WarehouseCode = LTRIM(RTRIM(R.WarehouseCode))
|
||
WHERE R.ItemTypeCode = 1
|
||
AND UPPER(LTRIM(RTRIM(R.ItemCode))) = @p1
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(R.ColorCode, '')))) = @p2
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(R.ItemDim2Code, '')))) = @p3
|
||
GROUP BY UPPER(LTRIM(RTRIM(ISNULL(R.ItemDim1Code, '')))), LTRIM(RTRIM(R.WarehouseCode))
|
||
),
|
||
Disp AS (
|
||
SELECT
|
||
SizeCode = UPPER(LTRIM(RTRIM(ISNULL(D.ItemDim1Code, '')))),
|
||
WarehouseCode = LTRIM(RTRIM(D.WarehouseCode)),
|
||
DispOrderQty1 = SUM(D.Qty1)
|
||
FROM DispOrderStates D WITH(NOLOCK)
|
||
INNER JOIN ActiveWarehouses W
|
||
ON W.WarehouseCode = LTRIM(RTRIM(D.WarehouseCode))
|
||
WHERE D.ItemTypeCode = 1
|
||
AND UPPER(LTRIM(RTRIM(D.ItemCode))) = @p1
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(D.ColorCode, '')))) = @p2
|
||
AND UPPER(LTRIM(RTRIM(ISNULL(D.ItemDim2Code, '')))) = @p3
|
||
GROUP BY UPPER(LTRIM(RTRIM(ISNULL(D.ItemDim1Code, '')))), LTRIM(RTRIM(D.WarehouseCode))
|
||
),
|
||
AvailableBySizeWarehouse AS (
|
||
SELECT
|
||
S.SizeCode,
|
||
StockQty =
|
||
ISNULL(S.InventoryQty1, 0)
|
||
- ISNULL(P.PickingQty1, 0)
|
||
- ISNULL(R.ReserveQty1, 0)
|
||
- ISNULL(D.DispOrderQty1, 0)
|
||
FROM Stock S
|
||
LEFT JOIN Pick P ON P.SizeCode = S.SizeCode AND P.WarehouseCode = S.WarehouseCode
|
||
LEFT JOIN Reserve R ON R.SizeCode = S.SizeCode AND R.WarehouseCode = S.WarehouseCode
|
||
LEFT JOIN Disp D ON D.SizeCode = S.SizeCode AND D.WarehouseCode = S.WarehouseCode
|
||
WHERE S.InventoryQty1 >= 0
|
||
)
|
||
SELECT
|
||
SizeCode,
|
||
StockQty = CAST(ROUND(SUM(StockQty), 2) AS FLOAT)
|
||
FROM AvailableBySizeWarehouse
|
||
GROUP BY SizeCode
|
||
HAVING SUM(StockQty) > 0
|
||
ORDER BY SizeCode
|
||
`, 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 := []string{" AND " + productPerformanceAllowedFirstGroupSQL("urun_ilk_grubu")}
|
||
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 := normalizeProductPerformanceProductCode(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_qty_365d": "sales_qty_365d",
|
||
"sales_qty_total": "sales_qty_total",
|
||
"sales_usd_90d": "sales_usd_90d",
|
||
"sales_usd_180d": "sales_usd_180d",
|
||
"sales_usd_365d": "sales_usd_365d",
|
||
"sales_usd_total": "sales_usd_total",
|
||
"stock_days_90d": "stock_days_90d",
|
||
"stock_days_180d": "stock_days_180d",
|
||
"stock_days_365d": "stock_days_365d",
|
||
"stock_days_total": "stock_days_total",
|
||
"stock_turnover_90d": "stock_turnover_90d",
|
||
"stock_turnover_180d": "stock_turnover_180d",
|
||
"stock_turnover_365d": "stock_turnover_365d",
|
||
"stock_turnover_total": "stock_turnover_total",
|
||
"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_base_90d": "(CASE WHEN COALESCE(sales_usd_90d,0) <= 0 THEN 0 ELSE (sales_usd_90d - (sales_qty_90d * COALESCE(base_price_usd,0))) / NULLIF(sales_usd_90d,0) END)",
|
||
"gross_margin_cost_90d": "(CASE WHEN COALESCE(sales_usd_90d,0) <= 0 THEN 0 ELSE (sales_usd_90d - (sales_qty_90d * COALESCE(cost_price_usd,0))) / NULLIF(sales_usd_90d,0) END)",
|
||
"gross_margin_base_180d": "(CASE WHEN COALESCE(sales_usd_180d,0) <= 0 THEN 0 ELSE (sales_usd_180d - (sales_qty_180d * COALESCE(base_price_usd,0))) / NULLIF(sales_usd_180d,0) END)",
|
||
"gross_margin_cost_180d": "(CASE WHEN COALESCE(sales_usd_180d,0) <= 0 THEN 0 ELSE (sales_usd_180d - (sales_qty_180d * COALESCE(cost_price_usd,0))) / NULLIF(sales_usd_180d,0) END)",
|
||
"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"
|
||
}
|
||
|
||
type productPerformancePriceInfo struct {
|
||
cost float64
|
||
base float64
|
||
}
|
||
|
||
type productPerformanceAttrInfo struct {
|
||
itemDescription string
|
||
kategori string
|
||
askiliYan string
|
||
urunIlkGrubu string
|
||
urunAnaGrubu string
|
||
urunAltGrubu string
|
||
}
|
||
|
||
func productPerformanceVariantKey(productCode, colorCode, yakaKodu string) string {
|
||
return normalizeProductPerformanceProductCode(productCode) + "|" + strings.TrimSpace(colorCode) + "|" + strings.TrimSpace(yakaKodu)
|
||
}
|
||
|
||
func normalizeProductPerformanceCostPair(costPriceUSD, basePriceUSD float64) (float64, float64) {
|
||
if costPriceUSD > 0 && basePriceUSD > 0 && costPriceUSD < basePriceUSD {
|
||
return basePriceUSD, costPriceUSD
|
||
}
|
||
return costPriceUSD, basePriceUSD
|
||
}
|
||
|
||
const productPerformanceExcludedFirstGroupsSQL = "('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')"
|
||
|
||
func productPerformanceAllowedFirstGroupSQL(expr string) string {
|
||
return "upper(btrim(COALESCE(" + expr + ",''))) NOT IN " + productPerformanceExcludedFirstGroupsSQL
|
||
}
|
||
|
||
func isExcludedProductPerformanceFirstGroup(value string) bool {
|
||
switch strings.ToUpper(strings.TrimSpace(value)) {
|
||
case "MALZEMELI FASON", "MALZEMESIZ FASON", "DIGER":
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func productPerformancePriceLookup(ctx context.Context, pg *sql.DB, productCodes []string) (map[string]productPerformancePriceInfo, error) {
|
||
out := make(map[string]productPerformancePriceInfo, len(productCodes))
|
||
if len(productCodes) == 0 {
|
||
return out, nil
|
||
}
|
||
normalizedCodes := make([]string, 0, len(productCodes))
|
||
seen := map[string]bool{}
|
||
for _, productCode := range productCodes {
|
||
code := normalizeProductPerformanceProductCode(productCode)
|
||
if code == "" || seen[code] {
|
||
continue
|
||
}
|
||
seen[code] = true
|
||
normalizedCodes = append(normalizedCodes, code)
|
||
}
|
||
if len(normalizedCodes) == 0 {
|
||
return out, nil
|
||
}
|
||
rows, err := pg.QueryContext(ctx, `
|
||
SELECT product_code, COALESCE(cost_price_usd,0), COALESCE(base_price_usd,0)
|
||
FROM mk_product_performance_price_dim
|
||
WHERE product_code = ANY($1)
|
||
`, pq.Array(normalizedCodes))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
for rows.Next() {
|
||
var productCode string
|
||
var p productPerformancePriceInfo
|
||
if err := rows.Scan(&productCode, &p.cost, &p.base); err != nil {
|
||
return nil, err
|
||
}
|
||
p.cost, p.base = normalizeProductPerformanceCostPair(p.cost, p.base)
|
||
out[normalizeProductPerformanceProductCode(productCode)] = p
|
||
}
|
||
return out, rows.Err()
|
||
}
|
||
|
||
func productPerformanceAttrLookup(ctx context.Context, pg *sql.DB, variantKeys []string) (map[string]productPerformanceAttrInfo, error) {
|
||
out := make(map[string]productPerformanceAttrInfo, len(variantKeys))
|
||
if len(variantKeys) == 0 {
|
||
return out, nil
|
||
}
|
||
rows, err := pg.QueryContext(ctx, `
|
||
WITH Latest AS (
|
||
SELECT MAX(kpi_date) AS kpi_date
|
||
FROM mk_product_performance_kpi_daily
|
||
)
|
||
SELECT DISTINCT ON (product_code, color_code, yaka_kodu)
|
||
product_code,
|
||
color_code,
|
||
yaka_kodu,
|
||
COALESCE(item_description,'') AS item_description,
|
||
COALESCE(kategori,'') AS kategori,
|
||
CASE WHEN btrim(COALESCE(askili_yan,'')) = '-' THEN '' ELSE COALESCE(askili_yan,'') END AS askili_yan,
|
||
COALESCE(urun_ilk_grubu,'') AS urun_ilk_grubu,
|
||
COALESCE(urun_ana_grubu,'') AS urun_ana_grubu,
|
||
COALESCE(urun_alt_grubu,'') AS urun_alt_grubu
|
||
FROM mk_product_performance_kpi_daily
|
||
WHERE kpi_date = (SELECT kpi_date FROM Latest)
|
||
AND product_code || '|' || color_code || '|' || yaka_kodu = ANY($1)
|
||
AND upper(btrim(COALESCE(urun_ilk_grubu,''))) NOT IN ('MALZEMELI FASON', 'MALZEMESIZ FASON', 'DIGER')
|
||
ORDER BY product_code, color_code, yaka_kodu, performance_score DESC
|
||
`, pq.Array(variantKeys))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
for rows.Next() {
|
||
var productCode, colorCode, yakaKodu string
|
||
var p productPerformanceAttrInfo
|
||
if err := rows.Scan(&productCode, &colorCode, &yakaKodu, &p.itemDescription, &p.kategori, &p.askiliYan, &p.urunIlkGrubu, &p.urunAnaGrubu, &p.urunAltGrubu); err != nil {
|
||
return nil, err
|
||
}
|
||
p.askiliYan = cleanProductPerformanceOptionalAttr(p.askiliYan)
|
||
p.urunIlkGrubu = cleanProductPerformanceFirstGroup(p.urunIlkGrubu)
|
||
out[productPerformanceVariantKey(productCode, colorCode, yakaKodu)] = p
|
||
}
|
||
return out, rows.Err()
|
||
}
|
||
|
||
func productPerformanceStockLookup(ctx context.Context, pg *sql.DB, variantKeys []string) (map[string]float64, error) {
|
||
out := make(map[string]float64, len(variantKeys))
|
||
if len(variantKeys) == 0 {
|
||
return out, nil
|
||
}
|
||
rows, err := pg.QueryContext(ctx, `
|
||
WITH Latest AS (
|
||
SELECT MAX(stock_date) AS stock_date
|
||
FROM mk_product_performance_stock_daily
|
||
)
|
||
SELECT
|
||
product_code || '|' || color_code || '|' || yaka_kodu AS variant_key,
|
||
COALESCE(SUM(stock_qty),0) AS stock_qty
|
||
FROM mk_product_performance_stock_daily
|
||
WHERE stock_date = (SELECT stock_date FROM Latest)
|
||
AND product_code || '|' || color_code || '|' || yaka_kodu = ANY($1)
|
||
GROUP BY product_code, color_code, yaka_kodu
|
||
`, pq.Array(variantKeys))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
for rows.Next() {
|
||
var key string
|
||
var stockQty float64
|
||
if err := rows.Scan(&key, &stockQty); err != nil {
|
||
return nil, err
|
||
}
|
||
out[key] = stockQty
|
||
}
|
||
return out, rows.Err()
|
||
}
|
||
|
||
func productPerformanceOrderRecommendation(row models.ProductPerformanceOrderAnalysisRow) (string, string) {
|
||
switch {
|
||
case row.OrderQty > 0 && row.NetStockAfterOrder < 0 && row.ExpectedProfitCostUSD >= 0:
|
||
return "STOKSUZ_TALEP", "Açık sipariş stoktan büyük. Karlı talep var; üretim/satın alma önceliği ver."
|
||
case row.ExpectedProfitCostUSD < 0:
|
||
return "FIYAT_BASKISI", "Açık sipariş çıplak maliyete göre zarar yazıyor. Fiyat/maliyet kontrol edilmeli."
|
||
case row.ExpectedMarginCost >= 0.25 && row.NetStockAfterOrder >= 0:
|
||
return "YILDIZ_URUN", "Açık sipariş karlı ve stok karşılıyor. Teslimat korunmalı."
|
||
case row.ExpectedMarginCost >= 0.25 && row.NetStockAfterOrder < 0:
|
||
return "FIYAT_FIRSATI", "Karlı talep var ama stok yetersiz. Üretim planına alınmalı."
|
||
case row.OverdueQty > 0:
|
||
return "TAKIP", "Termin gecikmesi olan açık sipariş var. Operasyon takibi gerekli."
|
||
default:
|
||
return "TAKIP", "Sipariş, stok ve fiyat düzenli izlenmeli."
|
||
}
|
||
}
|
||
|
||
func productPerformanceOrderGroupRecommendation(row models.ProductPerformanceOrderGroupRow) (string, string) {
|
||
switch {
|
||
case row.ExpectedProfitCostUSD < 0:
|
||
return "FIYAT_BASKISI", "Çıplak maliyete göre zarar yazan açık sipariş var. Fiyat/maliyet acil kontrol edilmeli."
|
||
case row.ExpectedProfitBaseUSD < 0:
|
||
return "FIYAT_BASKISI", "Taban maliyete göre brüt zarar var. Satış fiyatı veya iskonto kontrol edilmeli."
|
||
case row.NetStockAfterOrder < 0 && row.ExpectedProfitCostUSD >= 0:
|
||
return "STOKSUZ_TALEP", "Karlı açık talep var ama stok yetersiz. Üretim/satın alma önceliği ver."
|
||
case row.ExpectedMarginCost >= 0.25 && row.ExpectedMarginBase >= 0.15:
|
||
return "YILDIZ_URUN", "Piyasa/müşteri açık siparişleri karlı. Teslimat ve stok korunmalı."
|
||
case row.OverdueQty > 0:
|
||
return "TAKIP", "Geciken açık sipariş var. Operasyon takibi gerekli."
|
||
default:
|
||
return "TAKIP", "Sipariş karlılığı ve stok yeterliliği izlenmeli."
|
||
}
|
||
}
|
||
|
||
func productPerformanceOrderProductCustomerRecommendation(row models.ProductPerformanceOrderProductCustomerRow) (string, string) {
|
||
switch {
|
||
case row.ExpectedProfitCostUSD < 0:
|
||
return "FIYAT_BASKISI", "Bu müşteri/ürün açık siparişi çıplak maliyete göre zarar yazıyor."
|
||
case row.ExpectedProfitBaseUSD < 0:
|
||
return "FIYAT_BASKISI", "Bu müşteri/ürün açık siparişi taban maliyete göre brüt zarar yazıyor."
|
||
case row.NetStockAfterOrder < 0 && row.ExpectedProfitCostUSD >= 0:
|
||
return "STOKSUZ_TALEP", "Müşteride karlı talep var ama stok yetersiz."
|
||
case row.ExpectedMarginCost >= 0.25 && row.ExpectedMarginBase >= 0.15:
|
||
return "YILDIZ_URUN", "Müşteri bazında karlı açık talep var."
|
||
case row.OverdueQty > 0:
|
||
return "TAKIP", "Bu müşteri/ürün kırılımında geciken açık sipariş var."
|
||
default:
|
||
return "TAKIP", "Müşteri talebi, fiyat ve stok birlikte izlenmeli."
|
||
}
|
||
}
|
||
|
||
func productPerformanceOrderMarketDetailRecommendation(row models.ProductPerformanceOrderMarketDetailRow) (string, string) {
|
||
switch {
|
||
case row.ExpectedProfitCostUSD < 0:
|
||
return "FIYAT_BASKISI", "Sipariş satırı çıplak maliyete göre zarar yazıyor."
|
||
case row.ExpectedProfitBaseUSD < 0:
|
||
return "FIYAT_BASKISI", "Sipariş satırı taban maliyete göre brüt zarar yazıyor."
|
||
case row.NetStockAfterOrder < 0 && row.ExpectedProfitCostUSD >= 0:
|
||
return "STOKSUZ_TALEP", "Karlı sipariş var ama mevcut stok siparişi karşılamıyor."
|
||
case row.IsOverdue:
|
||
return "TAKIP", "Termin geçmiş; teslimat aksiyonu gerekli."
|
||
case row.ExpectedMarginCost >= 0.25:
|
||
return "YILDIZ_URUN", "Sipariş karlı; teslimat ve stok korunmalı."
|
||
default:
|
||
return "TAKIP", "Sipariş fiyatı, stok ve termin izlenmeli."
|
||
}
|
||
}
|
||
|
||
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
|
||
}
|