HY2XS_flamy/apps/controller/peer.go

package controller

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
	"hy2xs-admin/model/bo"
	"hy2xs-admin/model/constant"
	"hy2xs-admin/model/dto"
	"hy2xs-admin/model/vo"
	"hy2xs-admin/service"
)

func resolveID(c *gin.Context) (int64, error) {
	if raw := strings.TrimSpace(c.Param("id")); raw != "" {
		parsed, err := strconv.ParseInt(raw, 10, 64)
		if err == nil && parsed > 0 {
			return parsed, nil
		}
	}
	idDto, err := validateField(c, dto.IdDto{})
	if err != nil {
		return 0, err
	}
	return *idDto.Id, nil
}

func Login(c *gin.Context) {
	loginDto, err := validateField(c, dto.LoginDto{})
	if err != nil {
		return
	}
	token, forcePasswordChange, err := service.Login(*loginDto.Username, *loginDto.Pass)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(vo.JwtVo{TokenType: constant.TokenType, AccessToken: token, ForcePasswordChange: forcePasswordChange}, c)
}

func PagePeer(c *gin.Context) {
	peerPageDto, err := validateField(c, dto.PeerPageDto{})
	if err != nil {
		return
	}
	records, total, err := service.PagePeer(peerPageDto)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(vo.PeerPageVo{Records: records, Total: total}, c)
}

func SavePeer(c *gin.Context) {
	peerSaveDto, err := validateField(c, dto.PeerSaveDto{})
	if err != nil {
		return
	}
	peerVo, err := service.CreatePeer(peerSaveDto)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(peerVo, c)
}

func DeletePeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	if err = service.DeletePeer(id); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func UpdatePeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	peerUpdateDto, err := validateField(c, dto.PeerUpdateDto{})
	if err != nil {
		return
	}
	peerUpdateDto.Id = &id
	if peerUpdateDto.Name != nil && *peerUpdateDto.Name != "" {
		taken, nameErr := service.ExistPeerName(*peerUpdateDto.Name, id)
		if nameErr != nil {
			vo.Fail(nameErr.Error(), c)
			return
		}
		if taken {
			vo.Fail(fmt.Sprintf("name %s already exists", *peerUpdateDto.Name), c)
			return
		}
	}
	if err = service.UpdatePeer(id, peerUpdateDto); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func ResetTraffic(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	if err = service.ResetPeerTraffic(id); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func GetPeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	peer, err := service.GetPeerVo(id)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(peer, c)
}

// peerImportMaxBytes — предел размера загружаемого файла.
const peerImportMaxBytes = 2 * 1024 * 1024

// ImportPeer принимает выгрузку, сделанную ExportPeer.
//
// Импорт — полноценная дверь в таблицу пиров, поэтому его вход проверяется
// так же строго, как обычное создание пира: разбор JSON ограничен по размеру,
// неизвестные поля отклоняются, а содержимое записей валидируется в
// service.ValidatePeerImportBatch до первой записи в базу.
func ImportPeer(c *gin.Context) {
	file, header, err := c.Request.FormFile("file")
	if err != nil {
		vo.Fail(constant.SysError, c)
		return
	}
	defer func() { _ = file.Close() }()

	if header.Size > peerImportMaxBytes {
		vo.Fail("the file is too big", c)
		return
	}
	if !strings.HasSuffix(strings.ToLower(header.Filename), ".json") {
		vo.Fail(constant.InvalidError, c)
		return
	}

	// Заявленный Size — это то, что сказал клиент; читаем с собственным
	// пределом, чтобы расхождение не превращалось в чтение произвольного
	// объёма в память.
	content, err := io.ReadAll(io.LimitReader(file, peerImportMaxBytes+1))
	if err != nil {
		vo.Fail("json file read err", c)
		return
	}
	if len(content) > peerImportMaxBytes {
		vo.Fail("the file is too big", c)
		return
	}

	var peerExports []bo.PeerExport
	decoder := json.NewDecoder(bytes.NewReader(content))
	// Опечатка в имени поля должна быть видимой ошибкой, а не молча
	// импортированным значением по умолчанию.
	decoder.DisallowUnknownFields()
	if err = decoder.Decode(&peerExports); err != nil {
		vo.Fail("content Unmarshal err", c)
		return
	}

	// json.Decoder читает ПЕРВЫЙ документ и останавливается. Файл вида
	//
	//     [{"name":"peer"}]
	//     {"что-то":"ещё"}
	//
	// принимался целиком, а хвост просто не читался: оператор видел «импорт
	// выполнен» и не узнавал, что применилась половина файла. Файл обязан
	// содержать ровно один JSON-документ.
	if err = decoder.Decode(&struct{}{}); err != io.EOF {
		vo.Fail("json file must contain exactly one JSON document", c)
		return
	}

	if err = service.UpsertPeerExport(peerExports); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

// ExportPeer отдаёт выгрузку пиров прямо в ответ, не создавая файл на сервере.
//
// Раньше выгрузка шла через os.Create в /var/lib/hy2xs-admin/export и файл
// оставался там навсегда. При includeSecrets=true это означало расшифрованные
// секреты пиров — фактические учётные данные доступа — в открытом виде на
// диске, накапливающиеся с каждым нажатием кнопки. Артефакт, который покидает
// сервер, не должен существовать на сервере дольше самого запроса.
func ExportPeer(c *gin.Context) {
	includeSecrets := strings.EqualFold(strings.TrimSpace(c.Query("includeSecrets")), "true")
	peerExports, err := service.ListExportPeer(includeSecrets)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}

	payload, err := json.MarshalIndent(peerExports, "", "    ")
	if err != nil {
		logrus.Errorf("peer export marshal err: %v", err)
		vo.Fail(constant.SysError, c)
		return
	}

	fileName := fmt.Sprintf("PeerExport-%s.json", time.Now().Format("20060102150405"))
	c.Header("Content-Type", "application/octet-stream")
	c.Header("Content-Transfer-Encoding", "binary")
	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", fileName))
	c.Data(200, "application/octet-stream", payload)
}

func ReleaseKickPeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	if err = service.ReleaseKickPeer(id); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func KickPeer(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	kickDto, err := validateField(c, dto.PeerKickDto{})
	if err != nil {
		return
	}
	if err = service.KickPeer(id, *kickDto.BannedUntil); err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(nil, c)
}

func PeerClientConfig(c *gin.Context) {
	id, err := resolveID(c)
	if err != nil {
		return
	}
	data, err := service.BuildPeerClientConfig(id)
	if err != nil {
		vo.Fail(err.Error(), c)
		return
	}
	vo.Success(data, c)
}