package data import ( "errors" "eta_gn/eta_api/models" "eta_gn/eta_api/models/data_manage" "eta_gn/eta_api/models/data_manage/cross_variety" "eta_gn/eta_api/models/data_manage/excel" "eta_gn/eta_api/models/system" "eta_gn/eta_api/services/data/data_manage_permission" "eta_gn/eta_api/utils" "fmt" "strconv" "time" ) func edbClassifyHaveChild(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) (childs []*data_manage.EdbClassifyItems, yes bool) { for _, v := range allNode { if v.ParentId == node.ClassifyId { childs = append(childs, v) } } if len(childs) > 0 { yes = true } return } // GetClassifyTreeRecursive 递归获取分类树形结构 func GetClassifyTreeRecursive(list []*data_manage.EdbClassifyItems, parentId int) []*data_manage.EdbClassifyItems { res := make([]*data_manage.EdbClassifyItems, 0) for _, v := range list { if v.ParentId == parentId { v.Children = GetClassifyTreeRecursive(list, v.ClassifyId) res = append(res, v) } } return res } // GetClassifyTreeRecursiveAndInsert // @Description: 递归获取分类树形结构，同时根据分类id插入对应的指标数据 // @author: Roc // @datetime 2024-12-12 14:39:25 // @param list []*data_manage.EdbClassifyItems // @param parentId int // @param edbClassifyItemListMap map[int][]*data_manage.EdbClassifyItems // @return []*data_manage.EdbClassifyItems func GetClassifyTreeRecursiveAndInsert(list []*data_manage.EdbClassifyItems, parentId int, edbClassifyItemListMap map[int][]*data_manage.EdbClassifyItems) []*data_manage.EdbClassifyItems { // 先获取树形结构 list = GetClassifyTreeRecursive(list, parentId) // 将指标数据插入到分类树中 InsertEdbClassifyItemsToClassifyTree(list, edbClassifyItemListMap) return list } // InsertEdbClassifyItemsToClassifyTree // @Description: 递归将指标数据插入到分类树中 // @author: Roc // @datetime 2024-12-12 14:39:56 // @param list []*data_manage.EdbClassifyItems // @param edbClassifyItemListMap map[int][]*data_manage.EdbClassifyItems // @return []*data_manage.EdbClassifyItems func InsertEdbClassifyItemsToClassifyTree(list []*data_manage.EdbClassifyItems, edbClassifyItemListMap map[int][]*data_manage.EdbClassifyItems) []*data_manage.EdbClassifyItems { for k, v := range list { children := v.Children if children != nil { children = InsertEdbClassifyItemsToClassifyTree(children, edbClassifyItemListMap) } else { children = make([]*data_manage.EdbClassifyItems, 0) } if edbClassifyItemList, ok := edbClassifyItemListMap[v.ClassifyId]; ok { children = append(children, edbClassifyItemList...) } list[k].Children = children } return list } func GetFullClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) { //判断是否是挂在顶级目录下 targetClassify, err := data_manage.GetEdbClassifyById(targetClassifyId) if err != nil { if utils.IsErrNoRow(err) { errMsg = "当前分类不存在" err = errors.New(errMsg) return } errMsg = "获取失败" err = errors.New("获取分类信息失败，Err:" + err.Error()) return } if targetClassify.ParentId == 0 { targetItem := new(data_manage.EdbClassifyIdItems) targetItem.ClassifyId = targetClassify.ClassifyId targetItem.ParentId = targetClassify.ParentId targetItem.RootId = targetClassify.RootId targetItem.UniqueCode = targetClassify.UniqueCode targetItem.Level = targetClassify.Level targetItem.ClassifyName = targetClassify.ClassifyName targetItem.ClassifyNameEn = targetClassify.ClassifyNameEn targetItem.IsJoinPermission = targetClassify.IsJoinPermission targetList = append(targetList, targetItem) return } tmpList, err := data_manage.GetEdbClassifyByRootIdLevel(targetClassify.RootId, targetClassify.ClassifyType, "") if err != nil && !utils.IsErrNoRow(err) { errMsg = "获取失败" err = errors.New("获取数据失败，Err:" + err.Error()) return } idMap := make(map[int]struct{}) if len(tmpList) > 0 { for _, v := range tmpList { if v.ClassifyId == targetClassify.ClassifyId { idMap[v.ClassifyId] = struct{}{} idMap[v.ParentId] = struct{}{} } } for _, v := range tmpList { if _, ok := idMap[v.ClassifyId]; ok { idMap[v.ParentId] = struct{}{} } } for _, v := range tmpList { if _, ok := idMap[v.ClassifyId]; ok { targetItem := new(data_manage.EdbClassifyIdItems) targetItem.ClassifyId = v.ClassifyId targetItem.ParentId = v.ParentId targetItem.RootId = v.RootId targetItem.UniqueCode = v.UniqueCode targetItem.Level = v.Level targetItem.ClassifyName = v.ClassifyName targetItem.ClassifyNameEn = v.ClassifyNameEn targetItem.IsJoinPermission = v.IsJoinPermission targetList = append(targetList, targetItem) } } } return } // GetFullClassifyByRootId 查询指标列表里的分类信息 func GetFullClassifyByRootId(targetClassify *data_manage.EdbClassify, tmpList []*data_manage.EdbClassifyItems) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) { if targetClassify.ParentId == 0 { targetItem := new(data_manage.EdbClassifyIdItems) targetItem.ClassifyId = targetClassify.ClassifyId targetItem.ParentId = targetClassify.ParentId targetItem.RootId = targetClassify.RootId targetItem.UniqueCode = targetClassify.UniqueCode targetItem.Level = targetClassify.Level targetItem.ClassifyName = targetClassify.ClassifyName targetItem.ClassifyName = targetClassify.ClassifyName targetItem.IsJoinPermission = targetClassify.IsJoinPermission targetList = append(targetList, targetItem) return } idMap := make(map[int]struct{}) if len(tmpList) > 0 { for _, v := range tmpList { if v.ClassifyId == targetClassify.ClassifyId { idMap[v.ClassifyId] = struct{}{} idMap[v.ParentId] = struct{}{} } } for _, v := range tmpList { if _, ok := idMap[v.ClassifyId]; ok { idMap[v.ParentId] = struct{}{} } } for _, v := range tmpList { if _, ok := idMap[v.ClassifyId]; ok { targetItem := new(data_manage.EdbClassifyIdItems) targetItem.ClassifyId = v.ClassifyId targetItem.ParentId = v.ParentId targetItem.RootId = v.RootId targetItem.UniqueCode = v.UniqueCode targetItem.Level = v.Level targetItem.ClassifyName = v.ClassifyName targetItem.IsJoinPermission = v.IsJoinPermission targetList = append(targetList, targetItem) } } } return } func GetChildClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) { //判断是否是挂在顶级目录下 targetClassify, err := data_manage.GetEdbClassifyById(targetClassifyId) if err != nil { if utils.IsErrNoRow(err) { errMsg = "当前分类不存在" err = errors.New(errMsg) return } errMsg = "获取失败" err = errors.New("获取分类信息失败，Err:" + err.Error()) return } orderStr := ` order by level asc, sort asc, classify_id asc` tmpList, err := data_manage.GetEdbClassifyByRootIdLevel(targetClassify.RootId, targetClassify.ClassifyType, orderStr) if err != nil && !utils.IsErrNoRow(err) { errMsg = "获取失败" err = errors.New("获取数据失败，Err:" + err.Error()) return } idMap := make(map[int]struct{}) if len(tmpList) > 0 { for _, v := range tmpList { if v.ClassifyId == targetClassify.ClassifyId { idMap[v.ClassifyId] = struct{}{} } } for _, v := range tmpList { if _, ok := idMap[v.ParentId]; ok { idMap[v.ClassifyId] = struct{}{} } } for _, v := range tmpList { if _, ok := idMap[v.ClassifyId]; ok { targetItem := new(data_manage.EdbClassifyIdItems) targetItem.ClassifyId = v.ClassifyId targetItem.ParentId = v.ParentId targetItem.RootId = v.RootId targetItem.UniqueCode = v.UniqueCode targetItem.Level = v.Level targetItem.ClassifyName = v.ClassifyName targetItem.IsJoinPermission = v.IsJoinPermission targetList = append(targetList, targetItem) } } } return } func EdbClassifyItemsMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) { childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回 if len(childs) > 0 { node.Children = append(node.Children, childs[0:]...) //添加子节点 for _, v := range childs { //查询子节点的子节点，并添加到子节点 _, has := edbClassifyHaveChild(allNode, v) if has { EdbClassifyItemsMakeTree(allNode, v) //递归添加节点 } else { childrenArr := make([]*data_manage.EdbClassifyItems, 0) v.Children = childrenArr } } } else { childrenArr := make([]*data_manage.EdbClassifyItems, 0) node.Children = childrenArr } } // GetEdbClassifyListByAdminId 根据账户类型获取分类id集合 func GetEdbClassifyListByAdminId(adminId int64) (classifyIdList []string, err error) { list, err := models.GetEdbdataClassify(adminId) if err != nil { return } for _, parent := range list { if parent.Child != nil { for _, classify := range parent.Child { classifyIdList = append(classifyIdList, fmt.Sprint(classify.ClassifyId)) } } } return } // GetEdbClassifyNameListByAdminId 根据账户类型获取分类名称集合 func GetEdbClassifyNameListByAdminId(adminId int64) (classifyNameList []string, edbDataClassifyMap map[string]*models.EdbdataClassify, err error) { list, err := models.GetEdbdataClassify(adminId) edbDataClassifyMap = make(map[string]*models.EdbdataClassify) if err != nil { return } for _, parent := range list { if parent.Child != nil { for _, classify := range parent.Child { classifyNameList = append(classifyNameList, classify.ClassifyName) edbDataClassifyMap[classify.ClassifyName] = classify } } } return } // AddEdbClassify 添加指标分类 func AddEdbClassify(classifyName string, parentId, level int, classifyType uint8, sysUserId int, sysUserName, lang string) (classifyInfo *data_manage.EdbClassify, err error, errMsg string) { // 校验分类名称相同的数量 { var count int switch lang { case utils.EnLangVersion: count, err = data_manage.GetEdbClassifyEnCount(classifyName, parentId, sysUserId, classifyType) default: count, err = data_manage.GetEdbClassifyCount(classifyName, 0, parentId, sysUserId, classifyType) } if err != nil { errMsg = `判断名称是否已存在失败` return } if count > 0 { errMsg = `分类名称已存在，请重新输入` err = errors.New(errMsg) return } } // 层级校验 if level > utils.EdbClassifyMaxLevel { errMsg = fmt.Sprintf("最高只支持添加%d级分类", level) return } //获取该层级下最大的排序数 maxSort, err := GetEdbClassifyMaxSort(parentId, classifyType) if err != nil { errMsg = "获取失败" err = errors.New("查询排序信息失败，Err:" + err.Error()) return } //查询顶级rootId rootId := 0 var classifyNamePath, classifyIdPath string if parentId > 0 { parentClassify, tErr := data_manage.GetEdbClassifyById(parentId) if tErr != nil { if utils.IsErrNoRow(tErr) { errMsg = "父级分类不存在" err = errors.New(errMsg) return } errMsg = "获取失败" err = errors.New("获取分类信息失败，Err:" + tErr.Error()) return } rootId = parentClassify.RootId classifyNamePath = fmt.Sprint(parentClassify.ClassifyNamePath, "|", classifyName) classifyIdPath = fmt.Sprint(parentClassify.ClassifyIdPath, ",") } else { classifyNamePath = classifyName } timestamp := strconv.FormatInt(time.Now().UnixNano(), 10) classifyInfo = &data_manage.EdbClassify{ //ClassifyId: 0, ClassifyType: classifyType, ClassifyName: classifyName, ClassifyNameEn: classifyName, ParentId: parentId, RootId: rootId, HasData: 0, CreateTime: time.Now(), ModifyTime: time.Now(), SysUserId: sysUserId, SysUserRealName: sysUserName, Level: level + 1, UniqueCode: utils.MD5(utils.DATA_PREFIX + "_" + timestamp), Sort: maxSort + 1, ClassifyNamePath: classifyNamePath, } err = data_manage.AddEdbClassify(classifyInfo) if err != nil { errMsg = "保存分类失败" return } // 更改分类id完整路径path updateCols := []string{"ClassifyIdPath"} classifyInfo.ClassifyIdPath = fmt.Sprint(classifyIdPath, classifyInfo.ClassifyId) if parentId == 0 { //一级目录的rootId等于自己本身 classifyInfo.RootId = classifyInfo.ClassifyId updateCols = append(updateCols, "RootId") } err = classifyInfo.Update(updateCols) if err != nil { errMsg = "更新分类失败" return } // 继承分类权限 { source := utils.EdbPermissionSourceBase if classifyType == 1 { source = utils.EdbPermissionSourcePredict } if classifyType == utils.EdbClassifyTypeCalculate { source = utils.EdbPermissionSourceCalculate } go data_manage_permission.InheritParentClassify(source, int(classifyType), classifyInfo.ClassifyId, classifyInfo.ParentId, classifyInfo.ClassifyName) } return } // EditEdbClassify 编辑指标分类 func EditEdbClassify(classifyId int, classifyName, lang string, sysUser *system.Admin) (err error, errMsg string) { item, err := data_manage.GetEdbClassifyById(classifyId) if err != nil { errMsg = `保存失败` return } // 权限校验 { // 已授权分类id permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId) if tmpErr != nil { errMsg = "保存失败" err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error()) return } // 数据权限 haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(item.IsJoinPermission, item.ClassifyId, permissionClassifyIdList) if item.ClassifyType == 0 { // 普通指标 button := GetEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth) if !button.OpButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } else if item.ClassifyType == 1 { // 预测指标 button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth) if !button.OpButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } } // 需要变更的字段 updateCols := make([]string, 0) // 旧完整路径 ， 新的完整路径 var oldClassifyNamePath, newClassifyNamePath string switch lang { case utils.EnLangVersion: // 名字相同，那么就直接返回 if item.ClassifyNameEn == classifyName { return } // 判断名称是否已存在 count, tmpErr := data_manage.GetEdbClassifyEnCount(classifyName, item.ParentId, sysUser.AdminId, item.ClassifyType) if tmpErr != nil { err = tmpErr errMsg = "判断名称是否已存在失败" return } if count > 0 { errMsg = "分类名称已存在，请重新输入" err = errors.New(errMsg) return } item.ClassifyNameEn = classifyName item.LastModifyUserId = sysUser.AdminId item.LastModifyUserRealName = sysUser.RealName updateCols = append(updateCols, "ClassifyNameEn", "LastModifyUserId", "LastModifyUserRealName") default: // 名字相同，那么就直接返回 if item.ClassifyName == classifyName { return } //// 判断名称是否已存在 count, tmpErr := data_manage.GetEdbClassifyCount(classifyName, item.ClassifyId, item.ParentId, sysUser.AdminId, item.ClassifyType) if tmpErr != nil { err = tmpErr errMsg = "判断名称是否已存在失败" return } if count > 0 { errMsg = "分类名称已存在，请重新输入" err = errors.New(errMsg) return } // 旧完整路径 oldClassifyNamePath = item.ClassifyNamePath if item.ParentId > 0 { parentItem, tmpErr := data_manage.GetEdbClassifyById(item.ParentId) if tmpErr != nil { err = tmpErr return } newClassifyNamePath = fmt.Sprint(parentItem.ClassifyNamePath, "|", classifyName) } else { newClassifyNamePath = classifyName } // 更新自己的信息 item.ClassifyName = classifyName item.ClassifyNamePath = newClassifyNamePath item.LastModifyUserId = sysUser.AdminId item.LastModifyUserRealName = sysUser.RealName updateCols = append(updateCols, "ClassifyName", "ClassifyNamePath", "LastModifyUserId", "LastModifyUserRealName") } // 修改数据 if len(updateCols) > 0 { err = item.UpdateEdbClassifyNameAndNamePath(updateCols, oldClassifyNamePath, newClassifyNamePath) if err != nil { errMsg = "保存失败" } } return } // DeleteCheck 删除检测 func DeleteCheck(classifyId, edbInfoId int, sysUser *system.Admin) (deleteStatus int, tipsMsg string, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) { //删除分类 if classifyId > 0 && edbInfoId == 0 { // 查找分类 item, tmpErr := data_manage.GetEdbClassifyById(classifyId) if tmpErr != nil { errMsg = `查找分类失败` err = tmpErr return } // 已授权分类id permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId) if tmpErr != nil { errMsg = "删除检测失败" err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error()) return } // 权限校验 { // 数据权限 haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(item.IsJoinPermission, item.ClassifyId, permissionClassifyIdList) if item.ClassifyType == 0 { // 普通指标 button := GetEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth) if !button.DeleteButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } else if item.ClassifyType == 1 { // 预测指标 button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth) if !button.DeleteButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } } //判断分类下，是否含有指标 count, tmpErr := data_manage.GetEdbInfoCountByClassifyId(classifyId) if tmpErr != nil { errMsg = "删除失败" err = errors.New("分类下是否含有指标失败，Err:" + tmpErr.Error()) return } if count > 0 { deleteStatus = 1 tipsMsg = "若目录关联指标不可删除" } } if deleteStatus != 1 && edbInfoId == 0 { classifyCount, tmpErr := data_manage.GetClassifyCountByClassifyId(classifyId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("分类下是否含有指标失败，Err:" + tmpErr.Error()) return } if classifyCount > 0 { deleteStatus = 2 tipsMsg = "确认删除当前目录及包含的子目录吗" } } //删除指标 if edbInfoId > 0 { edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId) if tmpErr != nil { if utils.IsErrNoRow(tmpErr) { errMsg = "指标已删除，请刷新页面" err = errors.New("指标不存在，Err:" + tmpErr.Error()) return } else { errMsg = "删除失败" err = errors.New("删除失败，获取指标信息失败，Err:" + tmpErr.Error()) return } } if edbInfo == nil { errMsg = "指标已删除，请刷新页面" return } //判断指标是否用于作图，如果用于作图，则不可删除 chartCount, tmpErr := data_manage.GetChartEdbMappingCount(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否被用于作图失败，Err:" + tmpErr.Error()) return } if chartCount > 0 { deleteStatus = 3 tipsMsg = "当前指标已用作画图，不可删除" return } //判断指标是否用于计算 { calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否被用于计算失败，GetEdbInfoCalculateCount Err:" + tmpErr.Error()) return } if calculateCount > 0 { deleteStatus = 4 tipsMsg = "当前指标已用作指标运算，不可删除" return } } //如果是普通指标，那么还需要判断是否被预测指标作为源指标 if edbInfo.EdbInfoType == 0 { predictEdbInfoCount, tmpErr := data_manage.GetPredictEdbConfCount(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否被用于预测指标失败，Err:" + tmpErr.Error()) return } if predictEdbInfoCount > 0 { deleteStatus = 5 tipsMsg = "当前指标已用作预测指标，不可删除" return } } // 判断指标是否用作表格引用 { tableItems, tmpErr := excel.GetNoCustomAnalysisExcelEdbMapping(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作表格引用，GetNoCustomAnalysisExcelEdbMappingCount Err:" + tmpErr.Error()) return } //英文翻译： //1、当前指标已用作画图，不可删除：The current metric is in use for charting and cannot be deleted //2、当前指标已被表格引用，不可删除：The current metric is referenced by a table and cannot be deleted //3、删除失败：Deletion failed //4、知道了：Understood if len(tableItems) > 0 { deleteStatus = 6 tipsMsg = "当前指标已被表格引用，不可删除" var excelIds []int for _, tableItem := range tableItems { if tableItem.ParentId > 0 { excelIds = append(excelIds, tableItem.ParentId) } else { excelIds = append(excelIds, tableItem.ExcelInfoId) } } tableList, tmpErr = excel.GetExcelBaseInfoByExcelInfoIdList(excelIds) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作表格引用，GetExcelBaseInfoByExcelInfoIdList Err:" + tmpErr.Error()) return } return } } // 判断指标是否用作跨品种图表使用 { // todo 如果绑定的标签未画图，则允许删除绑定 // 查询跨品种的图表 tagXList, tmpErr := cross_variety.GetChartInfoCrossVarietyByXEdbInfoId(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作跨品种图表使用，GetChartInfoCrossVarietyByXEdbInfoId Err:" + tmpErr.Error()) return } if len(tagXList) > 0 { deleteStatus = 7 tipsMsg = "当前指标已添加到跨品种分析，不可删除" return } tagYList, tmpErr := cross_variety.GetChartInfoCrossVarietyByYEdbInfoId(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作跨品种图表使用，GetChartInfoCrossVarietyByYEdbInfoId Err:" + tmpErr.Error()) return } if len(tagYList) > 0 { deleteStatus = 7 tipsMsg = "当前指标已添加到跨品种分析，不可删除" return } /*calculateCount, tmpErr := cross_variety.GetCountByEdbInfoId(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作跨品种图表使用，GetCountByEdbInfoId Err:" + tmpErr.Error()) return } if calculateCount > 0 { deleteStatus = 3 tipsMsg = "当前指标已添加到跨品种分析，不可删除" return }*/ } // 判断指标是否用于因子指标系列 { ob := new(data_manage.FactorEdbSeriesMapping) cond := fmt.Sprintf(" AND %s = ?", ob.Cols().EdbInfoId) pars := make([]interface{}, 0) pars = append(pars, edbInfoId) count, e := ob.GetCountByCondition(cond, pars) if e != nil { errMsg = "删除失败" err = fmt.Errorf("获取指标是否用于系列失败, err: %v", e) return } if count > 0 { deleteStatus = 3 tipsMsg = "当前指标已用于因子指标系列, 不可删除" return } } } return } // Delete 删除分类/指标 func Delete(classifyId, edbInfoId int, sysUser *system.Admin, requestBody, requestUrl string) (nextItem *data_manage.EdbInfo, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) { //删除分类 if classifyId > 0 && edbInfoId == 0 { // 查找分类 item, tmpErr := data_manage.GetEdbClassifyById(classifyId) if tmpErr != nil { errMsg = `查找分类失败` err = tmpErr return } // 已授权分类id permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId) if tmpErr != nil { errMsg = "删除失败" err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error()) return } // 权限校验 { // 数据权限 haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(item.IsJoinPermission, item.ClassifyId, permissionClassifyIdList) if item.ClassifyType == 0 { // 普通指标 button := GetEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth) if !button.DeleteButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } else if item.ClassifyType == 1 { // 预测指标 button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth) if !button.DeleteButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } } //判断是否含有指标 count, tmpErr := data_manage.GetEdbInfoCountByClassifyId(classifyId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("分类下是否含有指标失败，Err:" + tmpErr.Error()) return } if count > 0 { errMsg = "该目录下存在关联指标，不可删除" return } tmpErr = data_manage.DeleteEdbClassify(classifyId) if tmpErr != nil { errMsg = "删除失败" err = errors.New("删除失败,Err:" + tmpErr.Error()) return } } //删除指标 if edbInfoId > 0 { edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId) if tmpErr != nil { if utils.IsErrNoRow(tmpErr) { errMsg = "指标已删除，请刷新页面" err = errors.New("指标不存在，Err:" + tmpErr.Error()) return } else { errMsg = "删除失败" err = errors.New("删除失败，获取指标信息失败，Err:" + tmpErr.Error()) return } } if edbInfo == nil { errMsg = "指标已删除，请刷新页面" return } //判断指标是否用于作图，如果用于作图，则不可删除 chartCount, tmpErr := data_manage.GetChartEdbMappingCount(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否被用于作图失败，Err:" + tmpErr.Error()) return } if chartCount > 0 { errMsg = "当前指标已用作画图，不可删除" return } //如果是普通指标，那么还需要判断是否被预测指标作为源指标 if edbInfo.EdbInfoType == 0 { predictEdbInfoCount, tmpErr := data_manage.GetPredictEdbConfCount(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否被用于预测指标失败，Err:" + tmpErr.Error()) return } if predictEdbInfoCount > 0 { errMsg = "当前指标已用作预测指标，不可删除" return } } //判断指标是否用作其他指标的计算 { calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否被用于计算失败，GetEdbInfoCalculateCount Err:" + tmpErr.Error()) return } if calculateCount > 0 { errMsg = "当前指标已用作，指标运算，不可删除" return } } // 判断指标是否用作表格引用 { tableItems, tmpErr := excel.GetNoCustomAnalysisExcelEdbMapping(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作表格引用，GetNoCustomAnalysisExcelEdbMappingCount Err:" + tmpErr.Error()) return } //英文翻译： //1、当前指标已用作画图，不可删除：The current metric is in use for charting and cannot be deleted //2、当前指标已被表格引用，不可删除：The current metric is referenced by a table and cannot be deleted //3、删除失败：Deletion failed //4、知道了：Understood if len(tableItems) > 0 { errMsg = "当前指标已被表格引用，不可删除" return } } // 判断指标是否用作跨品种图表使用 { // todo 如果绑定的标签未画图，则允许删除绑定 // 查询跨品种的图表 tagXList, tmpErr := cross_variety.GetChartInfoCrossVarietyByXEdbInfoId(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作跨品种图表使用，GetChartInfoCrossVarietyByXEdbInfoId Err:" + tmpErr.Error()) return } if len(tagXList) > 0 { errMsg = "当前指标已添加到跨品种分析，不可删除" return } tagYList, tmpErr := cross_variety.GetChartInfoCrossVarietyByYEdbInfoId(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作跨品种图表使用，GetChartInfoCrossVarietyByYEdbInfoId Err:" + tmpErr.Error()) return } if len(tagYList) > 0 { errMsg = "当前指标已添加到跨品种分析，不可删除" return } /*calculateCount, tmpErr := cross_variety.GetCountByEdbInfoId(edbInfoId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "删除失败" err = errors.New("判断指标是否用作跨品种图表使用，GetCountByEdbInfoId Err:" + tmpErr.Error()) return } if calculateCount > 0 { errMsg = "当前指标已添加到跨品种分析，不可删除" return }*/ } //真实删除 tmpErr = data_manage.DeleteEdbInfoAndData(edbInfo.EdbInfoId, edbInfo.Source, edbInfo.SubSource) if tmpErr != nil { errMsg = "删除失败" err = errors.New("删除失败，Err:" + tmpErr.Error()) return } // 如果是同花顺高频数据或类似数据, 还需要删除base_from_edb_mapping对应关系 baseMappingOb := new(data_manage.BaseFromEdbMapping) { cond := fmt.Sprintf(" %s = ? AND %s = ? AND %s = ?", baseMappingOb.Cols().EdbCode, baseMappingOb.Cols().Source, baseMappingOb.Cols().SubSource) pars := make([]interface{}, 0) pars = append(pars, edbInfo.EdbCode, edbInfo.Source, edbInfo.SubSource) if e := baseMappingOb.RemoveByCondition(cond, pars); e != nil { errMsg = "删除失败" err = fmt.Errorf("删除源指标映射失败, %v", e) return } } // 删除指标后的操作 go handleByDelEdbInfo(edbInfo) // 返回下一个表格的信息 { var condition string var pars []interface{} condition += " AND edb_info_type=? AND classify_id=? " pars = append(pars, edbInfo.EdbInfoType, edbInfo.ClassifyId) condition += " AND (sort>? OR (sort=? AND edb_info_id 0 { parentEdbClassifyInfo, err = data_manage.GetEdbClassifyById(parentClassifyId) if err != nil { errMsg = "移动失败" err = errors.New("获取上级分类信息失败,Err:" + err.Error()) return } } //如果有传入 上一个兄弟节点分类id var ( edbClassifyInfo *data_manage.EdbClassify prevClassify *data_manage.EdbClassify nextClassify *data_manage.EdbClassify edbInfo *data_manage.EdbInfo prevEdbInfo *data_manage.EdbInfo nextEdbInfo *data_manage.EdbInfo prevSort int nextSort int ) // 移动对象为分类， 判断权限 if edbInfoId == 0 { edbClassifyInfo, err = data_manage.GetEdbClassifyById(classifyId) if err != nil { if utils.IsErrNoRow(err) { errMsg = "当前分类不存在" err = errors.New("获取分类信息失败,Err:" + err.Error()) return } errMsg = "移动失败" err = errors.New("获取分类信息失败,Err:" + err.Error()) return } if edbClassifyInfo.SysUserId != sysUser.AdminId { errMsg = "不是本人目录，您没有操作权限" err = errors.New(errMsg) return } if parentClassifyId > 0 && parentEdbClassifyInfo.Level == 6 { errMsg = "最高只支持添加6级分类" err = errors.New(errMsg) return } // 如果是移动目录, 那么校验一下父级目录下是否有重名目录 exists, e := data_manage.GetEdbClassifyByParentIdAndName(parentClassifyId, edbClassifyInfo.ClassifyName, classifyId, classifyType) if e != nil && !utils.IsErrNoRow(e) { errMsg = "移动失败" err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error()) return } if exists != nil && exists.ClassifyId > 0 { errMsg = "移动失败，分类名称已存在" return } // 权限校验 { // 已授权分类id permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId) if tmpErr != nil { errMsg = "移动失败" err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error()) return } // 数据权限 haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(edbClassifyInfo.IsJoinPermission, edbClassifyInfo.ClassifyId, permissionClassifyIdList) if edbClassifyInfo.ClassifyType == 0 { // 普通指标 button := GetEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId, haveOperaAuth) if !button.MoveButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } else if edbClassifyInfo.ClassifyType == 1 { // 预测指标 button := GetPredictEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId, haveOperaAuth) if !button.MoveButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } } } else { edbInfo, err = data_manage.GetEdbInfoById(req.EdbInfoId) if err != nil { if utils.IsErrNoRow(err) { errMsg = "当前指标不存在" err = errors.New("获取分类信息失败,Err:" + err.Error()) return } errMsg = "移动失败" err = errors.New("获取分类信息失败,Err:" + err.Error()) return } if edbInfo.SysUserId != sysUser.AdminId { errMsg = "不是本人指标，您没有操作权限" err = errors.New(errMsg) return } if parentClassifyId == 0 { errMsg = "移动失败,指标必须挂在分类下" err = errors.New(errMsg) return } var haveOperaAuth bool // 权限校验 { haveOperaAuth, err = data_manage_permission.CheckEdbPermissionByEdbInfoId(edbInfo.EdbInfoId, edbInfo.ClassifyId, edbInfo.IsJoinPermission, sysUser.AdminId) if err != nil { errMsg = "移动失败" err = errors.New("获取指标权限信息失败,Err:" + err.Error()) return } } editShareEdbInfoIdMap, tmpErr := GetAllEditSharedEdbInfoIdMapByReceivedUserId(sysUser.AdminId) if tmpErr != nil { errMsg = "移动失败" err = errors.New("获取分享出来有操作权限的指标id列表失败,Err:" + tmpErr.Error()) return } // 移动权限校验 button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbInfoId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth, editShareEdbInfoIdMap) if !button.MoveButton { errMsg = "无操作权限" err = errors.New(errMsg) return } } if prevClassifyId > 0 { prevClassify, err = data_manage.GetEdbClassifyById(prevClassifyId) if err != nil { errMsg = "移动失败" err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error()) return } prevSort = prevClassify.Sort } else if prevEdbInfoId > 0 { prevEdbInfo, err = data_manage.GetEdbInfoById(prevEdbInfoId) if err != nil { errMsg = "移动失败" err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error()) return } prevSort = prevEdbInfo.Sort } if nextClassifyId > 0 { //下一个兄弟节点 nextClassify, err = data_manage.GetEdbClassifyById(nextClassifyId) if err != nil { errMsg = "移动失败" err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error()) return } nextSort = nextClassify.Sort } else if nextEdbInfoId > 0 { //下一个兄弟节点 nextEdbInfo, err = data_manage.GetEdbInfoById(nextEdbInfoId) if err != nil { errMsg = "移动失败" err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error()) return } nextSort = nextEdbInfo.Sort } err, errMsg = moveEdbOrClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType) return } // moveEdbOrClassify 移动指标分类 func moveEdbOrClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) { if edbClassifyInfo != nil { // 移动分类 return moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType) } else { // 移动指标 return moveEdb(prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType) } return } // moveEdb // @Description: 移动指标 // @author: Roc // @datetime 2024-11-26 16:07:37 // @param prevClassify *data_manage.EdbClassify // @param nextClassify *data_manage.EdbClassify // @param edbInfo *data_manage.EdbInfo // @param prevEdbInfo *data_manage.EdbInfo // @param nextEdbInfo *data_manage.EdbInfo // @param parentClassifyId int // @param prevSort int // @param nextSort int // @param classifyType uint8 // @return err error // @return errMsg string func moveEdb(prevClassify, nextClassify *data_manage.EdbClassify, edbInfo, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) { updateCol := make([]string, 0) if edbInfo == nil { errMsg = "当前指标不存在" err = errors.New(errMsg) return } //如果改变了分类，那么移动该指标数据 if edbInfo.ClassifyId != parentClassifyId { edbInfo.ClassifyId = parentClassifyId edbInfo.ModifyTime = time.Now() updateCol = append(updateCol, "ClassifyId", "ModifyTime") } if prevSort > 0 { //如果是移动在两个兄弟节点之间 if nextSort > 0 { //下一个兄弟节点 //如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1 if prevSort == nextSort || prevSort == edbInfo.Sort { //变更兄弟节点的排序 updateSortStr := `sort + 2` //变更分类 if prevClassify != nil { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType) } else { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType) } //变更指标 if prevEdbInfo != nil { //变更兄弟节点的排序 _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr) } else { _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr) } } else { //如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了 if nextSort-prevSort == 1 { //变更兄弟节点的排序 updateSortStr := `sort + 1` //变更分类 if prevClassify != nil { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType) } else { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType) } //变更指标 if prevEdbInfo != nil { //变更兄弟节点的排序 _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr) } else { _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr) } } } } edbInfo.Sort = prevSort + 1 edbInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 { //处理只拖动到目录里，默认放到目录底部的情况 var maxSort int maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType) if err != nil { errMsg = "移动失败" err = errors.New("查询组内排序信息失败,Err:" + err.Error()) return } edbInfo.Sort = maxSort + 1 //那就是排在组内最后一位 edbInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } else { // 拖动到父级分类的第一位 firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 { updateSortStr := ` sort + 1 ` _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType) //该分类下的所有指标也需要+1 _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr) } else { //如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序 firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId) if tErr != nil && !utils.IsErrNoRow(tErr) { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.Sort == 0 { updateSortStr := ` sort + 1 ` _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr) _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType) } } edbInfo.Sort = 0 //那就是排在第一位 edbInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } //更新 if len(updateCol) > 0 { err = edbInfo.Update(updateCol) if err != nil { errMsg = "移动失败" err = errors.New("修改失败,Err:" + err.Error()) return } } return } // moveEdbClassify // @Description: 移动指标分类 // @author: Roc // @datetime 2024-11-26 16:07:44 // @param parentEdbClassifyInfo *data_manage.EdbClassify // @param edbClassifyInfo *data_manage.EdbClassify // @param prevClassify *data_manage.EdbClassify // @param nextClassify *data_manage.EdbClassify // @param edbInfo *data_manage.EdbInfo // @param prevEdbInfo *data_manage.EdbInfo // @param nextEdbInfo *data_manage.EdbInfo // @param parentClassifyId int // @param prevSort int // @param nextSort int // @param classifyType uint8 // @return err error // @return errMsg string func moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify *data_manage.EdbClassify, prevEdbInfo, nextEdbInfo *data_manage.EdbInfo, parentClassifyId int, prevSort, nextSort int, classifyType uint8) (err error, errMsg string) { updateCol := make([]string, 0) // 移动对象为分类， 判断分类是否存在 oldParentId := edbClassifyInfo.ParentId oldLevel := edbClassifyInfo.Level var classifyIds []int if oldParentId != parentClassifyId { //更新子分类对应的level childList, e, m := GetChildClassifyByClassifyId(edbClassifyInfo.ClassifyId) if e != nil { errMsg = "移动失败" err = errors.New("查询子分类失败,Err:" + e.Error() + m) return } if len(childList) > 0 { for _, v := range childList { if v.ClassifyId == edbClassifyInfo.ClassifyId { continue } classifyIds = append(classifyIds, v.ClassifyId) } } } //判断上级id是否一致，如果不一致的话，那么需要移动该分类层级 if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 { if edbClassifyInfo.Level != parentEdbClassifyInfo.Level+1 { //禁止层级调整 errMsg = "移动失败" err = errors.New("不支持目录层级变更") return } edbClassifyInfo.ParentId = parentEdbClassifyInfo.ClassifyId edbClassifyInfo.RootId = parentEdbClassifyInfo.RootId edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1 edbClassifyInfo.ModifyTime = time.Now() updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime") } else if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 { errMsg = "移动失败" err = errors.New("不支持目录层级变更") return } if prevSort > 0 { //如果是移动在两个兄弟节点之间 if nextSort > 0 { //下一个兄弟节点 //如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1 if prevSort == nextSort || prevSort == edbClassifyInfo.Sort { //变更兄弟节点的排序 updateSortStr := `sort + 2` //变更分类 if prevClassify != nil { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType) } else { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType) } //变更指标 if prevEdbInfo != nil { //变更兄弟节点的排序 _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr) } else { _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr) } } else { //如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了 if nextSort-prevSort == 1 { //变更兄弟节点的排序 updateSortStr := `sort + 1` //变更分类 if prevClassify != nil { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType) } else { _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType) } //变更指标 if prevEdbInfo != nil { //变更兄弟节点的排序 _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr) } else { _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr) } } } } edbClassifyInfo.Sort = prevSort + 1 edbClassifyInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 { //处理只拖动到目录里，默认放到目录底部的情况 var maxSort int maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType) if err != nil { errMsg = "移动失败" err = errors.New("查询组内排序信息失败,Err:" + err.Error()) return } edbClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位 edbClassifyInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } else { // 拖动到父级分类的第一位 firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId) if tmpErr != nil && !utils.IsErrNoRow(tmpErr) { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstClassify != nil && firstClassify.ClassifyId > 0 && firstClassify.Sort == 0 { updateSortStr := ` sort + 1 ` _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType) //该分类下的所有指标也需要+1 _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr) } else { //如果该分类下存在指标，且第一个指标的排序等于0，那么需要调整排序 firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId) if tErr != nil && !utils.IsErrNoRow(tErr) { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstEdb != nil && firstEdb.ClassifyId > 0 && firstEdb.Sort == 0 { updateSortStr := ` sort + 1 ` _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr) _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType) } } edbClassifyInfo.Sort = 0 //那就是排在第一位 edbClassifyInfo.ModifyTime = time.Now() updateCol = append(updateCol, "Sort", "ModifyTime") } oldClassifyIdPath := edbClassifyInfo.ClassifyIdPath oldClassifyNamePath := edbClassifyInfo.ClassifyNamePath newClassifyNamePath := fmt.Sprint(parentEdbClassifyInfo.ClassifyNamePath, `|`, edbClassifyInfo.ClassifyName) newClassifyIdPath := fmt.Sprint(parentEdbClassifyInfo.ClassifyIdPath, `,`, edbClassifyInfo.ClassifyId) //更新 if len(updateCol) > 0 { edbClassifyInfo.ClassifyNamePath = newClassifyNamePath edbClassifyInfo.ClassifyIdPath = newClassifyIdPath updateCol = append(updateCol, "ClassifyNamePath", "ClassifyIdPath") err = edbClassifyInfo.Update(updateCol) if err != nil { errMsg = "移动失败" err = errors.New("修改失败,Err:" + err.Error()) return } //更新对应分类的root_id和层级 if oldParentId != parentClassifyId { if len(classifyIds) > 0 { levelStep := edbClassifyInfo.Level - oldLevel err = data_manage.UpdateEdbClassifyChildByParentClassifyId(classifyIds, edbClassifyInfo.RootId, levelStep) if err != nil { errMsg = "移动失败" err = errors.New("更新子分类失败,Err:" + err.Error()) return } } // 更改了上级分类，那么需要同步去更改自己的分类全路径 tmpErr := data_manage.UpdateEdbClassifyNameAndNamePathByOldClassifyIdPath(oldClassifyIdPath, newClassifyIdPath, oldClassifyNamePath, newClassifyNamePath) if tmpErr != nil { utils.FileLog.Error(fmt.Sprintf("更新分类全路径失败，分类id：%d；失败原因Err:%s", edbClassifyInfo.ClassifyId, tmpErr.Error())) } } } return } // GetEdbOpButton 获取ETA指标的操作权限 func GetEdbOpButton(sysUser *system.Admin, belongUserId, edbInfoId, edbType, edbInfoType int, haveOperaAuth bool, editShareEdbMap map[int]bool) (button data_manage.EdbClassifyItemsButton) { // 没有数据权限就直接返回 if !haveOperaAuth { return } //2、用户对于自己添加的分类，有权限编辑、移动和删除该分类； //3、ficc管理员和超管对所有分类有编辑、移动和删除权限； //if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN || sysUser.AdminId == belongUserId || sysUser.EdbPermission == 1 { // button.AddButton = true // button.OpButton = true // button.DeleteButton = true // button.MoveButton = true //} if sysUser.AdminId == belongUserId { //button.AddButton = true button.OpButton = true button.DeleteButton = true button.MoveButton = true } else { // 拥有别人分享的操作权限 if _, ok := editShareEdbMap[edbInfoId]; ok { button.OpButton = true } } // ETA指标的基础指标才允许插入值 if edbInfoType == 0 && edbType == 1 { button.InsertNewDataButton = true } // 关联指标、关联图的权限 button.ShowEdbRelation = false button.ShowChartRelation = false return } // GetEdbClassifyOpButton 获取ETA指标分类的操作权限 func GetEdbClassifyOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.EdbClassifyItemsButton) { // 没有数据权限就直接返回 if !haveOperaAuth { return } //ficc管理员和超管和ficc研究员有权限创建和管理分类，可以编辑分类名称（分类名称不允许重复），可以拖动分类，改变分类顺序，可以拖动分类下模型，改变顺序，可以删除分类，若分类下有预测指标，则不允许删除； //if utils.InArrayByStr([]string{utils.ROLE_TYPE_CODE_ADMIN, utils.ROLE_TYPE_CODE_FICC_ADMIN, utils.ROLE_TYPE_CODE_RESEARCHR, utils.ROLE_TYPE_CODE_FICC_RESEARCHR}, sysUser.RoleTypeCode) { button.AddButton = true button.OpButton = true button.DeleteButton = true button.MoveButton = true //} return } // GetPredictEdbOpButton 获取ETA预测指标的操作权限 func GetPredictEdbOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.EdbClassifyItemsButton) { // 没有数据权限就直接返回 if !haveOperaAuth { return } //预测指标的添加人对该预测指标有全部操作权限，ficc管理员、超管对所有预测指标有全部操作权限； if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN || sysUser.AdminId == belongUserId || sysUser.PredictEdbPermission == 1 { button.AddButton = true button.OpButton = true button.DeleteButton = true button.MoveButton = true } button.ShowEdbRelation = true button.ShowChartRelation = true return } // GetPredictEdbClassifyOpButton 获取ETA预测指标分类的操作权限 func GetPredictEdbClassifyOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.EdbClassifyItemsButton) { // 没有数据权限就直接返回 if !haveOperaAuth { return } //ficc管理员和超管和ficc研究员有权限创建和管理分类，可以编辑分类名称（分类名称不允许重复），可以拖动分类，改变分类顺序，可以拖动分类下模型，改变顺序，可以删除分类，若分类下有预测指标，则不允许删除； //if utils.InArrayByStr([]string{utils.ROLE_TYPE_CODE_ADMIN, utils.ROLE_TYPE_CODE_FICC_ADMIN, utils.ROLE_TYPE_CODE_RESEARCHR, utils.ROLE_TYPE_CODE_FICC_RESEARCHR}, sysUser.RoleTypeCode) { button.AddButton = true button.OpButton = true button.DeleteButton = true button.MoveButton = true //} return } func GetEdbClassifyMaxSort(parentId int, classifyType uint8) (maxSort int, err error) { //获取该层级下最大的排序数 classifyMaxSort, err := data_manage.GetEdbClassifyMaxSort(parentId, classifyType) if err != nil { return } maxSort = classifyMaxSort edbMaxSort, err := data_manage.GetEdbInfoMaxSortByClassifyId(parentId) if err != nil { return } if maxSort < edbMaxSort { maxSort = edbMaxSort } return } // GetAllChildClassifyByParentId // @Description: 根据上级id获取所有的下级id // @author: Roc // @datetime 2024-12-02 15:14:13 // @param parentId int // @return targetList []*data_manage.EdbClassifyItems // @return err error // @return errMsg string func GetAllChildClassifyByParentId(parentId int) (targetList []*data_manage.EdbClassifyItems, err error, errMsg string) { //判断是否是挂在顶级目录下 parentClassify, err := data_manage.GetEdbClassifyById(parentId) if err != nil { if utils.IsErrNoRow(err) { errMsg = "当前分类不存在" err = errors.New(errMsg) return } errMsg = "获取失败" err = errors.New("获取分类信息失败，Err:" + err.Error()) return } orderStr := ` order by level asc, sort asc, classify_id asc` targetList, err = data_manage.GetChildEdbClassifyListByParentId(fmt.Sprint(parentClassify.ClassifyIdPath, ",%"), orderStr) return }