kra-new/internal/server/handler/dictionary.go

package handler

import (
	"strconv"

	"kra/internal/biz"
	"kra/internal/server/httpx"
	"kra/internal/service"
	"kra/internal/service/dto"

	"github.com/gin-gonic/gin"
)

type Dictionary struct{ service *service.SettingsService }

func NewDictionary(service *service.SettingsService) *Dictionary {
	return &Dictionary{service: service}
}

func (h *Dictionary) Create(c *gin.Context) {
	var req dto.DictionaryRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	created, err := h.service.CreateDictionaryRequest(c.Request.Context(), &req)
	if err != nil {
		httpx.Fail(c, "创建失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, created, "创建成功")
}
func (h *Dictionary) Update(c *gin.Context) {
	var req dto.DictionaryRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	if err := h.service.UpdateDictionaryRequest(c.Request.Context(), &req); err != nil {
		httpx.Fail(c, "更新失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{}, "更新成功")
}
func (h *Dictionary) Delete(c *gin.Context) {
	var req dto.DictionaryRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	if err := h.service.DeleteDictionary(c.Request.Context(), req.ID); err != nil {
		httpx.Fail(c, "删除失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{}, "删除成功")
}
func (h *Dictionary) Find(c *gin.Context) {
	var req dto.DictionaryRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	item, err := h.service.Dictionary(c.Request.Context(), req.ID, req.Type, req.Status, true)
	if err != nil {
		httpx.Fail(c, "字典未创建或未开启")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{"resysDictionary": item}, "查询成功")
}
func (h *Dictionary) List(details bool) gin.HandlerFunc {
	return func(c *gin.Context) {
		items, _, err := h.service.Dictionaries(c.Request.Context(), 0, 0, c.Query("name"), "", details)
		if err != nil {
			httpx.Fail(c, "获取失败")
			return
		}
		httpx.Write(c, httpx.CodeSuccess, items, "获取成功")
	}
}
func (h *Dictionary) Export(c *gin.Context) {
	var req dto.DictionaryRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	if req.ID == 0 {
		httpx.Fail(c, "字典ID不能为空")
		return
	}
	item, err := h.service.ExportDictionary(c.Request.Context(), req.ID)
	if err != nil {
		httpx.Fail(c, "导出失败")
		return
	}
	delete(item, "ID")
	delete(item, "CreatedAt")
	delete(item, "UpdatedAt")
	delete(item, "DeletedAt")
	if details, ok := item["sysDictionaryDetails"].([]map[string]any); ok {
		for _, detail := range details {
			for _, key := range []string{"ID", "CreatedAt", "UpdatedAt", "DeletedAt", "sysDictionaryID", "parentID", "disabled", "children"} {
				delete(detail, key)
			}
		}
	}
	httpx.Write(c, httpx.CodeSuccess, item, "导出成功")
}
func (h *Dictionary) Import(c *gin.Context) {
	var req dto.ImportDictionaryRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	if err := h.service.ImportDictionaryJSON(c.Request.Context(), req.JSON); err != nil {
		httpx.Fail(c, "导入失败: "+err.Error())
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{}, "导入成功")
}

func (h *Dictionary) CreateDetail(c *gin.Context) {
	var req dto.DictionaryDetailRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	if err := h.service.CreateDictionaryDetailRequest(c.Request.Context(), &req); err != nil {
		httpx.Fail(c, "创建失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{}, "创建成功")
}
func (h *Dictionary) UpdateDetail(c *gin.Context) {
	var req dto.DictionaryDetailRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	if err := h.service.UpdateDictionaryDetailRequest(c.Request.Context(), &req); err != nil {
		httpx.Fail(c, "更新失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{}, "更新成功")
}
func (h *Dictionary) DeleteDetail(c *gin.Context) {
	var req dto.DictionaryDetailRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	if err := h.service.DeleteDictionaryDetail(c.Request.Context(), req.ID); err != nil {
		httpx.Fail(c, "删除失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{}, "删除成功")
}
func (h *Dictionary) FindDetail(c *gin.Context) {
	var req dto.DictionaryDetailRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	item, err := h.service.DictionaryDetail(c.Request.Context(), req.ID)
	if err != nil {
		httpx.Fail(c, "查询失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{"reSysDictionaryDetail": item}, "查询成功")
}
func (h *Dictionary) Details(c *gin.Context) {
	p, size := page(c)
	dictionaryID, _ := strconv.ParseUint(c.Query("sysDictionaryID"), 10, 64)
	filter := biz.DictionaryDetailFilter{DictionaryID: uint(dictionaryID), Label: c.Query("label"), Value: c.Query("value")}
	if raw, exists := c.GetQuery("status"); exists {
		value, parseErr := strconv.ParseBool(raw)
		if parseErr != nil {
			httpx.Fail(c, parseErr.Error())
			return
		}
		filter.Status = &value
	}
	if raw, exists := c.GetQuery("parentID"); exists {
		value, parseErr := strconv.ParseUint(raw, 10, 64)
		if parseErr != nil {
			httpx.Fail(c, parseErr.Error())
			return
		}
		parentID := uint(value)
		filter.ParentID = &parentID
	}
	if raw, exists := c.GetQuery("level"); exists {
		value, parseErr := strconv.Atoi(raw)
		if parseErr != nil {
			httpx.Fail(c, parseErr.Error())
			return
		}
		filter.Level = &value
	}
	items, total, err := h.service.DictionaryDetails(c.Request.Context(), p, size, filter)
	if err != nil {
		httpx.Fail(c, "获取失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, httpx.PageResult{List: items, Total: total, Page: p, PageSize: size}, "获取成功")
}
func (h *Dictionary) Tree(byType bool) gin.HandlerFunc {
	return func(c *gin.Context) {
		rawID := c.Query("sysDictionaryID")
		id, parseErr := strconv.ParseUint(rawID, 10, 64)
		typ := ""
		if byType {
			typ = c.Query("type")
			if typ == "" {
				httpx.Fail(c, "字典类型不能为空")
				return
			}
		} else if rawID == "" {
			httpx.Fail(c, "字典ID不能为空")
			return
		} else if parseErr != nil {
			httpx.Fail(c, "字典ID格式错误")
			return
		}
		items, err := h.service.DictionaryTree(c.Request.Context(), uint(id), typ)
		if err != nil {
			httpx.Fail(c, "获取失败")
			return
		}
		httpx.Write(c, httpx.CodeSuccess, gin.H{"list": items}, "获取成功")
	}
}
func (h *Dictionary) DetailsByParent(c *gin.Context) {
	var req dto.DictionaryDetailsByParentRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		httpx.Fail(c, err.Error())
		return
	}
	items, err := h.service.DictionaryDetailsByParent(c.Request.Context(), req.DictionaryID, req.ParentID, req.IncludeChildren)
	if err != nil {
		httpx.Fail(c, "获取失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{"list": items}, "获取成功")
}
func (h *Dictionary) Path(c *gin.Context) {
	rawID := c.Query("id")
	if rawID == "" {
		httpx.Fail(c, "字典详情ID不能为空")
		return
	}
	id, parseErr := strconv.ParseUint(rawID, 10, 64)
	if parseErr != nil {
		httpx.Fail(c, "字典详情ID格式错误")
		return
	}
	item, err := h.service.DictionaryDetail(c.Request.Context(), uint(id))
	if err != nil {
		httpx.Fail(c, "获取失败")
		return
	}
	httpx.Write(c, httpx.CodeSuccess, gin.H{"path": item["path"]}, "获取成功")
}