hz_crm_eta/controller/eta/classify.go

package eta

import (
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"hongze/hz_crm_eta/controller/resp"
	"hongze/hz_crm_eta/global"
	"hongze/hz_crm_eta/models/crm"
	"hongze/hz_crm_eta/models/eta"
	etaService "hongze/hz_crm_eta/services/eta"
	"hongze/hz_crm_eta/utils"
	"time"
)

type ClassifyController struct{}

// ListClassify
// @Title 获取分类列表
// @Description 获取分类列表
// @Param   KeyWord   query   string  true       "检索关键词"
// @Param   CompanyType   query   string  false       "产品类型，枚举值：'ficc','权益';不传默认返回全部"
// @Param   HideDayWeek   query   int  false       "是否隐藏晨周报"
// @Success 200 {object} models.Classify
// @router /classify/list [get]
func (this *ClassifyController) ListClassify(c *gin.Context) {
	var req eta.ClassifyListReq
	err := c.Bind(&req)
	if err != nil {
		errs, ok := err.(validator.ValidationErrors)
		if !ok {
			resp.FailData("参数解析失败", "Err:"+err.Error(), c)
			return
		}
		resp.FailData("参数解析失败", errs.Translate(global.Trans), c)
		return
	}

	keyWord := req.Keyword

	list, err := eta.GetClassifyListByKeyword(keyWord)
	if err != nil {
		resp.FailData("获取失败", err.Error(), c)
		return
	}

	if keyWord != `` {
		idMap := make(map[int]bool)

		currParentClassifyIdList := make([]int, 0)
		for _, v := range list {
			idMap[v.Id] = true
			if v.ParentId > 0 {
				currParentClassifyIdList = append(currParentClassifyIdList, v.ParentId)
			}
		}

		findList := list
		list = make([]*eta.ClassifyListV2, 0)

		tmpList, tmpErr := etaService.GetParentClassifyListByParentIdList(currParentClassifyIdList)
		if tmpErr != nil {
			resp.FailData("获取失败", "获取上级分类信息失败，Err:"+err.Error(), c)
			return
		}
		for _, v := range tmpList {
			if _, ok := idMap[v.Id]; !ok {
				list = append(list, v)
			}
		}

		list = append(list, findList...)
	}

	classifyIdList := make([]int, 0)
	for i := range list {
		classifyIdList = append(classifyIdList, list[i].Id)
	}
	parentIdLen := len(classifyIdList)
	if parentIdLen == 0 {
		data := &eta.ClassifyListResp{
			List: make([]*eta.ClassifyListV2, 0),
		}
		resp.OkData("操作成功", data, c)
		return
	}

	// 获取一级分类-子目录列表
	menuListMap := make(map[int][]*eta.ClassifyMenu, 0)
	var menuCond string
	var menuPars []interface{}
	menuCond += ` classify_id IN (?)`
	menuPars = append(menuPars, classifyIdList)
	menuOb := new(eta.ClassifyMenu)
	parentMenus, e := menuOb.GetClassifyMenuList(menuCond, menuPars)
	if e != nil {
		resp.FailData("获取失败", "获取一级分类子目录列表失败", c)
		return
	}
	for i := range parentMenus {
		if menuListMap[parentMenus[i].ClassifyId] == nil {
			menuListMap[parentMenus[i].ClassifyId] = make([]*eta.ClassifyMenu, 0)
		}
		menuListMap[parentMenus[i].ClassifyId] = append(menuListMap[parentMenus[i].ClassifyId], parentMenus[i])
	}

	// 获取子分类
	children, e := eta.GetClassifyChildByParentIds(classifyIdList, keyWord)
	if e != nil {
		resp.FailData("获取失败", "获取子分类失败", c)
		return
	}
	childrenIds := make([]int, 0)
	for i := range children {
		childrenIds = append(childrenIds, children[i].Id)
	}
	childrenIdsLen := len(childrenIds)

	// 获取二级分类-子目录关联
	relateMap := make(map[int]int, 0)
	if childrenIdsLen > 0 {
		var relateCond string
		var relatePars []interface{}
		relateCond += ` classify_id IN (?)`
		relatePars = append(relatePars, childrenIds)
		menuRelationOb := new(eta.ClassifyMenuRelation)
		relates, e := menuRelationOb.GetClassifyMenuRelationList(relateCond, relatePars)
		if e != nil {
			resp.FailData("获取失败", "获取二级分类子目录关联失败, Err: "+e.Error(), c)
			return
		}
		for i := range relates {
			relateMap[relates[i].ClassifyId] = relates[i].MenuId
		}
	}

	permissionMappingOb := new(crm.ChartPermissionSearchKeyWordMapping)
	permissionList, e := permissionMappingOb.GetPermission()
	if e != nil {
		resp.FailData("查询权限失败", e.Error(), c)
		return
	}
	classifyPermissionMap := make(map[int][]int, 0)
	if len(permissionList) > 0 {
		for _, v := range permissionList {
			classifyPermissionMap[v.ClassifyId] = append(classifyPermissionMap[v.ClassifyId], v.ChartPermissionId)
		}
	}

	// 遍历分类并绑定子目录和权限
	for i, v := range list {
		list[i].ClassifyMenuList = menuListMap[v.Id]

		list[i].ClassifyMenuId = relateMap[v.Id]
		if permissionIds, ok := classifyPermissionMap[v.Id]; ok {
			list[i].ChartPermissionIdList = permissionIds
		}
	}

	// 先将分类列表排序
	etaService.SortClassifyListBySortAndCreateTime(list)
	// 接着转换结构
	list = etaService.GetClassifyListTreeRecursive(list, 0)

	data := new(eta.ClassifyListResp)
	data.List = list
	resp.OkData("操作成功", data, c)
}

//func (this *ClassifyController) ListClassify(c *gin.Context) {
//	var req eta.ClassifyListReq
//	err := c.Bind(&req)
//	if err != nil {
//		errs, ok := err.(validator.ValidationErrors)
//		if !ok {
//			resp.FailData("参数解析失败", "Err:"+err.Error(), c)
//			return
//		}
//		resp.FailData("参数解析失败", errs.Translate(global.Trans), c)
//		return
//	}
//
//	keyWord := req.Keyword
//	companyType := req.CompanyType
//	hideDayWeek := req.HideDayWeek
//
//	list, err := eta.GetClassifyList(keyWord, companyType, hideDayWeek)
//	if err != nil {
//		resp.FailData("获取失败", err.Error(), c)
//		return
//	}
//	finalList := make([]*eta.ClassifyList, 0)
//	parentIds := make([]int, 0)
//	for i := range list {
//		tmp := new(eta.ClassifyList)
//		tmp.ClassifyListItem = *list[i]
//		finalList = append(finalList, tmp)
//		parentIds = append(parentIds, list[i].Id)
//	}
//	parentIdLen := len(parentIds)
//	if parentIdLen == 0 {
//		data := &eta.ClassifyListResp{
//			List: finalList,
//		}
//		resp.OkData("操作成功", data, c)
//		return
//	}
//
//	// 获取一级分类-子目录列表
//	menuListMap := make(map[int][]*eta.ClassifyMenu, 0)
//	var menuCond string
//	var menuPars []interface{}
//	menuCond += ` classify_id IN (?)`
//	menuPars = append(menuPars, parentIds)
//	menuOb := new(eta.ClassifyMenu)
//	parentMenus, e := menuOb.GetClassifyMenuList(menuCond, menuPars)
//	if e != nil {
//		resp.FailData("获取失败", "获取一级分类子目录列表失败", c)
//		return
//	}
//	for i := range parentMenus {
//		if menuListMap[parentMenus[i].ClassifyId] == nil {
//			menuListMap[parentMenus[i].ClassifyId] = make([]*eta.ClassifyMenu, 0)
//		}
//		menuListMap[parentMenus[i].ClassifyId] = append(menuListMap[parentMenus[i].ClassifyId], parentMenus[i])
//	}
//
//	// 获取子分类
//	children, e := eta.GetClassifyChildByParentIds(parentIds, keyWord)
//	if e != nil {
//		resp.FailData("获取失败", "获取子分类失败", c)
//		return
//	}
//	childrenIds := make([]int, 0)
//	for i := range children {
//		childrenIds = append(childrenIds, children[i].Id)
//	}
//	childrenIdsLen := len(childrenIds)
//
//	// 获取二级分类-子目录关联
//	relateMap := make(map[int]int, 0)
//	if childrenIdsLen > 0 {
//		var relateCond string
//		var relatePars []interface{}
//		relateCond += ` classify_id IN (?)`
//		relatePars = append(relatePars, childrenIds)
//		menuRelationOb := new(eta.ClassifyMenuRelation)
//		relates, e := menuRelationOb.GetClassifyMenuRelationList(relateCond, relatePars)
//		if e != nil {
//			resp.FailData("获取失败", "获取二级分类子目录关联失败, Err: "+e.Error(), c)
//			return
//		}
//		for i := range relates {
//			relateMap[relates[i].ClassifyId] = relates[i].MenuId
//		}
//	}
//
//	permissionMappingOb := new(crm.ChartPermissionSearchKeyWordMapping)
//	permissionList, e := permissionMappingOb.GetPermission()
//	if e != nil {
//		resp.FailData("查询权限失败", e.Error(), c)
//		return
//	}
//	classifyPermissionMap := make(map[string][]int, 0)
//	if len(permissionList) > 0 {
//		for _, v := range permissionList {
//			classifyPermissionMap[v.KeyWord] = append(classifyPermissionMap[v.KeyWord], v.ChartPermissionId)
//		}
//	}
//	// 二级分类
//	childrenMap := make(map[int][]*eta.ClassifyItem, 0)
//	for i := range children {
//
//		if childrenMap[children[i].ParentId] == nil {
//			childrenMap[children[i].ParentId] = make([]*eta.ClassifyItem, 0)
//		}
//		tmp := &eta.ClassifyItem{
//			Classify:       *children[i],
//			ClassifyMenuId: relateMap[children[i].Id],
//		}
//		if permissionIds, ok := classifyPermissionMap[children[i].ClassifyName]; ok {
//			tmp.ChartPermissionIdList = permissionIds
//		}
//		childrenMap[children[i].ParentId] = append(childrenMap[children[i].ParentId], tmp)
//	}
//
//	// 一级分类
//	for i := range finalList {
//		finalList[i].ClassifyMenuList = menuListMap[list[i].Id]
//		finalList[i].Child = childrenMap[list[i].Id]
//	}
//
//	data := new(eta.ClassifyListResp)
//	data.List = finalList
//	resp.OkData("操作成功", data, c)
//}

// SetEnabled
// @Title 启用/禁用分类接口
// @Description 启用/禁用分类
// @Param	request	body models.ClassifyMoveReq true "type json string"
// @Success 200 新增成功
// @router /classify/enabled/set [post]
func (this *ClassifyController) SetEnabled(c *gin.Context) {
	var req eta.ClassifySetEnabledReq
	err := c.Bind(&req)
	if err != nil {
		errs, ok := err.(validator.ValidationErrors)
		if !ok {
			resp.FailData("参数解析失败", "Err:"+err.Error(), c)
			return
		}
		resp.FailData("参数解析失败", errs.Translate(global.Trans), c)
		return
	}

	if req.ClassifyId <= 0 {
		resp.Fail("请选择分类", c)
		return
	}
	if req.Enabled != 0 && req.Enabled != 1 {
		resp.Fail("请选择正确的启用禁用状态", c)
		return
	}
	ob := new(eta.Classify)
	item, err := ob.GetClassifyById(req.ClassifyId)
	if err != nil {
		if err == utils.ErrNoRow {
			resp.FailData("分类不存在", "Err:"+err.Error(), c)
			return
		}

		resp.FailData("获取信息失败", "Err:"+err.Error(), c)
		return
	}
	if item == nil {
		resp.Fail("分类不存在", c)
		return
	}
	//设置分类启用、禁用状态
	err = ob.SetEnabled(req.ClassifyId, req.Enabled)
	if err != nil {
		resp.FailData("操作失败", "Err:"+err.Error(), c)
		return
	}

	resp.Ok("操作成功", c)
}

// Edit
// @Title 修改分类接口
// @Description 修改分类
// @Param	request	body models.EditClassifyReq true "type json string"
// @Success 200 Ret=200，修改成功
// @router /classify/edit [post]
func (this *ClassifyController) Edit(c *gin.Context) {
	var req eta.EditClassifyReq
	err := c.Bind(&req)
	if err != nil {
		errs, ok := err.(validator.ValidationErrors)
		if !ok {
			resp.FailData("参数解析失败", "Err:"+err.Error(), c)
			return
		}
		resp.FailData("参数解析失败", errs.Translate(global.Trans), c)
		return
	}
	// 获取系统菜单, 如果没有对应的字段的特殊处理项, 则忽略必填
	sysMenuObject := new(eta.SysMenu)
	menus, e := sysMenuObject.GetSysMenuItemsByCondition(` hidden = 0`, make([]interface{}, 0), []string{}, ``)
	if e != nil {
		resp.FailData("保存失败", "获取菜单列表失败, Err:"+err.Error(), c)
		return
	}
	menuMap := make(map[string]bool)
	for _, m := range menus {
		if m.ButtonCode != "" {
			menuMap[m.ButtonCode] = true
		}
	}

	if req.ClassifyId <= 0 {
		resp.Fail("参数错误", c)
		return
	}

	ob := new(eta.Classify)
	item, err := ob.GetClassifyById(req.ClassifyId)
	if err != nil {
		if err == utils.ErrNoRow {
			resp.Fail("分类不存在", c)
			return
		}

		resp.FailData("获取信息失败", "Err:"+err.Error(), c)
		return
	}
	if item == nil {
		resp.Fail("分类不存在", c)
		return
	}

	if menuMap[eta.MenuSpecialHandleClassifyShowType] && item.ParentId != 0 && req.ShowType == 0 {
		resp.Fail("展示类型不可为空", c)
		return
	}
	if menuMap[eta.MenuSpecialHandleClassifyReportImgs] && (req.ShowType == 1 || req.ShowType == 3) && req.YbRightBanner == "" && item.ParentId == 0 { //当一级报告分类为列表、品种时，增加“报告合集配图”的配置项
		resp.Fail("报告合集配图不可为空", c)
		return
	}
	//originRelateTel := item.RelateTel
	item.ModifyTime = time.Now().Local()
	/*item.Abstract = req.Abstract
	item.Descript = req.Descript
	item.ReportAuthor = req.ReportAuthor
	item.AuthorDescript = req.AuthorDescript
	item.ColumnImgUrl = req.ColumnImgUrl
	item.HeadImgUrl = req.HeadImgUrl
	item.AvatarImgUrl = req.AvatarImgUrl
	item.ReportImgUrl = req.ReportImgUrl
	item.HomeImgUrl = req.HomeImgUrl*/
	item.ClassifyLabel = req.ClassifyLabel
	item.ShowType = req.ShowType
	/*	item.HasTeleconference = req.HasTeleconference
		item.VipTitle = req.VipTitle*/
	//	item.Sort = req.Sort
	item.IsShow = req.IsShow
	item.YbFiccSort = req.YbFiccSort
	item.YbFiccIcon = req.YbFiccIcon
	item.YbFiccPcIcon = req.YbFiccPcIcon
	item.YbIconUrl = req.YbIconUrl
	item.YbBgUrl = req.YbBgUrl
	item.YbListImg = req.YbListImg
	item.YbShareBgImg = req.YbShareBgImg
	item.YbRightBanner = req.YbRightBanner
	item.RelateTel = req.RelateTel
	item.RelateVideo = req.RelateVideo
	item.ModifyTime = time.Now().Local()

	// 报告详情的展示类型：1-拼接；2:目录
	if req.ReportDetailShowType > 0 {
		item.ReportDetailShowType = req.ReportDetailShowType
	}

	cols := make([]string, 0)
	/*cols = append(cols, "Abstract", "Descript", "ReportAuthor", "AuthorDescript", "ColumnImgUrl",
	"HeadImgUrl", "AvatarImgUrl", "ReportImgUrl", "HomeImgUrl", "ClassifyLabel", "ShowType", "HasTeleconference", "VipTitle",
	"IsShow", "YbFiccSort", "YbFiccIcon", "YbFiccPcIcon", "YbIconUrl", "YbBgUrl", "YbListImg", "YbShareBgImg", "YbRightBanner",
	"RelateTel", "RelateVideo", "ModifyTime")*/
	cols = append(cols, "ClassifyLabel", "ShowType",
		"IsShow", "YbFiccSort", "YbFiccIcon", "YbFiccPcIcon", "YbIconUrl", "YbBgUrl", "YbListImg", "YbShareBgImg", "YbRightBanner",
		"RelateTel", "RelateVideo", "ModifyTime", "ReportDetailShowType")
	if e = item.UpdateClassify(cols); e != nil {
		resp.FailData("修改失败", "Err:"+e.Error(), c)
		return
	}
	// 一级分类关联设置会强制修改二级分类的所有关联设置
	if item.ParentId == 0 {
		if e = item.UpdateChildClassifyRelateSetting(item.Id, req.RelateTel, req.RelateVideo); e != nil {
			resp.FailData("更新二级分类关联设置失败", "更新二级分类关联设置失败 Err:"+err.Error(), c)
			return
		}
	}

	// 为二级分类时, 更新父级分类是否含电话会字段
	/*if item.ParentId > 0 {
		go func() {
			_ = eta2.UpdateParentClassifyHasTel(req.ClassifyId, item.ParentId, req.HasTeleconference)
		}()
	}*/

	// 获取编辑前子目录列表
	classifyId := item.Id
	var menuCond string
	var menuPars []interface{}
	menuCond += ` classify_id = ?`
	menuPars = append(menuPars, classifyId)
	menuOb := new(eta.ClassifyMenu)
	menuList, e := menuOb.GetClassifyMenuList(menuCond, menuPars)
	if e != nil {
		resp.FailData("保存失败", "获取分类子目录列表失败, Err:"+err.Error(), c)
		return
	}
	oriMenuIds := make([]int, 0)
	for i := range menuList {
		oriMenuIds = append(oriMenuIds, menuList[i].MenuId)
	}

	// 一级分类-新增/编辑/删除子目录
	if item.ParentId == 0 && len(req.MenuList) > 0 {
		nowTime := time.Now().Local()
		insertMenus := make([]*eta.ClassifyMenu, 0)
		editMenus := make([]*eta.ClassifyMenu, 0)
		deleteMenuIds := make([]int, 0)
		menuIds := make([]int, 0)
		for i := range req.MenuList {
			m := req.MenuList[i]

			v := new(eta.ClassifyMenu)
			v.MenuName = req.MenuList[i].MenuName
			v.ClassifyId = classifyId
			v.Sort = i + 1
			v.MenuId = m.MenuId
			v.ModifyTime = nowTime
			if v.MenuId > 0 {
				// 编辑
				editMenus = append(editMenus, v)
				menuIds = append(menuIds, m.MenuId)
			} else {
				// 新增
				v.CreateTime = nowTime
				insertMenus = append(insertMenus, v)
			}
		}
		// 编辑前存在子目录则取"编辑前子目录IDs与编辑时子目录IDs的差集"作为删除IDs
		if len(oriMenuIds) > 0 {
			deleteMenuIds = utils.MinusInt(oriMenuIds, menuIds)
		}
		if e = eta.InsertAndUpdateClassifyMenu(insertMenus, editMenus, deleteMenuIds); e != nil {
			resp.FailData("保存失败", "新增/编辑/删除分类子目录失败, Err:"+e.Error(), c)
			return
		}
	}

	// 二级分类-新增子目录关联
	if item.ParentId > 0 {
		if e := eta.DeleteAndInsertClassifyMenuRelation(classifyId, req.ClassifyMenuId); e != nil {
			resp.FailData("新增子目录关联失败", "新增子目录关联失败 Err:"+e.Error(), c)
			return
		}
	}

	resp.Ok("操作成功", c)
}