package data import ( "errors" "eta/eta_api/models" "eta/eta_api/models/data_manage" "eta/eta_api/models/data_manage/cross_variety" "eta/eta_api/models/data_manage/excel" "eta/eta_api/models/system" "eta/eta_api/services/alarm_msg" "eta/eta_api/services/data/data_manage_permission" "eta/eta_api/services/data_stat" "eta/eta_api/utils" "fmt" "strconv" "time" ) func EdbClassifyListMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) { childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回 allEdbInfo, _ := GetEdbClassifyEdbInfo() if len(childs) > 0 { node.Children = append(node.Children, childs[0:]...) //添加子节点 for _, v := range childs { //查询子节点的子节点，并添加到子节点 _, has := edbClassifyHaveChild(allNode, v) if has { EdbClassifyListMakeTree(allNode, v) //递归添加节点 } else { edbInfoList := allEdbInfo[v.ClassifyId] v.Children = edbInfoList if v.Children == nil { childrenArr := make([]*data_manage.EdbClassifyItems, 0) v.Children = childrenArr } } } } else { childrenArr := make([]*data_manage.EdbClassifyItems, 0) node.Children = childrenArr } } 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 } func GetFullClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) { //判断是否是挂在顶级目录下 targetClassify, err := data_manage.GetEdbClassifyById(targetClassifyId) if err != nil { if err.Error() == utils.ErrNoRow() { 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.ClassifyName = targetClassify.ClassifyName targetItem.IsJoinPermission = targetClassify.IsJoinPermission targetList = append(targetList, targetItem) return } tmpList, err := data_manage.GetEdbClassifyByRootIdLevel(targetClassify.RootId, targetClassify.ClassifyType, "") if err != nil && err.Error() != utils.ErrNoRow() { 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.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 err.Error() == utils.ErrNoRow() { 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 && err.Error() != utils.ErrNoRow() { 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 GetEdbClassifyEdbInfo() (result map[int][]*data_manage.EdbClassifyItems, err error) { cMap := make(map[int][]*data_manage.EdbClassifyItems) items, err := data_manage.GetEdbInfoAll(0) if err != nil { return } for _, v := range items { childrenArr := make([]*data_manage.EdbClassifyItems, 0) v.Children = childrenArr if items, ok := cMap[v.ClassifyId]; ok { items = append(items, v) cMap[v.ClassifyId] = items } else { infoList := make([]*data_manage.EdbClassifyItems, 0) infoList = append(infoList, v) cMap[v.ClassifyId] = infoList } } result = cMap 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, classifyType) default: count, err = data_manage.GetEdbClassifyCount(classifyName, parentId, classifyType) } if err != nil { errMsg = `判断名称是否已存在失败` return } if count > 0 { errMsg = `分类名称已存在，请重新输入` err = errors.New(errMsg) return } } // 层级校验 if level > 6 { errMsg = `最高只支持添加6级分类` return } //获取该层级下最大的排序数 maxSort, err := GetEdbClassifyMaxSort(parentId, classifyType) if err != nil { errMsg = "获取失败" err = errors.New("查询排序信息失败，Err:" + err.Error()) return } //查询顶级rootId rootId := 0 if parentId > 0 { parentClassify, tErr := data_manage.GetEdbClassifyById(parentId) if tErr != nil { if tErr.Error() == utils.ErrNoRow() { errMsg = "父级分类不存在" err = errors.New(errMsg) return } errMsg = "获取失败" err = errors.New("获取分类信息失败，Err:" + tErr.Error()) return } rootId = parentClassify.RootId } 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, } newId, err := data_manage.AddEdbClassify(classifyInfo) if err != nil { errMsg = "保存分类失败" return } // 继承分类权限 { source := 3 if classifyType == 1 { source = 4 } go data_manage_permission.InheritParentClassify(source, int(classifyType), int(newId), classifyInfo.ParentId, classifyInfo.ClassifyName) } if parentId == 0 { //一级目录的rootId等于自己本身 classifyInfo.ClassifyId = int(newId) classifyInfo.RootId = int(newId) err = classifyInfo.Update([]string{"RootId"}) if err != nil { errMsg = "更新分类失败" return } } 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) switch lang { case utils.EnLangVersion: // 名字相同，那么就直接返回 if item.ClassifyNameEn == classifyName { return } // 判断名称是否已存在 count, tmpErr := data_manage.GetEdbClassifyEnCount(classifyName, item.ParentId, 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.ParentId, item.ClassifyType) if tmpErr != nil { err = tmpErr errMsg = "判断名称是否已存在失败" return } if count > 0 { errMsg = "分类名称已存在，请重新输入" err = errors.New(errMsg) return } item.ClassifyName = classifyName item.LastModifyUserId = sysUser.AdminId item.LastModifyUserRealName = sysUser.RealName updateCols = append(updateCols, "ClassifyName", "LastModifyUserId", "LastModifyUserRealName") } // 修改数据 if len(updateCols) > 0 { err = item.Update(updateCols) if err != nil { errMsg = "保存失败" } } return } // DeleteCheck 删除检测 func DeleteCheck(classifyId, edbInfoId int, sysUser *system.Admin) (deleteStatus int, tipsMsg string, 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 && tmpErr.Error() != utils.ErrNoRow() { 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 tmpErr.Error() == utils.ErrNoRow() { 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 && tmpErr.Error() != utils.ErrNoRow() { errMsg = "删除失败" err = errors.New("判断指标是否被用于作图失败，Err:" + tmpErr.Error()) return } if chartCount > 0 { deleteStatus = 3 tipsMsg = "当前指标已用作画图，不可删除" return } //判断指标是否用于计算 { calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { 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 && tmpErr.Error() != utils.ErrNoRow() { errMsg = "删除失败" err = errors.New("判断指标是否被用于预测指标失败，Err:" + tmpErr.Error()) return } if predictEdbInfoCount > 0 { deleteStatus = 3 tipsMsg = "当前指标已用作预测指标，不可删除" return } } // 判断指标是否用作表格引用 { calculateCount, tmpErr := excel.GetNoCustomAnalysisExcelEdbMappingCount(edbInfoId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { errMsg = "删除失败" err = errors.New("判断指标是否用作表格引用，GetNoCustomAnalysisExcelEdbMappingCount Err:" + tmpErr.Error()) return } if calculateCount > 0 { deleteStatus = 3 tipsMsg = "当前指标已添加到表格，不可删除" return } } // 判断指标是否用作跨品种图表使用 { calculateCount, tmpErr := cross_variety.GetCountByEdbInfoId(edbInfoId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { errMsg = "删除失败" err = errors.New("判断指标是否用作跨品种图表使用，GetCountByEdbInfoId Err:" + tmpErr.Error()) return } if calculateCount > 0 { deleteStatus = 3 tipsMsg = "当前指标已添加到跨品种分析，不可删除" return } } } return } // Delete 删除分类/指标 func Delete(classifyId, edbInfoId int, sysUser *system.Admin, requestBody, requestUrl string) (nextItem *data_manage.EdbInfo, 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 && tmpErr.Error() != utils.ErrNoRow() { 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 tmpErr.Error() == utils.ErrNoRow() { 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 && tmpErr.Error() != utils.ErrNoRow() { 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 && tmpErr.Error() != utils.ErrNoRow() { errMsg = "删除失败" err = errors.New("判断指标是否被用于预测指标失败，Err:" + tmpErr.Error()) return } if predictEdbInfoCount > 0 { errMsg = "当前指标已用作预测指标，不可删除" return } } //判断指标是否用作其他指标的计算 { calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { errMsg = "删除失败" err = errors.New("判断指标是否被用于计算失败，GetEdbInfoCalculateCount Err:" + tmpErr.Error()) return } if calculateCount > 0 { errMsg = "当前指标已用作，指标运算，不可删除" return } } // 判断指标是否用作表格引用 { calculateCount, tmpErr := excel.GetNoCustomAnalysisExcelEdbMappingCount(edbInfoId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { errMsg = "删除失败" err = errors.New("判断指标是否用作表格引用，GetNoCustomAnalysisExcelEdbMappingCount Err:" + tmpErr.Error()) return } if calculateCount > 0 { errMsg = "当前指标已添加到表格，不可删除" return } } // 判断指标是否用作跨品种图表使用 { calculateCount, tmpErr := cross_variety.GetCountByEdbInfoId(edbInfoId) if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() { 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 } go data_stat.AddEdbDeleteLog(edbInfo, sysUser) // 如果删除的指标是自定义分析的来源，那么还需要删除指标与excel的关系 if edbInfo.Source == utils.DATA_SOURCE_CALCULATE_ZDYFX { tmpErr = excel.DeleteCustomAnalysisExcelEdbMappingByEdbInfoId(edbInfo.EdbInfoId) if tmpErr != nil { alarm_msg.SendAlarmMsg(fmt.Sprintf("删除指标时，需要删除与自定义分析的关系失败，指标ID：%d，Err:%s", edbInfo.EdbInfoId, tmpErr.Error()), 3) } } // 返回下一个表格的信息 { 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 err.Error() == utils.ErrNoRow() { errMsg = "当前分类不存在" err = errors.New("获取分类信息失败,Err:" + err.Error()) return } errMsg = "移动失败" err = errors.New("获取分类信息失败,Err:" + err.Error()) return } if parentClassifyId > 0 && parentEdbClassifyInfo.Level == 6 { errMsg = "最高只支持添加6级分类" err = errors.New(errMsg) return } // 如果是移动目录, 那么校验一下父级目录下是否有重名目录 exists, e := data_manage.GetEdbClassifyByParentIdAndName(parentClassifyId, edbClassifyInfo.ClassifyName, classifyId) if e != nil && e.Error() != utils.ErrNoRow() { errMsg = "移动失败" err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error()) return } if exists != 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(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 err.Error() == utils.ErrNoRow() { errMsg = "当前指标不存在" err = errors.New("获取分类信息失败,Err:" + err.Error()) return } errMsg = "移动失败" err = errors.New("获取分类信息失败,Err:" + err.Error()) 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 } } // 移动权限校验 button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth) 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 = moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType) return } // moveEdbClassify 移动指标分类 func moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, 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 edbClassifyInfo != nil { 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 && tmpErr.Error() != utils.ErrNoRow() { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstClassify != nil && 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 && tErr.Error() != utils.ErrNoRow() { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstEdb != nil && 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") } //更新 if len(updateCol) > 0 { 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 } } } } } else { 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 && tmpErr.Error() != utils.ErrNoRow() { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstClassify != nil && 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 && tErr.Error() != utils.ErrNoRow() { errMsg = "移动失败" err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error()) return } //如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序 if firstEdb != nil && 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 } // GetEdbOpButton 获取ETA指标的操作权限 func GetEdbOpButton(sysUser *system.Admin, belongUserId, edbType, edbInfoType int, haveOperaAuth 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 } // ETA指标的基础指标才允许插入值 if edbInfoType == 0 && edbType == 1 { button.InsertNewDataButton = true } button.ShowEdbRelation = true button.ShowChartRelation = true 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 }