Merge remote-tracking branch 'origin/master'

svc/db/migrations/2026-05-21_first_group_mail_mappings.sql

@@ -0,0 +1,17 @@
+-- Product First Group mail mappings (Postgres)
+-- Two independent mapping tables:
+-- 1) Costing mails: triggered when a costing is created/updated
+-- 2) Pricing mails: triggered when pricing is created/updated
+
+CREATE TABLE IF NOT EXISTS mk_costing_first_group_mail (
+  urun_ilk_grubu TEXT NOT NULL,
+  mail_id        BIGINT NOT NULL REFERENCES mk_mail(id) ON DELETE CASCADE,
+  PRIMARY KEY (urun_ilk_grubu, mail_id)
+);
+
+CREATE TABLE IF NOT EXISTS mk_pricing_first_group_mail (
+  urun_ilk_grubu TEXT NOT NULL,
+  mail_id        BIGINT NOT NULL REFERENCES mk_mail(id) ON DELETE CASCADE,
+  PRIMARY KEY (urun_ilk_grubu, mail_id)
+);
+

svc/main.go

@@ -321,6 +321,38 @@ func InitRoutes(pgDB *sql.DB, mssql *sql.DB, ml *mailer.GraphMailer) *mux.Router
 		"system", "update",
 		wrapV3(routes.SaveMarketMailMappingHandler(pgDB)),
 	)
+
+	bindV3(r, pgDB,
+		"/api/system/costing-mail-mappings/lookups", "GET",
+		"system", "update",
+		wrapV3(routes.GetCostingFirstGroupMailMappingLookupsHandler(pgDB)),
+	)
+	bindV3(r, pgDB,
+		"/api/system/costing-mail-mappings", "GET",
+		"system", "update",
+		wrapV3(routes.GetCostingFirstGroupMailMappingsHandler(pgDB)),
+	)
+	bindV3(r, pgDB,
+		"/api/system/costing-mail-mappings/{group}", "PUT",
+		"system", "update",
+		wrapV3(routes.SaveCostingFirstGroupMailMappingHandler(pgDB)),
+	)
+
+	bindV3(r, pgDB,
+		"/api/system/pricing-mail-mappings/lookups", "GET",
+		"system", "update",
+		wrapV3(routes.GetPricingFirstGroupMailMappingLookupsHandler(pgDB)),
+	)
+	bindV3(r, pgDB,
+		"/api/system/pricing-mail-mappings", "GET",
+		"system", "update",
+		wrapV3(routes.GetPricingFirstGroupMailMappingsHandler(pgDB)),
+	)
+	bindV3(r, pgDB,
+		"/api/system/pricing-mail-mappings/{group}", "PUT",
+		"system", "update",
+		wrapV3(routes.SavePricingFirstGroupMailMappingHandler(pgDB)),
+	)
 	bindV3(r, pgDB,
 		"/api/language/translations", "GET",
 		"language", "update",

svc/models/first_group_mail_mapping.go

@@ -0,0 +1,17 @@
+package models
+
+type FirstGroupOption struct {
+	ID    string `json:"id"`
+	Label string `json:"label"`
+}
+
+type FirstGroupMailOption struct {
+	ID    string `json:"id"`
+	Label string `json:"label"`
+}
+
+type FirstGroupMailMappingRow struct {
+	UrunIlkGrubu string                 `json:"urun_ilk_grubu"`
+	MailIDs      []string               `json:"mail_ids"`
+	Mails        []FirstGroupMailOption `json:"mails"`
+}

svc/queries/first_group_mail_mapping.go

@@ -0,0 +1,47 @@
+package queries
+
+const GetCostingFirstGroupMailMappingRows = `
+SELECT
+  f.urun_ilk_grubu,
+  m.id::text,
+  m.email,
+  COALESCE(NULLIF(m.display_name, ''), m.email) AS display_name
+FROM mk_costing_first_group_mail f
+JOIN mk_mail m
+  ON m.id = f.mail_id
+  AND m.is_active = true
+ORDER BY f.urun_ilk_grubu, m.email
+`
+
+const DeleteCostingFirstGroupMailsByGroup = `
+DELETE FROM mk_costing_first_group_mail
+WHERE urun_ilk_grubu = $1
+`
+
+const InsertCostingFirstGroupMailMapping = `
+INSERT INTO mk_costing_first_group_mail (urun_ilk_grubu, mail_id)
+VALUES ($1, $2)
+`
+
+const GetPricingFirstGroupMailMappingRows = `
+SELECT
+  f.urun_ilk_grubu,
+  m.id::text,
+  m.email,
+  COALESCE(NULLIF(m.display_name, ''), m.email) AS display_name
+FROM mk_pricing_first_group_mail f
+JOIN mk_mail m
+  ON m.id = f.mail_id
+  AND m.is_active = true
+ORDER BY f.urun_ilk_grubu, m.email
+`
+
+const DeletePricingFirstGroupMailsByGroup = `
+DELETE FROM mk_pricing_first_group_mail
+WHERE urun_ilk_grubu = $1
+`
+
+const InsertPricingFirstGroupMailMapping = `
+INSERT INTO mk_pricing_first_group_mail (urun_ilk_grubu, mail_id)
+VALUES ($1, $2)
+`

svc/queries/product_first_group.go

@@ -0,0 +1,34 @@
+package queries
+
+import (
+	"context"
+	"database/sql"
+	"strings"
+)
+
+// ListProductFirstGroupOptions returns distinct ProductAtt42Desc (UrunIlkGrubu) values from Nebim V3.
+func ListProductFirstGroupOptions(ctx context.Context, mssqlDB *sql.DB, search string, limit int) (*sql.Rows, error) {
+	search = strings.TrimSpace(search)
+	if mssqlDB == nil {
+		return nil, sql.ErrConnDone
+	}
+	if limit <= 0 || limit > 5000 {
+		limit = 5000
+	}
+
+	sqlText := `
+SELECT TOP (@p2)
+  LTRIM(RTRIM(ISNULL(ProductAtt42Desc, ''))) AS urun_ilk_grubu
+FROM ProductFilterWithDescription('TR')
+WHERE IsBlocked = 0
+  AND LTRIM(RTRIM(ISNULL(ProductAtt42Desc, ''))) <> ''
+  AND (
+    @p1 = ''
+    OR LTRIM(RTRIM(ISNULL(ProductAtt42Desc, ''))) LIKE '%' + @p1 + '%'
+  )
+GROUP BY LTRIM(RTRIM(ISNULL(ProductAtt42Desc, '')))
+ORDER BY LTRIM(RTRIM(ISNULL(ProductAtt42Desc, '')));
+`
+
+	return mssqlDB.QueryContext(ctx, sqlText, search, limit)
+}

svc/routes/first_group_mail_mapping.go

@@ -0,0 +1,418 @@
+package routes
+
+import (
+	"bssapp-backend/db"
+	"bssapp-backend/models"
+	"bssapp-backend/queries"
+	"bssapp-backend/utils"
+	"database/sql"
+	"encoding/json"
+	"net/http"
+	"sort"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+type FirstGroupMailSavePayload struct {
+	MailIDs []string `json:"mail_ids"`
+}
+
+type FirstGroupMailLookupResponse struct {
+	FirstGroups []models.FirstGroupOption `json:"first_groups"`
+	Mails       []models.MailOption       `json:"mails"`
+}
+
+func GetCostingFirstGroupMailMappingLookupsHandler(pg *sql.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+		mssql := db.GetDB()
+		if mssql == nil {
+			http.Error(w, "mssql connection not available", http.StatusServiceUnavailable)
+			return
+		}
+
+		traceID := utils.TraceIDFromRequest(r)
+		ctx := utils.ContextWithTraceID(r.Context(), traceID)
+
+		firstGroups := make([]models.FirstGroupOption, 0, 256)
+		mails := make([]models.MailOption, 0, 256)
+
+		fgRows, err := queries.ListProductFirstGroupOptions(ctx, mssql, "", 5000)
+		if err != nil {
+			http.Error(w, "first group lookup error", http.StatusInternalServerError)
+			return
+		}
+		defer fgRows.Close()
+		for fgRows.Next() {
+			var g string
+			if err := fgRows.Scan(&g); err != nil {
+				http.Error(w, "first group scan error", http.StatusInternalServerError)
+				return
+			}
+			g = strings.TrimSpace(g)
+			if g != "" {
+				firstGroups = append(firstGroups, models.FirstGroupOption{ID: g, Label: g})
+			}
+		}
+		if err := fgRows.Err(); err != nil {
+			http.Error(w, "first group rows error", http.StatusInternalServerError)
+			return
+		}
+
+		mailRows, err := pg.Query(queries.GetActiveMailsForMapping)
+		if err != nil {
+			http.Error(w, "mails lookup error", http.StatusInternalServerError)
+			return
+		}
+		defer mailRows.Close()
+		for mailRows.Next() {
+			var item models.MailOption
+			if err := mailRows.Scan(&item.ID, &item.Email, &item.DisplayName); err != nil {
+				http.Error(w, "mails scan error", http.StatusInternalServerError)
+				return
+			}
+			mails = append(mails, item)
+		}
+		if err := mailRows.Err(); err != nil {
+			http.Error(w, "mails rows error", http.StatusInternalServerError)
+			return
+		}
+
+		_ = json.NewEncoder(w).Encode(FirstGroupMailLookupResponse{FirstGroups: firstGroups, Mails: mails})
+	}
+}
+
+func GetPricingFirstGroupMailMappingLookupsHandler(pg *sql.DB) http.HandlerFunc {
+	// same lookups as costing
+	return GetCostingFirstGroupMailMappingLookupsHandler(pg)
+}
+
+func GetCostingFirstGroupMailMappingsHandler(pg *sql.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+		mssql := db.GetDB()
+		if mssql == nil {
+			http.Error(w, "mssql connection not available", http.StatusServiceUnavailable)
+			return
+		}
+
+		traceID := utils.TraceIDFromRequest(r)
+		ctx := utils.ContextWithTraceID(r.Context(), traceID)
+
+		// Fetch all first groups from V3 (source of truth for the list)
+		allGroups := make([]string, 0, 512)
+		fgRows, err := queries.ListProductFirstGroupOptions(ctx, mssql, "", 5000)
+		if err != nil {
+			http.Error(w, "first group lookup error", http.StatusInternalServerError)
+			return
+		}
+		defer fgRows.Close()
+		for fgRows.Next() {
+			var g string
+			if err := fgRows.Scan(&g); err != nil {
+				http.Error(w, "first group scan error", http.StatusInternalServerError)
+				return
+			}
+			g = strings.TrimSpace(g)
+			if g != "" {
+				allGroups = append(allGroups, g)
+			}
+		}
+		if err := fgRows.Err(); err != nil {
+			http.Error(w, "first group rows error", http.StatusInternalServerError)
+			return
+		}
+		sort.Strings(allGroups)
+
+		// Fetch mappings from Postgres
+		rows, err := pg.Query(queries.GetCostingFirstGroupMailMappingRows)
+		if err != nil {
+			http.Error(w, "mapping query error", http.StatusInternalServerError)
+			return
+		}
+		defer rows.Close()
+
+		byGroup := map[string]*models.FirstGroupMailMappingRow{}
+		for _, g := range allGroups {
+			byGroup[g] = &models.FirstGroupMailMappingRow{
+				UrunIlkGrubu: g,
+				MailIDs:      make([]string, 0, 8),
+				Mails:        make([]models.FirstGroupMailOption, 0, 8),
+			}
+		}
+
+		for rows.Next() {
+			var group sql.NullString
+			var mailID sql.NullString
+			var email sql.NullString
+			var displayName sql.NullString
+			if err := rows.Scan(&group, &mailID, &email, &displayName); err != nil {
+				http.Error(w, "mapping scan error", http.StatusInternalServerError)
+				return
+			}
+			g := strings.TrimSpace(group.String)
+			if g == "" {
+				continue
+			}
+			row, ok := byGroup[g]
+			if !ok {
+				row = &models.FirstGroupMailMappingRow{
+					UrunIlkGrubu: g,
+					MailIDs:      make([]string, 0, 8),
+					Mails:        make([]models.FirstGroupMailOption, 0, 8),
+				}
+				byGroup[g] = row
+				allGroups = append(allGroups, g)
+			}
+			if mailID.Valid && strings.TrimSpace(mailID.String) != "" {
+				id := strings.TrimSpace(mailID.String)
+				row.MailIDs = append(row.MailIDs, id)
+				label := strings.TrimSpace(displayName.String)
+				if label == "" {
+					label = strings.TrimSpace(email.String)
+				}
+				row.Mails = append(row.Mails, models.FirstGroupMailOption{ID: id, Label: label})
+			}
+		}
+		if err := rows.Err(); err != nil {
+			http.Error(w, "mapping rows error", http.StatusInternalServerError)
+			return
+		}
+
+		sort.Strings(allGroups)
+		out := make([]models.FirstGroupMailMappingRow, 0, len(allGroups))
+		for _, g := range allGroups {
+			if r := byGroup[g]; r != nil {
+				r.MailIDs = normalizeIDList(r.MailIDs)
+				out = append(out, *r)
+			}
+		}
+		_ = json.NewEncoder(w).Encode(out)
+	}
+}
+
+func GetPricingFirstGroupMailMappingsHandler(pg *sql.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+		mssql := db.GetDB()
+		if mssql == nil {
+			http.Error(w, "mssql connection not available", http.StatusServiceUnavailable)
+			return
+		}
+
+		traceID := utils.TraceIDFromRequest(r)
+		ctx := utils.ContextWithTraceID(r.Context(), traceID)
+
+		allGroups := make([]string, 0, 512)
+		fgRows, err := queries.ListProductFirstGroupOptions(ctx, mssql, "", 5000)
+		if err != nil {
+			http.Error(w, "first group lookup error", http.StatusInternalServerError)
+			return
+		}
+		defer fgRows.Close()
+		for fgRows.Next() {
+			var g string
+			if err := fgRows.Scan(&g); err != nil {
+				http.Error(w, "first group scan error", http.StatusInternalServerError)
+				return
+			}
+			g = strings.TrimSpace(g)
+			if g != "" {
+				allGroups = append(allGroups, g)
+			}
+		}
+		if err := fgRows.Err(); err != nil {
+			http.Error(w, "first group rows error", http.StatusInternalServerError)
+			return
+		}
+		sort.Strings(allGroups)
+
+		rows, err := pg.Query(queries.GetPricingFirstGroupMailMappingRows)
+		if err != nil {
+			http.Error(w, "mapping query error", http.StatusInternalServerError)
+			return
+		}
+		defer rows.Close()
+
+		byGroup := map[string]*models.FirstGroupMailMappingRow{}
+		for _, g := range allGroups {
+			byGroup[g] = &models.FirstGroupMailMappingRow{
+				UrunIlkGrubu: g,
+				MailIDs:      make([]string, 0, 8),
+				Mails:        make([]models.FirstGroupMailOption, 0, 8),
+			}
+		}
+
+		for rows.Next() {
+			var group sql.NullString
+			var mailID sql.NullString
+			var email sql.NullString
+			var displayName sql.NullString
+			if err := rows.Scan(&group, &mailID, &email, &displayName); err != nil {
+				http.Error(w, "mapping scan error", http.StatusInternalServerError)
+				return
+			}
+			g := strings.TrimSpace(group.String)
+			if g == "" {
+				continue
+			}
+			row, ok := byGroup[g]
+			if !ok {
+				row = &models.FirstGroupMailMappingRow{
+					UrunIlkGrubu: g,
+					MailIDs:      make([]string, 0, 8),
+					Mails:        make([]models.FirstGroupMailOption, 0, 8),
+				}
+				byGroup[g] = row
+				allGroups = append(allGroups, g)
+			}
+			if mailID.Valid && strings.TrimSpace(mailID.String) != "" {
+				id := strings.TrimSpace(mailID.String)
+				row.MailIDs = append(row.MailIDs, id)
+				label := strings.TrimSpace(displayName.String)
+				if label == "" {
+					label = strings.TrimSpace(email.String)
+				}
+				row.Mails = append(row.Mails, models.FirstGroupMailOption{ID: id, Label: label})
+			}
+		}
+		if err := rows.Err(); err != nil {
+			http.Error(w, "mapping rows error", http.StatusInternalServerError)
+			return
+		}
+
+		sort.Strings(allGroups)
+		out := make([]models.FirstGroupMailMappingRow, 0, len(allGroups))
+		for _, g := range allGroups {
+			if r := byGroup[g]; r != nil {
+				r.MailIDs = normalizeIDList(r.MailIDs)
+				out = append(out, *r)
+			}
+		}
+		_ = json.NewEncoder(w).Encode(out)
+	}
+}
+
+func SaveCostingFirstGroupMailMappingHandler(pg *sql.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+		group := strings.TrimSpace(mux.Vars(r)["group"])
+		if group == "" {
+			http.Error(w, "invalid urun_ilk_grubu", http.StatusBadRequest)
+			return
+		}
+
+		var payload FirstGroupMailSavePayload
+		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+			http.Error(w, "invalid payload", http.StatusBadRequest)
+			return
+		}
+
+		mailIDs := normalizeIDList(payload.MailIDs)
+		for _, mailID := range mailIDs {
+			var mailExists bool
+			if err := pg.QueryRow(queries.ExistsActiveMailByID, mailID).Scan(&mailExists); err != nil {
+				http.Error(w, "mail validate error", http.StatusInternalServerError)
+				return
+			}
+			if !mailExists {
+				http.Error(w, "mail not found: "+mailID, http.StatusBadRequest)
+				return
+			}
+		}
+
+		tx, err := pg.Begin()
+		if err != nil {
+			http.Error(w, "transaction start error", http.StatusInternalServerError)
+			return
+		}
+		defer tx.Rollback()
+
+		if _, err := tx.Exec(queries.DeleteCostingFirstGroupMailsByGroup, group); err != nil {
+			http.Error(w, "mapping delete error", http.StatusInternalServerError)
+			return
+		}
+		for _, mailID := range mailIDs {
+			if _, err := tx.Exec(queries.InsertCostingFirstGroupMailMapping, group, mailID); err != nil {
+				http.Error(w, "mapping insert error", http.StatusInternalServerError)
+				return
+			}
+		}
+
+		if err := tx.Commit(); err != nil {
+			http.Error(w, "transaction commit error", http.StatusInternalServerError)
+			return
+		}
+
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"success":        true,
+			"urun_ilk_grubu": group,
+			"mail_ids":       mailIDs,
+		})
+	}
+}
+
+func SavePricingFirstGroupMailMappingHandler(pg *sql.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+
+		group := strings.TrimSpace(mux.Vars(r)["group"])
+		if group == "" {
+			http.Error(w, "invalid urun_ilk_grubu", http.StatusBadRequest)
+			return
+		}
+
+		var payload FirstGroupMailSavePayload
+		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+			http.Error(w, "invalid payload", http.StatusBadRequest)
+			return
+		}
+
+		mailIDs := normalizeIDList(payload.MailIDs)
+		for _, mailID := range mailIDs {
+			var mailExists bool
+			if err := pg.QueryRow(queries.ExistsActiveMailByID, mailID).Scan(&mailExists); err != nil {
+				http.Error(w, "mail validate error", http.StatusInternalServerError)
+				return
+			}
+			if !mailExists {
+				http.Error(w, "mail not found: "+mailID, http.StatusBadRequest)
+				return
+			}
+		}
+
+		tx, err := pg.Begin()
+		if err != nil {
+			http.Error(w, "transaction start error", http.StatusInternalServerError)
+			return
+		}
+		defer tx.Rollback()
+
+		if _, err := tx.Exec(queries.DeletePricingFirstGroupMailsByGroup, group); err != nil {
+			http.Error(w, "mapping delete error", http.StatusInternalServerError)
+			return
+		}
+		for _, mailID := range mailIDs {
+			if _, err := tx.Exec(queries.InsertPricingFirstGroupMailMapping, group, mailID); err != nil {
+				http.Error(w, "mapping insert error", http.StatusInternalServerError)
+				return
+			}
+		}
+
+		if err := tx.Commit(); err != nil {
+			http.Error(w, "transaction commit error", http.StatusInternalServerError)
+			return
+		}
+
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"success":        true,
+			"urun_ilk_grubu": group,
+			"mail_ids":       mailIDs,
+		})
+	}
+}

svc/routes/production_product_costing_pdf.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"net/http"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -265,8 +266,9 @@ func (c *costingPDF) drawHeaderFull() {
 		firmaLabel = fmt.Sprintf("%s - %s", firmaLabel, strings.TrimSpace(c.header.UretimiYapanFirma))
 	}
 	line3 := fmt.Sprintf(
-		"Firma: %s | Kaydeden: %s | Son Guncelleme: %s (%s)",
+		"Firma: %s | 2.Firma: %s | Kaydeden: %s | Son Guncelleme: %s (%s)",
 		firmaLabel,
+		strings.TrimSpace(c.header.SonIsEmriVeren),
 		strings.TrimSpace(c.header.SKullaniciAdi),
 		formatDateTRDot(c.header.DteGuncellemeTarihi),
 		strings.TrimSpace(c.header.SGuncellemeKullaniciAdi),
@@ -509,7 +511,17 @@ func (c *costingPDF) drawGroup(g models.ProductionHasCostDetailGroup, firstGroup
 	wn := []float64{8, 20, 22, 32, 70, 14, 14, 10, 16, 16, 16, 16} // sum = 250
 
 	c.drawTableHeader(cols, wn)
-	for i, it := range g.Items {
+	// PDF-specific ordering: by hammadde turu no, then code.
+	items := append([]models.ProductionHasCostDetailGroupItem(nil), g.Items...)
+	sort.Slice(items, func(i, j int) bool {
+		ai, _ := strconv.Atoi(strings.TrimSpace(items[i].NHammaddeTuruNo))
+		aj, _ := strconv.Atoi(strings.TrimSpace(items[j].NHammaddeTuruNo))
+		if ai != aj {
+			return ai < aj
+		}
+		return strings.TrimSpace(items[i].SKodu) < strings.TrimSpace(items[j].SKodu)
+	})
+	for i, it := range items {
 		c.drawRowWithGroup(it, wn, cols, g, i)
 	}
 	pdf.Ln(2)