eta_api/controllers/speech_recognition/speech_recognition_menu.go

package speech_recognition

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/speech_recognition"
	"eta/eta_api/services"
	"eta/eta_api/utils"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"
)

type SpeechRecognitionMenuController struct {
	controllers.BaseAuthController
}

// Add
// @Title 新增分类
// @Description 新增分类
// @Param	request	body speech_recognition.SpeechRecognitionMenuAddReq true "type json string"
// @Success 200 string "操作成功"
// @router /menu/add [post]
func (this *SpeechRecognitionMenuController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req speech_recognition.SpeechRecognitionMenuAddReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	req.MenuName = strings.TrimSpace(req.MenuName)
	if req.MenuName == "" {
		br.Msg = "请输入目录名称"
		return
	}

	// 校验同级目录是否有重名
	menuOb := new(speech_recognition.SpeechRecognitionMenu)
	{
		cond := fmt.Sprintf(` AND %s = ? AND %s = ?`, speech_recognition.SpeechRecognitionMenuCols.MenuName, speech_recognition.SpeechRecognitionMenuCols.ParentId)
		pars := make([]interface{}, 0)
		pars = append(pars, req.MenuName, req.ParentId)
		exists, e := menuOb.GetItemByCondition(cond, pars, "")
		if e != nil && e.Error() != utils.ErrNoRow() {
			br.Msg = "操作失败"
			br.ErrMsg = "获取同名目录失败, Err: " + e.Error()
			return
		}
		if exists != nil && exists.SpeechRecognitionMenuId > 0 {
			br.Msg = "分类名称已存在，请重新输入"
			return
		}
	}

	// 获取目录层级和同级最大排序
	level := 1
	rootId := 0
	{
		if req.ParentId > 0 {
			parentMenu, e := menuOb.GetItemById(req.ParentId)
			if e != nil {
				br.Msg = "操作失败"
				br.ErrMsg = "获取父级目录失败, Err: " + e.Error()
				return
			}
			level += parentMenu.Level
			rootId = parentMenu.RootId
		}
	}
	sortMax, e := services.GetSpeechMenuMaxSort(req.ParentId)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取语音识别目录下最大排序失败, Err: " + e.Error()
		return
	}

	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	menuOb.UniqueCode = utils.MD5(fmt.Sprintf("%s_%s", menuOb.TableName(), timestamp))
	menuOb.MenuName = req.MenuName
	menuOb.ParentId = req.ParentId
	menuOb.Level = level
	menuOb.Sort = sortMax + 1
	menuOb.RootId = rootId
	menuOb.CreateTime = time.Now().Local()
	menuOb.ModifyTime = time.Now().Local()
	if e = menuOb.Create(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "新增目录失败, Err: " + e.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Edit
// @Title 编辑分类
// @Description 编辑分类
// @Param	request	body speech_recognition.SpeechRecognitionMenuEditReq true "type json string"
// @Success 200 string "操作成功"
// @router /menu/edit [post]
func (this *SpeechRecognitionMenuController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req speech_recognition.SpeechRecognitionMenuEditReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	if req.MenuId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, MenuId: %d", req.MenuId)
		return
	}
	req.MenuName = strings.TrimSpace(req.MenuName)
	if req.MenuName == "" {
		br.Msg = "请输入目录名称"
		return
	}

	menuOb := new(speech_recognition.SpeechRecognitionMenu)
	menuItem, e := menuOb.GetItemById(req.MenuId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "目录不存在，请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取目录失败, Err: " + e.Error()
		return
	}

	// 校验同级目录是否有重名
	{
		cond := fmt.Sprintf(` AND %s = ? AND %s = ? AND %s <> ?`, speech_recognition.SpeechRecognitionMenuCols.MenuName, speech_recognition.SpeechRecognitionMenuCols.ParentId, speech_recognition.SpeechRecognitionMenuCols.SpeechRecognitionMenuId)
		pars := make([]interface{}, 0)
		pars = append(pars, req.MenuName, menuItem.ParentId, req.MenuId)
		exists, e := menuOb.GetItemByCondition(cond, pars, "")
		if e != nil && e.Error() != utils.ErrNoRow() {
			br.Msg = "操作失败"
			br.ErrMsg = "获取同名目录失败, Err: " + e.Error()
			return
		}
		if exists != nil && exists.SpeechRecognitionMenuId > 0 {
			br.Msg = "分类名称已存在，请重新输入"
			return
		}
	}

	menuItem.MenuName = req.MenuName
	menuItem.ModifyTime = time.Now().Local()
	updateCols := []string{speech_recognition.SpeechRecognitionMenuCols.MenuName, speech_recognition.SpeechRecognitionMenuCols.ModifyTime}
	if e = menuItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新目录失败, Err: " + e.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Remove
// @Title 删除分类
// @Description 删除分类
// @Param	request	body speech_recognition.SpeechRecognitionMenuRemoveReq true "type json string"
// @Success 200 string "操作成功"
// @router /menu/remove [post]
func (this *SpeechRecognitionMenuController) Remove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req speech_recognition.SpeechRecognitionMenuRemoveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	if req.MenuId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, MenuId: %d", req.MenuId)
		return
	}

	menuOb := new(speech_recognition.SpeechRecognitionMenu)
	menuItem, e := menuOb.GetItemById(req.MenuId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Ret = 200
			br.Success = true
			br.Msg = "操作成功"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取目录失败, Err: " + e.Error()
		return
	}

	// 校验目录下是否有内容
	{
		speechOb := new(speech_recognition.SpeechRecognition)
		cond := fmt.Sprintf(` AND %s = ?`, speech_recognition.SpeechRecognitionCols.MenuId)
		pars := make([]interface{}, 0)
		pars = append(pars, req.MenuId)
		count, e := speechOb.GetCountByCondition(cond, pars)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "获取目录下的语音识别数失败, Err: " + e.Error()
			return
		}
		if count > 0 {
			br.Msg = "该分类关联转写文件，删除失败！"
			return
		}

		cond = fmt.Sprintf(` AND %s = ?`, speech_recognition.SpeechRecognitionMenuCols.ParentId)
		pars = make([]interface{}, 0)
		pars = append(pars, req.MenuId)
		count, e = menuOb.GetCountByCondition(cond, pars)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "获取下级目录数失败, Err: " + e.Error()
			return
		}
		if count > 0 {
			br.Msg = "该分类含下级目录，删除失败！"
			return
		}
	}

	if e = menuItem.Del(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "删除目录失败, Err: " + e.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// Tree
// @Title 目录树
// @Description 目录树
// @Param   ParentId  query  int  false  "父级ID"
// @Success 200 {object} speech_recognition.SpeechRecognitionMenuNodeItem
// @router /menu/tree [get]
func (this *SpeechRecognitionMenuController) Tree() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	// 前端采用懒加载, 所以只查询目录及当前目录下的语音识别
	parentId, _ := this.GetInt("ParentId")

	// 获取所有目录
	menus := make([]*speech_recognition.SpeechRecognitionMenu, 0)
	{
		menuOb := new(speech_recognition.SpeechRecognitionMenu)
		list, e := menuOb.GetItemsByCondition(``, make([]interface{}, 0), []string{}, fmt.Sprintf("%s ASC", speech_recognition.SpeechRecognitionMenuCols.Sort))
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取目录列表失败, Err: " + e.Error()
			return
		}
		menus = list
	}

	topMenus := make([]*speech_recognition.SpeechRecognitionMenu, 0)                  // 顶部节点
	menuChildren := make(map[int][]*speech_recognition.SpeechRecognitionMenuNodeItem) // 子目录节点
	menuIdLevel := make(map[int]int)                                                  // 目录对应层级
	for _, v := range menus {
		menuIdLevel[v.SpeechRecognitionMenuId] = v.Level
		if v.ParentId == parentId {
			topMenus = append(topMenus, v)
		}

		if menuChildren[v.ParentId] == nil {
			menuChildren[v.ParentId] = make([]*speech_recognition.SpeechRecognitionMenuNodeItem, 0)
		}
		menuChildren[v.ParentId] = append(menuChildren[v.ParentId], &speech_recognition.SpeechRecognitionMenuNodeItem{
			UniqueCode: v.UniqueCode,
			NodeType:   speech_recognition.SpeechRecognitionMenuNodeTypeDefault,
			MenuId:     v.SpeechRecognitionMenuId,
			MenuName:   v.MenuName,
			ParentId:   v.ParentId,
			Level:      v.Level,
			Sort:       v.Sort,
			CreateTime: utils.TimeTransferString(utils.FormatDateTime, v.CreateTime),
		})
	}

	resp := make([]*speech_recognition.SpeechRecognitionMenuNodeItem, 0)
	if len(topMenus) == 0 {
		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	// 目录下的语音识别
	menuIds := make([]int, 0)
	for _, m := range topMenus {
		menuIds = append(menuIds, m.SpeechRecognitionMenuId)
	}
	speeches := make([]*speech_recognition.SpeechRecognition, 0)
	{
		speechOb := new(speech_recognition.SpeechRecognition)
		cond := fmt.Sprintf(` AND %s IN (%s)`, speech_recognition.SpeechRecognitionCols.MenuId, utils.GetOrmInReplace(len(menuIds)))
		pars := make([]interface{}, 0)
		pars = append(pars, menuIds)
		list, e := speechOb.GetItemsByCondition(cond, pars, []string{}, fmt.Sprintf("%s ASC, %s DESC", speech_recognition.SpeechRecognitionCols.Sort, speech_recognition.SpeechRecognitionCols.CreateTime))
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取语音识别列表失败, Err: " + e.Error()
			return
		}
		speeches = list
	}
	menuSpeeches := make(map[int][]*speech_recognition.SpeechRecognitionMenuNodeItem)
	for _, s := range speeches {
		if menuSpeeches[s.MenuId] == nil {
			menuSpeeches[s.MenuId] = make([]*speech_recognition.SpeechRecognitionMenuNodeItem, 0)
		}
		menuSpeeches[s.MenuId] = append(menuSpeeches[s.MenuId], &speech_recognition.SpeechRecognitionMenuNodeItem{
			UniqueCode:            s.UniqueCode,
			NodeType:              speech_recognition.SpeechRecognitionMenuNodeTypeSpeech,
			SpeechRecognitionId:   s.SpeechRecognitionId,
			SpeechRecognitionName: s.FileName,
			ParentId:              s.MenuId,
			Level:                 menuIdLevel[s.MenuId] + 1,
			Sort:                  s.Sort,
			CreateTime:            utils.TimeTransferString(utils.FormatDateTime, s.CreateTime),
		})
	}

	for _, m := range topMenus {
		child := make([]*speech_recognition.SpeechRecognitionMenuNodeItem, 0)
		if menuSpeeches[m.SpeechRecognitionMenuId] != nil {
			child = append(child, menuSpeeches[m.SpeechRecognitionMenuId]...)
		}
		if menuChildren[m.SpeechRecognitionMenuId] != nil {
			child = append(child, menuChildren[m.SpeechRecognitionMenuId]...)
		}
		sort.Slice(child, func(i, j int) bool {
			return child[i].Sort < child[j].Sort
		})
		t := &speech_recognition.SpeechRecognitionMenuNodeItem{
			UniqueCode: m.UniqueCode,
			NodeType:   speech_recognition.SpeechRecognitionMenuNodeTypeDefault,
			MenuId:     m.SpeechRecognitionMenuId,
			MenuName:   m.MenuName,
			ParentId:   m.ParentId,
			Level:      m.Level,
			Sort:       m.Sort,
			CreateTime: utils.TimeTransferString(utils.FormatDateTime, m.CreateTime),
			Children:   child,
		}
		resp = append(resp, t)
	}

	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// Move
// @Title 移动目录/语音识别
// @Description 移动目录/语音识别
// @Param	request	body speech_recognition.SpeechRecognitionMenuMoveReq true "type json string"
// @Success 200 string "操作成功"
// @router /menu/move [post]
func (this *SpeechRecognitionMenuController) Move() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req speech_recognition.SpeechRecognitionMenuMoveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	if req.MenuId <= 0 && req.SpeechId <= 0 {
		br.Msg = "请选择目录或语音识别"
		return
	}

	e, _ := services.MoveSpeechMenu(req)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "移动目录/语音识别失败, Err: " + e.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}