Bridge-and-Join-s/internal/lkgateway/depo_procs.go

package lkgateway

// depo_procs.go — установка процедур обработки bj2depo (FTV_M2M_PROCESS_* и FTV_M2M_JOB)
// в базу DEPO прямо из bj: «Проверить возможности» (предпросмотр без изменений) и
// «Установить» (выполняется логином администратора SQL — разово, не сохраняется).
// Процедуры встроены в bj (internal/lkgateway/depoprocs/*.sql), порядок установки —
// WIRING → OPERATION → EVENTS → CREATE → JOB; затем GRANT EXECUTE на FTV_M2M_JOB логину bj.

import (
	"context"
	"database/sql"
	"embed"
	"fmt"
	"log"
	"net/http"
	"regexp"
	"strings"
	"time"
)

//go:embed depoprocs/*.sql
var depoProcFS embed.FS

// depoProcInstallOrder — имя процедуры и файл; порядок важен для зависимостей.
var depoProcInstallOrder = []struct{ Name, File string }{
	{"FTV_M2M_PROCESS_WIRING", "depoprocs/FTV_M2M_PROCESS_WIRING.sql"},
	{"FTV_M2M_PROCESS_OPERATION", "depoprocs/FTV_M2M_PROCESS_OPERATION.sql"},
	{"FTV_M2M_PROCESS_EVENTS", "depoprocs/FTV_M2M_PROCESS_EVENTS.sql"},
	{"FTV_M2M_PROCESS_CREATE", "depoprocs/FTV_M2M_PROCESS_CREATE.sql"},
	{"FTV_M2M_JOB", "depoprocs/FTV_M2M_JOB.sql"},
}

var goBatchRe = regexp.MustCompile(`(?im)^\s*GO\s*$`)

// splitSQLBatches — разбить скрипт на батчи по строкам «GO» (директива клиента, не T-SQL).
func splitSQLBatches(s string) []string {
	var out []string
	for _, part := range goBatchRe.Split(s, -1) {
		if strings.TrimSpace(part) != "" {
			out = append(out, part)
		}
	}
	return out
}

// depoProcFile — тело встроенной (исходной) процедуры из файла.
func depoProcFile(file string) (string, error) {
	b, err := depoProcFS.ReadFile(file)
	if err != nil {
		return "", err
	}
	return string(b), nil
}

// embeddedProcBody — встроенный текст процедуры по имени.
func embeddedProcBody(name string) string {
	for _, p := range depoProcInstallOrder {
		if p.Name == name {
			b, _ := depoProcFile(p.File)
			return b
		}
	}
	return ""
}

// depoProcEffective — текст процедуры с учётом правки под клиента: сохранённый
// в настройках вариант, иначе встроенный. Используется в предпросмотре, установке
// и скачиваемом скрипте.
func depoProcEffective(f FancyMSSQLSettings, name string) string {
	if v, ok := f.DepoProcOverrides[name]; ok && strings.TrimSpace(v) != "" {
		return v
	}
	return embeddedProcBody(name)
}

// depoProcList — порядок процедур для шаблона (редактор текстов).
func depoProcList() []struct{ Name, File string } { return depoProcInstallOrder }

// depoProcsCombined — единый скрипт установки (для скачивания администратору): USE, процедуры, GRANT.
func depoProcsCombined(f FancyMSSQLSettings) string {
	return depoProcsScriptFor(f, f.DepoDB(), depoSetupLogin(f))
}

// depoProcsScriptFor — скрипт установки процедур в базу db с выдачей EXECUTE логину login.
// Тексты процедур — с учётом правки под клиента (depoProcEffective).
func depoProcsScriptFor(f FancyMSSQLSettings, db, login string) string {
	var b strings.Builder
	b.WriteString("/* Bridge&Join: процедуры обработки bj2depo для базы DEPO.\n")
	b.WriteString("   Порядок WIRING -> OPERATION -> EVENTS -> CREATE -> JOB. Запуск под sysadmin в SSMS.\n")
	b.WriteString("   CREATE OR ALTER — повторный запуск безопасен (данные не меняются). */\n")
	fmt.Fprintf(&b, "USE %s;\nGO\n\n", quoteIdent(db))
	for _, p := range depoProcInstallOrder {
		body := depoProcEffective(f, p.Name)
		if strings.TrimSpace(body) == "" {
			continue
		}
		fmt.Fprintf(&b, "/* ===== %s ===== */\n%s\nGO\n\n", p.Name, strings.TrimRight(body, "\n"))
	}
	if depoLoginRe.MatchString(login) {
		fmt.Fprintf(&b, "/* Право запуска задания логину bj */\nGRANT EXECUTE ON dbo.FTV_M2M_JOB TO %s;\nGO\n", quoteIdent(login))
	}
	return b.String()
}

// depoProcsInstallInto — установить процедуры (CREATE OR ALTER, с учётом правки под клиента) в базу
// dbName соединением adm (логин администратора) и выдать EXECUTE логину grantLogin.
func depoProcsInstallInto(ctx context.Context, adm, f FancyMSSQLSettings, dbName, grantLogin string) error {
	db, err := fancyOpen(adm, dbName)
	if err != nil {
		return err
	}
	defer db.Close()
	for _, p := range depoProcInstallOrder {
		body := depoProcEffective(f, p.Name)
		if strings.TrimSpace(body) == "" {
			return fmt.Errorf("пустой текст процедуры %s", p.Name)
		}
		for _, batch := range splitSQLBatches(body) {
			if _, err := db.ExecContext(ctx, batch); err != nil {
				return fmt.Errorf("установка %s: %s", p.Name, quikErrorDetail(err))
			}
		}
	}
	if depoLoginRe.MatchString(grantLogin) {
		if _, err := db.ExecContext(ctx, "GRANT EXECUTE ON dbo.FTV_M2M_JOB TO "+quoteIdent(grantLogin)); err != nil {
			return fmt.Errorf("право EXECUTE логину %s: %s", grantLogin, quikErrorDetail(err))
		}
	}
	return nil
}

// quoteIdent — квадратные скобки для идентификатора T-SQL.
func quoteIdent(s string) string { return "[" + strings.ReplaceAll(s, "]", "]]") + "]" }

// depoProcsPreflight — проверка возможности установки (без изменений в базе). Возвращает отчёт
// для экрана, признак «можно применять» и ошибку подключения/проверки.
func depoProcsPreflight(ctx context.Context, f FancyMSSQLSettings, adminUser, adminPass string) (report string, canApply bool, err error) {
	if f.IsPostgres() {
		return "", false, fmt.Errorf("установка процедур bj2depo поддержана только для MSSQL")
	}
	conn := f
	admin := strings.TrimSpace(adminUser)
	if admin != "" {
		conn.User, conn.Password = admin, adminPass
	}
	db, err := fancyOpen(conn, f.DepoDB())
	if err != nil {
		return "", false, err
	}
	defer db.Close()
	if err := db.PingContext(ctx); err != nil {
		return "", false, fmt.Errorf("подключение к базе %s логином %s: %s", f.DepoDB(), conn.User, quikErrorDetail(err))
	}
	if err := depoCheckIsDepo(ctx, conn, f.DepoDB()); err != nil {
		return "", false, err
	}
	missing := depoMissing(ctx, db, depoBj2depoProcs, "P")
	login := depoSetupLogin(f)
	execAs := depoProcExecAsUser(f) // пользователь для EXECUTE AS в теле процедур (обычно SYSDBA)
	var canCreate, sysadmin, bjUser, execAsOK int
	_ = db.QueryRowContext(ctx,
		`SELECT CAST(ISNULL(HAS_PERMS_BY_NAME(NULL,'DATABASE','CREATE PROCEDURE'),0) AS int),
		        CAST(ISNULL(IS_SRVROLEMEMBER('sysadmin'),0) AS int),
		        CASE WHEN DATABASE_PRINCIPAL_ID(@u) IS NULL THEN 0 ELSE 1 END,
		        CASE WHEN DATABASE_PRINCIPAL_ID(@e) IS NULL THEN 0 ELSE 1 END`,
		sql.Named("u", login), sql.Named("e", execAs)).Scan(&canCreate, &sysadmin, &bjUser, &execAsOK)
	canApply = (canCreate == 1 || sysadmin == 1) && execAsOK == 1

	var b strings.Builder
	fmt.Fprintf(&b, "Сервер %s, база %s, логин %s.\n", f.Server, f.DepoDB(), conn.User)
	if len(missing) == 0 {
		b.WriteString("Процедуры: все 5 уже установлены (будут обновлены CREATE OR ALTER).\n")
	} else {
		fmt.Fprintf(&b, "Процедуры: нет %d из 5 (%s).\n", len(missing), strings.Join(missing, ", "))
	}
	if canApply {
		b.WriteString("Право создавать процедуры: есть.\n")
	} else {
		b.WriteString("Право создавать процедуры: НЕТ — введите логин администратора SQL (sysadmin, обычно sa).\n")
	}
	if bjUser == 1 {
		fmt.Fprintf(&b, "Логин %s в базе: есть — выдам ему EXECUTE на FTV_M2M_JOB.\n", login)
	} else {
		fmt.Fprintf(&b, "Логин %s в базе: нет — сначала подготовьте базу (логин/таблицы), GRANT будет пропущен.\n", login)
	}
	if execAsOK == 1 {
		fmt.Fprintf(&b, "Пользователь %s (для EXECUTE AS в процедурах): есть.\n", execAs)
	} else {
		fmt.Fprintf(&b, "Пользователь %s (для EXECUTE AS в процедурах): НЕТ — процедуры FTV_M2M_PROCESS_* используют EXECUTE AS USER='%s' и не создадутся без него. Создайте этого пользователя в базе (как в рабочей базе Fancy) или замените имя в «Тексты процедур».\n", execAs, execAs)
	}
	b.WriteString("Будет выполнено: CREATE OR ALTER 5 процедур (WIRING→OPERATION→EVENTS→CREATE→JOB) + GRANT EXECUTE на FTV_M2M_JOB.")
	return b.String(), canApply, nil
}

// depoProcExecAsUser — пользователь, под которым процедуры выполняют EXECUTE AS (из их текста,
// строка «execute as user = '...'»). По умолчанию SYSDBA.
func depoProcExecAsUser(f FancyMSSQLSettings) string {
	body := depoProcEffective(f, "FTV_M2M_PROCESS_WIRING")
	if m := execAsUserRe.FindStringSubmatch(body); len(m) == 2 {
		return m[1]
	}
	return "SYSDBA"
}

var execAsUserRe = regexp.MustCompile(`(?i)execute\s+as\s+user\s*=\s*'([^']+)'`)

// depoProcErrHint — подсказка по типичной причине отказа CREATE процедур.
func depoProcErrHint(msg string) string {
	l := strings.ToLower(msg)
	if strings.Contains(l, "sysdba") || strings.Contains(l, "principal") || strings.Contains(l, "15517") ||
		strings.Contains(l, "execute as") || strings.Contains(l, "не удается олицетворить") || strings.Contains(l, "олицетвор") {
		return " Процедуры FTV_M2M_PROCESS_* используют EXECUTE AS USER='SYSDBA' — в базе DEPO должен быть пользователь SYSDBA (как в рабочей базе Fancy). Создайте его или замените имя пользователя в «Тексты процедур» и повторите."
	}
	return ""
}

// depoProcsInstall — установить процедуры логином администратора. Сначала preflight; при отсутствии
// прав — отказ без изменений. Возвращает итоговое сообщение.
func depoProcsInstall(ctx context.Context, f FancyMSSQLSettings, adminUser, adminPass string) (string, error) {
	report, canApply, err := depoProcsPreflight(ctx, f, adminUser, adminPass)
	if err != nil {
		return "", err
	}
	if !canApply {
		return "", fmt.Errorf("нет прав на установку. %s", report)
	}
	adm := f
	if u := strings.TrimSpace(adminUser); u != "" {
		adm.User, adm.Password = u, adminPass
	}
	login := depoSetupLogin(f)
	if err := depoProcsInstallInto(ctx, adm, f, f.DepoDB(), login); err != nil {
		return "", err
	}
	msg := "установлено процедур: 5 (WIRING, OPERATION, EVENTS, CREATE, JOB); право EXECUTE логину " + login + " выдано"
	log.Printf("depo-procs: %s", msg)
	return msg, nil
}

// ---- хендлеры ----

// checkFancyDepoProcs — POST /admin/setup/fancy/depo-procs/check: проверка возможностей (без изменений).
func (h *setupHandlers) checkFancyDepoProcs(w http.ResponseWriter, r *http.Request) {
	if !requireDepo(w, r) {
		return
	}
	if r.Method != http.MethodPost {
		http.Error(w, "method", http.StatusMethodNotAllowed)
		return
	}
	s := h.rc.Snapshot().Fancy
	if s.Server == "" {
		setupFlash(w, r, "Процедуры DEPO: сначала сохраните подключение к серверу БД")
		return
	}
	ctx, cancel := context.WithTimeout(depoLoginForce(r.Context()), time.Minute)
	defer cancel()
	report, canApply, err := depoProcsPreflight(ctx, s, r.FormValue("admin_user"), r.FormValue("admin_password"))
	if err != nil {
		setupFlash(w, r, "Процедуры DEPO: проверка не удалась — "+err.Error())
		return
	}
	verdict := "можно устанавливать"
	if !canApply {
		verdict = "установка невозможна"
	}
	setupFlash(w, r, "Процедуры DEPO ("+verdict+"): "+report)
}

// installFancyDepoProcs — POST /admin/setup/fancy/depo-procs/install: установить процедуры.
func (h *setupHandlers) installFancyDepoProcs(w http.ResponseWriter, r *http.Request) {
	if !requireDepo(w, r) {
		return
	}
	if r.Method != http.MethodPost {
		http.Error(w, "method", http.StatusMethodNotAllowed)
		return
	}
	s := h.rc.Snapshot().Fancy
	if s.Server == "" {
		setupFlash(w, r, "Процедуры DEPO: сначала сохраните подключение к серверу БД")
		return
	}
	ctx, cancel := context.WithTimeout(depoLoginForce(r.Context()), 2*time.Minute)
	defer cancel()
	msg, err := depoProcsInstall(ctx, s, r.FormValue("admin_user"), r.FormValue("admin_password"))
	if err != nil {
		log.Printf("depo-procs: установка не удалась: %v", err)
		txt := "установка не удалась: " + err.Error() + depoProcErrHint(err.Error())
		s2 := h.rc.Snapshot().Fancy // сохранить ошибку, чтобы не мелькала во флеше
		s2.DepoProcCheck, s2.DepoProcCheckOK, s2.DepoProcCheckAt = txt, false, time.Now()
		_ = h.rc.UpdateFancy(s2)
		setupFlash(w, r, "Процедуры DEPO: "+txt)
		return
	}
	pmsg, pok := depoProcCheck(ctx, h.rc)
	s = h.rc.Snapshot().Fancy
	s.DepoProcCheck, s.DepoProcCheckOK, s.DepoProcCheckAt = pmsg, pok, time.Now()
	_ = h.rc.UpdateFancy(s)
	setupFlash(w, r, "Процедуры DEPO: "+msg+". Проверка обработки: "+pmsg)
}

// fancyDepoProcsScript — GET /admin/setup/fancy/depo-procs/script.sql: единый скрипт для администратора.
func (h *setupHandlers) fancyDepoProcsScript(w http.ResponseWriter, r *http.Request) {
	s := h.rc.Snapshot().Fancy
	w.Header().Set("Content-Type", "application/sql; charset=utf-8")
	w.Header().Set("Content-Disposition", `attachment; filename="bj-depo-procs-mssql.sql"`)
	// UTF-8 BOM (0xEF 0xBB 0xBF): SSMS без него читает кириллицу в комментариях как ANSI.
	_, _ = w.Write(append([]byte{0xEF, 0xBB, 0xBF}, depoProcsCombined(s)...))
}

// saveFancyDepoProcsText — POST /admin/setup/fancy/depo-procs/save-text: сохранить правку текстов процедур
// под клиента. Пустое поле или совпадение со встроенным текстом — вернуть встроенную версию (убрать правку).
func (h *setupHandlers) saveFancyDepoProcsText(w http.ResponseWriter, r *http.Request) {
	if !requireDepo(w, r) {
		return
	}
	if r.Method != http.MethodPost {
		http.Error(w, "method", http.StatusMethodNotAllowed)
		return
	}
	s := h.rc.Snapshot().Fancy
	ov := map[string]string{}
	changed := 0
	for _, p := range depoProcInstallOrder {
		v := strings.ReplaceAll(r.FormValue("proc_"+p.Name), "\r\n", "\n")
		if strings.TrimSpace(v) != "" && strings.TrimSpace(v) != strings.TrimSpace(embeddedProcBody(p.Name)) {
			ov[p.Name] = v
			changed++
		}
	}
	if changed == 0 {
		s.DepoProcOverrides = nil
	} else {
		s.DepoProcOverrides = ov
	}
	if err := h.rc.UpdateFancy(s); err != nil {
		setupFlash(w, r, "Тексты процедур: ошибка сохранения — "+err.Error())
		return
	}
	setupFlash(w, r, fmt.Sprintf("Тексты процедур сохранены. Изменённых под клиента: %d (пустые или совпадающие со встроенными — используется встроенная версия).", changed))
}