edb_classify.go 53 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552
  1. package data
  2. import (
  3. "errors"
  4. "eta/eta_api/models"
  5. "eta/eta_api/models/data_manage"
  6. "eta/eta_api/models/data_manage/cross_variety"
  7. "eta/eta_api/models/data_manage/excel"
  8. "eta/eta_api/models/system"
  9. "eta/eta_api/services/alarm_msg"
  10. "eta/eta_api/services/data/data_manage_permission"
  11. "eta/eta_api/services/data_stat"
  12. "eta/eta_api/utils"
  13. "fmt"
  14. "strconv"
  15. "time"
  16. )
  17. func EdbClassifyListMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) {
  18. childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回
  19. allEdbInfo, _ := GetEdbClassifyEdbInfo()
  20. if len(childs) > 0 {
  21. node.Children = append(node.Children, childs[0:]...) //添加子节点
  22. for _, v := range childs { //查询子节点的子节点,并添加到子节点
  23. _, has := edbClassifyHaveChild(allNode, v)
  24. if has {
  25. EdbClassifyListMakeTree(allNode, v) //递归添加节点
  26. } else {
  27. edbInfoList := allEdbInfo[v.ClassifyId]
  28. v.Children = edbInfoList
  29. if v.Children == nil {
  30. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  31. v.Children = childrenArr
  32. }
  33. }
  34. }
  35. } else {
  36. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  37. node.Children = childrenArr
  38. }
  39. }
  40. func edbClassifyHaveChild(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) (childs []*data_manage.EdbClassifyItems, yes bool) {
  41. for _, v := range allNode {
  42. if v.ParentId == node.ClassifyId {
  43. childs = append(childs, v)
  44. }
  45. }
  46. if len(childs) > 0 {
  47. yes = true
  48. }
  49. return
  50. }
  51. // GetClassifyTreeRecursive 递归获取分类树形结构
  52. func GetClassifyTreeRecursive(list []*data_manage.EdbClassifyItems, parentId int) []*data_manage.EdbClassifyItems {
  53. res := make([]*data_manage.EdbClassifyItems, 0)
  54. for _, v := range list {
  55. if v.ParentId == parentId {
  56. v.Children = GetClassifyTreeRecursive(list, v.ClassifyId)
  57. res = append(res, v)
  58. }
  59. }
  60. return res
  61. }
  62. func GetFullClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) {
  63. //判断是否是挂在顶级目录下
  64. targetClassify, err := data_manage.GetEdbClassifyById(targetClassifyId)
  65. if err != nil {
  66. if err.Error() == utils.ErrNoRow() {
  67. errMsg = "当前分类不存在"
  68. err = errors.New(errMsg)
  69. return
  70. }
  71. errMsg = "获取失败"
  72. err = errors.New("获取分类信息失败,Err:" + err.Error())
  73. return
  74. }
  75. if targetClassify.ParentId == 0 {
  76. targetItem := new(data_manage.EdbClassifyIdItems)
  77. targetItem.ClassifyId = targetClassify.ClassifyId
  78. targetItem.ParentId = targetClassify.ParentId
  79. targetItem.RootId = targetClassify.RootId
  80. targetItem.UniqueCode = targetClassify.UniqueCode
  81. targetItem.Level = targetClassify.Level
  82. targetItem.ClassifyName = targetClassify.ClassifyName
  83. targetItem.ClassifyName = targetClassify.ClassifyName
  84. targetItem.IsJoinPermission = targetClassify.IsJoinPermission
  85. targetList = append(targetList, targetItem)
  86. return
  87. }
  88. tmpList, err := data_manage.GetEdbClassifyByRootIdLevel(targetClassify.RootId, targetClassify.ClassifyType, "")
  89. if err != nil && err.Error() != utils.ErrNoRow() {
  90. errMsg = "获取失败"
  91. err = errors.New("获取数据失败,Err:" + err.Error())
  92. return
  93. }
  94. idMap := make(map[int]struct{})
  95. if len(tmpList) > 0 {
  96. for _, v := range tmpList {
  97. if v.ClassifyId == targetClassify.ClassifyId {
  98. idMap[v.ClassifyId] = struct{}{}
  99. idMap[v.ParentId] = struct{}{}
  100. }
  101. }
  102. for _, v := range tmpList {
  103. if _, ok := idMap[v.ClassifyId]; ok {
  104. idMap[v.ParentId] = struct{}{}
  105. }
  106. }
  107. for _, v := range tmpList {
  108. if _, ok := idMap[v.ClassifyId]; ok {
  109. targetItem := new(data_manage.EdbClassifyIdItems)
  110. targetItem.ClassifyId = v.ClassifyId
  111. targetItem.ParentId = v.ParentId
  112. targetItem.RootId = v.RootId
  113. targetItem.UniqueCode = v.UniqueCode
  114. targetItem.Level = v.Level
  115. targetItem.ClassifyName = v.ClassifyName
  116. targetItem.IsJoinPermission = v.IsJoinPermission
  117. targetList = append(targetList, targetItem)
  118. }
  119. }
  120. }
  121. return
  122. }
  123. // GetFullClassifyByRootId 查询指标列表里的分类信息
  124. func GetFullClassifyByRootId(targetClassify *data_manage.EdbClassify, tmpList []*data_manage.EdbClassifyItems) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) {
  125. if targetClassify.ParentId == 0 {
  126. targetItem := new(data_manage.EdbClassifyIdItems)
  127. targetItem.ClassifyId = targetClassify.ClassifyId
  128. targetItem.ParentId = targetClassify.ParentId
  129. targetItem.RootId = targetClassify.RootId
  130. targetItem.UniqueCode = targetClassify.UniqueCode
  131. targetItem.Level = targetClassify.Level
  132. targetItem.ClassifyName = targetClassify.ClassifyName
  133. targetItem.ClassifyName = targetClassify.ClassifyName
  134. targetItem.IsJoinPermission = targetClassify.IsJoinPermission
  135. targetList = append(targetList, targetItem)
  136. return
  137. }
  138. idMap := make(map[int]struct{})
  139. if len(tmpList) > 0 {
  140. for _, v := range tmpList {
  141. if v.ClassifyId == targetClassify.ClassifyId {
  142. idMap[v.ClassifyId] = struct{}{}
  143. idMap[v.ParentId] = struct{}{}
  144. }
  145. }
  146. for _, v := range tmpList {
  147. if _, ok := idMap[v.ClassifyId]; ok {
  148. idMap[v.ParentId] = struct{}{}
  149. }
  150. }
  151. for _, v := range tmpList {
  152. if _, ok := idMap[v.ClassifyId]; ok {
  153. targetItem := new(data_manage.EdbClassifyIdItems)
  154. targetItem.ClassifyId = v.ClassifyId
  155. targetItem.ParentId = v.ParentId
  156. targetItem.RootId = v.RootId
  157. targetItem.UniqueCode = v.UniqueCode
  158. targetItem.Level = v.Level
  159. targetItem.ClassifyName = v.ClassifyName
  160. targetItem.IsJoinPermission = v.IsJoinPermission
  161. targetList = append(targetList, targetItem)
  162. }
  163. }
  164. }
  165. return
  166. }
  167. func GetChildClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) {
  168. //判断是否是挂在顶级目录下
  169. targetClassify, err := data_manage.GetEdbClassifyById(targetClassifyId)
  170. if err != nil {
  171. if err.Error() == utils.ErrNoRow() {
  172. errMsg = "当前分类不存在"
  173. err = errors.New(errMsg)
  174. return
  175. }
  176. errMsg = "获取失败"
  177. err = errors.New("获取分类信息失败,Err:" + err.Error())
  178. return
  179. }
  180. orderStr := ` order by level asc, sort asc, classify_id asc`
  181. tmpList, err := data_manage.GetEdbClassifyByRootIdLevel(targetClassify.RootId, targetClassify.ClassifyType, orderStr)
  182. if err != nil && err.Error() != utils.ErrNoRow() {
  183. errMsg = "获取失败"
  184. err = errors.New("获取数据失败,Err:" + err.Error())
  185. return
  186. }
  187. idMap := make(map[int]struct{})
  188. if len(tmpList) > 0 {
  189. for _, v := range tmpList {
  190. if v.ClassifyId == targetClassify.ClassifyId {
  191. idMap[v.ClassifyId] = struct{}{}
  192. }
  193. }
  194. for _, v := range tmpList {
  195. if _, ok := idMap[v.ParentId]; ok {
  196. idMap[v.ClassifyId] = struct{}{}
  197. }
  198. }
  199. for _, v := range tmpList {
  200. if _, ok := idMap[v.ClassifyId]; ok {
  201. targetItem := new(data_manage.EdbClassifyIdItems)
  202. targetItem.ClassifyId = v.ClassifyId
  203. targetItem.ParentId = v.ParentId
  204. targetItem.RootId = v.RootId
  205. targetItem.UniqueCode = v.UniqueCode
  206. targetItem.Level = v.Level
  207. targetItem.ClassifyName = v.ClassifyName
  208. targetItem.IsJoinPermission = v.IsJoinPermission
  209. targetList = append(targetList, targetItem)
  210. }
  211. }
  212. }
  213. return
  214. }
  215. func GetEdbClassifyEdbInfo() (result map[int][]*data_manage.EdbClassifyItems, err error) {
  216. cMap := make(map[int][]*data_manage.EdbClassifyItems)
  217. items, err := data_manage.GetEdbInfoAll(0)
  218. if err != nil {
  219. return
  220. }
  221. for _, v := range items {
  222. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  223. v.Children = childrenArr
  224. if items, ok := cMap[v.ClassifyId]; ok {
  225. items = append(items, v)
  226. cMap[v.ClassifyId] = items
  227. } else {
  228. infoList := make([]*data_manage.EdbClassifyItems, 0)
  229. infoList = append(infoList, v)
  230. cMap[v.ClassifyId] = infoList
  231. }
  232. }
  233. result = cMap
  234. return
  235. }
  236. func EdbClassifyItemsMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) {
  237. childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回
  238. if len(childs) > 0 {
  239. node.Children = append(node.Children, childs[0:]...) //添加子节点
  240. for _, v := range childs { //查询子节点的子节点,并添加到子节点
  241. _, has := edbClassifyHaveChild(allNode, v)
  242. if has {
  243. EdbClassifyItemsMakeTree(allNode, v) //递归添加节点
  244. } else {
  245. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  246. v.Children = childrenArr
  247. }
  248. }
  249. } else {
  250. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  251. node.Children = childrenArr
  252. }
  253. }
  254. // GetEdbClassifyListByAdminId 根据账户类型获取分类id集合
  255. func GetEdbClassifyListByAdminId(adminId int64) (classifyIdList []string, err error) {
  256. list, err := models.GetEdbdataClassify(adminId)
  257. if err != nil {
  258. return
  259. }
  260. for _, parent := range list {
  261. if parent.Child != nil {
  262. for _, classify := range parent.Child {
  263. classifyIdList = append(classifyIdList, fmt.Sprint(classify.ClassifyId))
  264. }
  265. }
  266. }
  267. return
  268. }
  269. // GetEdbClassifyNameListByAdminId 根据账户类型获取分类名称集合
  270. func GetEdbClassifyNameListByAdminId(adminId int64) (classifyNameList []string, edbDataClassifyMap map[string]*models.EdbdataClassify, err error) {
  271. list, err := models.GetEdbdataClassify(adminId)
  272. edbDataClassifyMap = make(map[string]*models.EdbdataClassify)
  273. if err != nil {
  274. return
  275. }
  276. for _, parent := range list {
  277. if parent.Child != nil {
  278. for _, classify := range parent.Child {
  279. classifyNameList = append(classifyNameList, classify.ClassifyName)
  280. edbDataClassifyMap[classify.ClassifyName] = classify
  281. }
  282. }
  283. }
  284. return
  285. }
  286. // AddEdbClassify 添加指标分类
  287. func AddEdbClassify(classifyName string, parentId, level int, classifyType uint8, sysUserId int, sysUserName, lang string) (classifyInfo *data_manage.EdbClassify, err error, errMsg string) {
  288. // 校验分类名称相同的数量
  289. {
  290. var count int
  291. switch lang {
  292. case utils.EnLangVersion:
  293. count, err = data_manage.GetEdbClassifyEnCount(classifyName, parentId, classifyType)
  294. default:
  295. count, err = data_manage.GetEdbClassifyCount(classifyName, parentId, classifyType)
  296. }
  297. if err != nil {
  298. errMsg = `判断名称是否已存在失败`
  299. return
  300. }
  301. if count > 0 {
  302. errMsg = `分类名称已存在,请重新输入`
  303. err = errors.New(errMsg)
  304. return
  305. }
  306. }
  307. // 层级校验
  308. if level > 6 {
  309. errMsg = `最高只支持添加6级分类`
  310. return
  311. }
  312. //获取该层级下最大的排序数
  313. maxSort, err := GetEdbClassifyMaxSort(parentId, classifyType)
  314. if err != nil {
  315. errMsg = "获取失败"
  316. err = errors.New("查询排序信息失败,Err:" + err.Error())
  317. return
  318. }
  319. //查询顶级rootId
  320. rootId := 0
  321. if parentId > 0 {
  322. parentClassify, tErr := data_manage.GetEdbClassifyById(parentId)
  323. if tErr != nil {
  324. if tErr.Error() == utils.ErrNoRow() {
  325. errMsg = "父级分类不存在"
  326. err = errors.New(errMsg)
  327. return
  328. }
  329. errMsg = "获取失败"
  330. err = errors.New("获取分类信息失败,Err:" + tErr.Error())
  331. return
  332. }
  333. rootId = parentClassify.RootId
  334. }
  335. timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
  336. classifyInfo = &data_manage.EdbClassify{
  337. //ClassifyId: 0,
  338. ClassifyType: classifyType,
  339. ClassifyName: classifyName,
  340. ClassifyNameEn: classifyName,
  341. ParentId: parentId,
  342. RootId: rootId,
  343. HasData: 0,
  344. CreateTime: time.Now(),
  345. ModifyTime: time.Now(),
  346. SysUserId: sysUserId,
  347. SysUserRealName: sysUserName,
  348. Level: level + 1,
  349. UniqueCode: utils.MD5(utils.DATA_PREFIX + "_" + timestamp),
  350. Sort: maxSort + 1,
  351. }
  352. newId, err := data_manage.AddEdbClassify(classifyInfo)
  353. if err != nil {
  354. errMsg = "保存分类失败"
  355. return
  356. }
  357. // 继承分类权限
  358. {
  359. source := 3
  360. if classifyType == 1 {
  361. source = 4
  362. }
  363. go data_manage_permission.InheritParentClassify(source, int(classifyType), int(newId), classifyInfo.ParentId, classifyInfo.ClassifyName)
  364. }
  365. if parentId == 0 { //一级目录的rootId等于自己本身
  366. classifyInfo.ClassifyId = int(newId)
  367. classifyInfo.RootId = int(newId)
  368. err = classifyInfo.Update([]string{"RootId"})
  369. if err != nil {
  370. errMsg = "更新分类失败"
  371. return
  372. }
  373. }
  374. return
  375. }
  376. // EditEdbClassify 编辑指标分类
  377. func EditEdbClassify(classifyId int, classifyName, lang string, sysUser *system.Admin) (err error, errMsg string) {
  378. item, err := data_manage.GetEdbClassifyById(classifyId)
  379. if err != nil {
  380. errMsg = `保存失败`
  381. return
  382. }
  383. // 权限校验
  384. {
  385. // 已授权分类id
  386. permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId)
  387. if tmpErr != nil {
  388. errMsg = "保存失败"
  389. err = errors.New("获取已授权分类id数据失败,Err:" + tmpErr.Error())
  390. return
  391. }
  392. // 数据权限
  393. haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(item.IsJoinPermission, item.ClassifyId, permissionClassifyIdList)
  394. if item.ClassifyType == 0 { // 普通指标
  395. button := GetEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth)
  396. if !button.OpButton {
  397. errMsg = "无操作权限"
  398. err = errors.New(errMsg)
  399. return
  400. }
  401. } else if item.ClassifyType == 1 { // 预测指标
  402. button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth)
  403. if !button.OpButton {
  404. errMsg = "无操作权限"
  405. err = errors.New(errMsg)
  406. return
  407. }
  408. }
  409. }
  410. // 需要变更的字段
  411. updateCols := make([]string, 0)
  412. switch lang {
  413. case utils.EnLangVersion:
  414. // 名字相同,那么就直接返回
  415. if item.ClassifyNameEn == classifyName {
  416. return
  417. }
  418. // 判断名称是否已存在
  419. count, tmpErr := data_manage.GetEdbClassifyEnCount(classifyName, item.ParentId, item.ClassifyType)
  420. if tmpErr != nil {
  421. err = tmpErr
  422. errMsg = "判断名称是否已存在失败"
  423. return
  424. }
  425. if count > 0 {
  426. errMsg = "分类名称已存在,请重新输入"
  427. err = errors.New(errMsg)
  428. return
  429. }
  430. item.ClassifyNameEn = classifyName
  431. item.LastModifyUserId = sysUser.AdminId
  432. item.LastModifyUserRealName = sysUser.RealName
  433. updateCols = append(updateCols, "ClassifyNameEn", "LastModifyUserId", "LastModifyUserRealName")
  434. default:
  435. // 名字相同,那么就直接返回
  436. if item.ClassifyName == classifyName {
  437. return
  438. }
  439. // 判断名称是否已存在
  440. count, tmpErr := data_manage.GetEdbClassifyCount(classifyName, item.ParentId, item.ClassifyType)
  441. if tmpErr != nil {
  442. err = tmpErr
  443. errMsg = "判断名称是否已存在失败"
  444. return
  445. }
  446. if count > 0 {
  447. errMsg = "分类名称已存在,请重新输入"
  448. err = errors.New(errMsg)
  449. return
  450. }
  451. item.ClassifyName = classifyName
  452. item.LastModifyUserId = sysUser.AdminId
  453. item.LastModifyUserRealName = sysUser.RealName
  454. updateCols = append(updateCols, "ClassifyName", "LastModifyUserId", "LastModifyUserRealName")
  455. }
  456. // 修改数据
  457. if len(updateCols) > 0 {
  458. err = item.Update(updateCols)
  459. if err != nil {
  460. errMsg = "保存失败"
  461. }
  462. }
  463. return
  464. }
  465. // DeleteCheck 删除检测
  466. func DeleteCheck(classifyId, edbInfoId int, sysUser *system.Admin) (deleteStatus int, tipsMsg string, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) {
  467. //删除分类
  468. if classifyId > 0 && edbInfoId == 0 {
  469. // 查找分类
  470. item, tmpErr := data_manage.GetEdbClassifyById(classifyId)
  471. if tmpErr != nil {
  472. errMsg = `查找分类失败`
  473. err = tmpErr
  474. return
  475. }
  476. // 已授权分类id
  477. permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId)
  478. if tmpErr != nil {
  479. errMsg = "删除检测失败"
  480. err = errors.New("获取已授权分类id数据失败,Err:" + tmpErr.Error())
  481. return
  482. }
  483. // 权限校验
  484. {
  485. // 数据权限
  486. haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(item.IsJoinPermission, item.ClassifyId, permissionClassifyIdList)
  487. if item.ClassifyType == 0 { // 普通指标
  488. button := GetEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth)
  489. if !button.DeleteButton {
  490. errMsg = "无操作权限"
  491. err = errors.New(errMsg)
  492. return
  493. }
  494. } else if item.ClassifyType == 1 { // 预测指标
  495. button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth)
  496. if !button.DeleteButton {
  497. errMsg = "无操作权限"
  498. err = errors.New(errMsg)
  499. return
  500. }
  501. }
  502. }
  503. //判断分类下,是否含有指标
  504. count, tmpErr := data_manage.GetEdbInfoCountByClassifyId(classifyId)
  505. if tmpErr != nil {
  506. errMsg = "删除失败"
  507. err = errors.New("分类下是否含有指标失败,Err:" + tmpErr.Error())
  508. return
  509. }
  510. if count > 0 {
  511. deleteStatus = 1
  512. tipsMsg = "若目录关联指标不可删除"
  513. }
  514. }
  515. if deleteStatus != 1 && edbInfoId == 0 {
  516. classifyCount, tmpErr := data_manage.GetClassifyCountByClassifyId(classifyId)
  517. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  518. errMsg = "删除失败"
  519. err = errors.New("分类下是否含有指标失败,Err:" + tmpErr.Error())
  520. return
  521. }
  522. if classifyCount > 0 {
  523. deleteStatus = 2
  524. tipsMsg = "确认删除当前目录及包含的子目录吗"
  525. }
  526. }
  527. //删除指标
  528. if edbInfoId > 0 {
  529. edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId)
  530. if tmpErr != nil {
  531. if tmpErr.Error() == utils.ErrNoRow() {
  532. errMsg = "指标已删除,请刷新页面"
  533. err = errors.New("指标不存在,Err:" + tmpErr.Error())
  534. return
  535. } else {
  536. errMsg = "删除失败"
  537. err = errors.New("删除失败,获取指标信息失败,Err:" + tmpErr.Error())
  538. return
  539. }
  540. }
  541. if edbInfo == nil {
  542. errMsg = "指标已删除,请刷新页面"
  543. return
  544. }
  545. //判断指标是否用于作图,如果用于作图,则不可删除
  546. chartCount, tmpErr := data_manage.GetChartEdbMappingCount(edbInfoId)
  547. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  548. errMsg = "删除失败"
  549. err = errors.New("判断指标是否被用于作图失败,Err:" + tmpErr.Error())
  550. return
  551. }
  552. if chartCount > 0 {
  553. deleteStatus = 3
  554. tipsMsg = "当前指标已用作画图,不可删除"
  555. return
  556. }
  557. //判断指标是否用于计算
  558. {
  559. calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId)
  560. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  561. errMsg = "删除失败"
  562. err = errors.New("判断指标是否被用于计算失败,GetEdbInfoCalculateCount Err:" + tmpErr.Error())
  563. return
  564. }
  565. if calculateCount > 0 {
  566. deleteStatus = 4
  567. tipsMsg = "当前指标已用作指标运算,不可删除"
  568. return
  569. }
  570. }
  571. //如果是普通指标,那么还需要判断是否被预测指标作为源指标
  572. if edbInfo.EdbInfoType == 0 {
  573. predictEdbInfoCount, tmpErr := data_manage.GetPredictEdbConfCount(edbInfoId)
  574. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  575. errMsg = "删除失败"
  576. err = errors.New("判断指标是否被用于预测指标失败,Err:" + tmpErr.Error())
  577. return
  578. }
  579. if predictEdbInfoCount > 0 {
  580. deleteStatus = 5
  581. tipsMsg = "当前指标已用作预测指标,不可删除"
  582. return
  583. }
  584. }
  585. // 判断指标是否用作表格引用
  586. {
  587. tableItems, tmpErr := excel.GetNoCustomAnalysisExcelEdbMapping(edbInfoId)
  588. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  589. errMsg = "删除失败"
  590. err = errors.New("判断指标是否用作表格引用,GetNoCustomAnalysisExcelEdbMappingCount Err:" + tmpErr.Error())
  591. return
  592. }
  593. //英文翻译:
  594. //1、当前指标已用作画图,不可删除:The current metric is in use for charting and cannot be deleted
  595. //2、当前指标已被表格引用,不可删除:The current metric is referenced by a table and cannot be deleted
  596. //3、删除失败:Deletion failed
  597. //4、知道了:Understood
  598. if len(tableItems) > 0 {
  599. deleteStatus = 6
  600. tipsMsg = "当前指标已被表格引用,不可删除"
  601. var excelIds []int
  602. for _, tableItem := range tableItems {
  603. if tableItem.ParentId > 0 {
  604. excelIds = append(excelIds, tableItem.ParentId)
  605. } else {
  606. excelIds = append(excelIds, tableItem.ExcelInfoId)
  607. }
  608. }
  609. tableList, tmpErr = excel.GetExcelBaseInfoByExcelInfoIdList(excelIds)
  610. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  611. errMsg = "删除失败"
  612. err = errors.New("判断指标是否用作表格引用,GetExcelBaseInfoByExcelInfoIdList Err:" + tmpErr.Error())
  613. return
  614. }
  615. return
  616. }
  617. }
  618. // 判断指标是否用作跨品种图表使用
  619. {
  620. // todo 如果绑定的标签未画图,则允许删除绑定
  621. // 查询跨品种的图表
  622. tagXList, tmpErr := cross_variety.GetChartInfoCrossVarietyByXEdbInfoId(edbInfoId)
  623. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  624. errMsg = "删除失败"
  625. err = errors.New("判断指标是否用作跨品种图表使用,GetChartInfoCrossVarietyByXEdbInfoId Err:" + tmpErr.Error())
  626. return
  627. }
  628. if len(tagXList) > 0 {
  629. deleteStatus = 7
  630. tipsMsg = "当前指标已添加到跨品种分析,不可删除"
  631. return
  632. }
  633. tagYList, tmpErr := cross_variety.GetChartInfoCrossVarietyByYEdbInfoId(edbInfoId)
  634. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  635. errMsg = "删除失败"
  636. err = errors.New("判断指标是否用作跨品种图表使用,GetChartInfoCrossVarietyByYEdbInfoId Err:" + tmpErr.Error())
  637. return
  638. }
  639. if len(tagYList) > 0 {
  640. deleteStatus = 7
  641. tipsMsg = "当前指标已添加到跨品种分析,不可删除"
  642. return
  643. }
  644. /*calculateCount, tmpErr := cross_variety.GetCountByEdbInfoId(edbInfoId)
  645. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  646. errMsg = "删除失败"
  647. err = errors.New("判断指标是否用作跨品种图表使用,GetCountByEdbInfoId Err:" + tmpErr.Error())
  648. return
  649. }
  650. if calculateCount > 0 {
  651. deleteStatus = 3
  652. tipsMsg = "当前指标已添加到跨品种分析,不可删除"
  653. return
  654. }*/
  655. }
  656. // 判断指标是否用于因子指标系列
  657. {
  658. ob := new(data_manage.FactorEdbSeriesMapping)
  659. cond := fmt.Sprintf(" AND %s = ?", ob.Cols().EdbInfoId)
  660. pars := make([]interface{}, 0)
  661. pars = append(pars, edbInfoId)
  662. count, e := ob.GetCountByCondition(cond, pars)
  663. if e != nil {
  664. errMsg = "删除失败"
  665. err = fmt.Errorf("获取指标是否用于系列失败, err: %v", e)
  666. return
  667. }
  668. if count > 0 {
  669. deleteStatus = 3
  670. tipsMsg = "当前指标已用于因子指标系列, 不可删除"
  671. return
  672. }
  673. }
  674. }
  675. return
  676. }
  677. // Delete 删除分类/指标
  678. func Delete(classifyId, edbInfoId int, sysUser *system.Admin, requestBody, requestUrl string) (nextItem *data_manage.EdbInfo, tableList []*data_manage.ExcelBaseInfo, err error, errMsg string) {
  679. //删除分类
  680. if classifyId > 0 && edbInfoId == 0 {
  681. // 查找分类
  682. item, tmpErr := data_manage.GetEdbClassifyById(classifyId)
  683. if tmpErr != nil {
  684. errMsg = `查找分类失败`
  685. err = tmpErr
  686. return
  687. }
  688. // 已授权分类id
  689. permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId)
  690. if tmpErr != nil {
  691. errMsg = "删除失败"
  692. err = errors.New("获取已授权分类id数据失败,Err:" + tmpErr.Error())
  693. return
  694. }
  695. // 权限校验
  696. {
  697. // 数据权限
  698. haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(item.IsJoinPermission, item.ClassifyId, permissionClassifyIdList)
  699. if item.ClassifyType == 0 { // 普通指标
  700. button := GetEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth)
  701. if !button.DeleteButton {
  702. errMsg = "无操作权限"
  703. err = errors.New(errMsg)
  704. return
  705. }
  706. } else if item.ClassifyType == 1 { // 预测指标
  707. button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId, haveOperaAuth)
  708. if !button.DeleteButton {
  709. errMsg = "无操作权限"
  710. err = errors.New(errMsg)
  711. return
  712. }
  713. }
  714. }
  715. //判断是否含有指标
  716. count, tmpErr := data_manage.GetEdbInfoCountByClassifyId(classifyId)
  717. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  718. errMsg = "删除失败"
  719. err = errors.New("分类下是否含有指标失败,Err:" + tmpErr.Error())
  720. return
  721. }
  722. if count > 0 {
  723. errMsg = "该目录下存在关联指标,不可删除"
  724. return
  725. }
  726. tmpErr = data_manage.DeleteEdbClassify(classifyId)
  727. if tmpErr != nil {
  728. errMsg = "删除失败"
  729. err = errors.New("删除失败,Err:" + tmpErr.Error())
  730. return
  731. }
  732. }
  733. //删除指标
  734. if edbInfoId > 0 {
  735. edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId)
  736. if tmpErr != nil {
  737. if tmpErr.Error() == utils.ErrNoRow() {
  738. errMsg = "指标已删除,请刷新页面"
  739. err = errors.New("指标不存在,Err:" + tmpErr.Error())
  740. return
  741. } else {
  742. errMsg = "删除失败"
  743. err = errors.New("删除失败,获取指标信息失败,Err:" + tmpErr.Error())
  744. return
  745. }
  746. }
  747. if edbInfo == nil {
  748. errMsg = "指标已删除,请刷新页面"
  749. return
  750. }
  751. //判断指标是否用于作图,如果用于作图,则不可删除
  752. chartCount, tmpErr := data_manage.GetChartEdbMappingCount(edbInfoId)
  753. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  754. errMsg = "删除失败"
  755. err = errors.New("判断指标是否被用于作图失败,Err:" + tmpErr.Error())
  756. return
  757. }
  758. if chartCount > 0 {
  759. errMsg = "当前指标已用作画图,不可删除"
  760. return
  761. }
  762. //如果是普通指标,那么还需要判断是否被预测指标作为源指标
  763. if edbInfo.EdbInfoType == 0 {
  764. predictEdbInfoCount, tmpErr := data_manage.GetPredictEdbConfCount(edbInfoId)
  765. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  766. errMsg = "删除失败"
  767. err = errors.New("判断指标是否被用于预测指标失败,Err:" + tmpErr.Error())
  768. return
  769. }
  770. if predictEdbInfoCount > 0 {
  771. errMsg = "当前指标已用作预测指标,不可删除"
  772. return
  773. }
  774. }
  775. //判断指标是否用作其他指标的计算
  776. {
  777. calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId)
  778. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  779. errMsg = "删除失败"
  780. err = errors.New("判断指标是否被用于计算失败,GetEdbInfoCalculateCount Err:" + tmpErr.Error())
  781. return
  782. }
  783. if calculateCount > 0 {
  784. errMsg = "当前指标已用作,指标运算,不可删除"
  785. return
  786. }
  787. }
  788. // 判断指标是否用作表格引用
  789. {
  790. tableItems, tmpErr := excel.GetNoCustomAnalysisExcelEdbMapping(edbInfoId)
  791. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  792. errMsg = "删除失败"
  793. err = errors.New("判断指标是否用作表格引用,GetNoCustomAnalysisExcelEdbMappingCount Err:" + tmpErr.Error())
  794. return
  795. }
  796. //英文翻译:
  797. //1、当前指标已用作画图,不可删除:The current metric is in use for charting and cannot be deleted
  798. //2、当前指标已被表格引用,不可删除:The current metric is referenced by a table and cannot be deleted
  799. //3、删除失败:Deletion failed
  800. //4、知道了:Understood
  801. if len(tableItems) > 0 {
  802. errMsg = "当前指标已被表格引用,不可删除"
  803. return
  804. }
  805. }
  806. // 判断指标是否用作跨品种图表使用
  807. {
  808. // todo 如果绑定的标签未画图,则允许删除绑定
  809. // 查询跨品种的图表
  810. tagXList, tmpErr := cross_variety.GetChartInfoCrossVarietyByXEdbInfoId(edbInfoId)
  811. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  812. errMsg = "删除失败"
  813. err = errors.New("判断指标是否用作跨品种图表使用,GetChartInfoCrossVarietyByXEdbInfoId Err:" + tmpErr.Error())
  814. return
  815. }
  816. if len(tagXList) > 0 {
  817. errMsg = "当前指标已添加到跨品种分析,不可删除"
  818. return
  819. }
  820. tagYList, tmpErr := cross_variety.GetChartInfoCrossVarietyByYEdbInfoId(edbInfoId)
  821. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  822. errMsg = "删除失败"
  823. err = errors.New("判断指标是否用作跨品种图表使用,GetChartInfoCrossVarietyByYEdbInfoId Err:" + tmpErr.Error())
  824. return
  825. }
  826. if len(tagYList) > 0 {
  827. errMsg = "当前指标已添加到跨品种分析,不可删除"
  828. return
  829. }
  830. /*calculateCount, tmpErr := cross_variety.GetCountByEdbInfoId(edbInfoId)
  831. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  832. errMsg = "删除失败"
  833. err = errors.New("判断指标是否用作跨品种图表使用,GetCountByEdbInfoId Err:" + tmpErr.Error())
  834. return
  835. }
  836. if calculateCount > 0 {
  837. errMsg = "当前指标已添加到跨品种分析,不可删除"
  838. return
  839. }*/
  840. }
  841. //真实删除
  842. tmpErr = data_manage.DeleteEdbInfoAndData(edbInfo.EdbInfoId, edbInfo.Source, edbInfo.SubSource)
  843. if tmpErr != nil {
  844. errMsg = "删除失败"
  845. err = errors.New("删除失败,Err:" + tmpErr.Error())
  846. return
  847. }
  848. // 如果是同花顺高频数据或类似数据, 还需要删除base_from_edb_mapping对应关系
  849. baseMappingOb := new(data_manage.BaseFromEdbMapping)
  850. {
  851. cond := fmt.Sprintf(" %s = ? AND %s = ? AND %s = ?", baseMappingOb.Cols().EdbCode, baseMappingOb.Cols().Source, baseMappingOb.Cols().SubSource)
  852. pars := make([]interface{}, 0)
  853. pars = append(pars, edbInfo.EdbCode, edbInfo.Source, edbInfo.SubSource)
  854. if e := baseMappingOb.RemoveByCondition(cond, pars); e != nil {
  855. errMsg = "删除失败"
  856. err = fmt.Errorf("删除源指标映射失败, %v", e)
  857. return
  858. }
  859. }
  860. go data_stat.AddEdbDeleteLog(edbInfo, sysUser)
  861. // 如果删除的指标是自定义分析的来源,那么还需要删除指标与excel的关系
  862. if edbInfo.Source == utils.DATA_SOURCE_CALCULATE_ZDYFX {
  863. tmpErr = excel.DeleteCustomAnalysisExcelEdbMappingByEdbInfoId(edbInfo.EdbInfoId)
  864. if tmpErr != nil {
  865. alarm_msg.SendAlarmMsg(fmt.Sprintf("删除指标时,需要删除与自定义分析的关系失败,指标ID:%d,Err:%s", edbInfo.EdbInfoId, tmpErr.Error()), 3)
  866. }
  867. }
  868. // 返回下一个表格的信息
  869. {
  870. var condition string
  871. var pars []interface{}
  872. condition += " AND edb_info_type=? AND classify_id=? "
  873. pars = append(pars, edbInfo.EdbInfoType, edbInfo.ClassifyId)
  874. condition += " AND (sort>? OR (sort=? AND edb_info_id<?) ) "
  875. pars = append(pars, edbInfo.Sort, edbInfo.Sort, edbInfo.EdbInfoId)
  876. nextItem, tmpErr = data_manage.GetNextEdbInfoByCondition(condition, pars)
  877. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  878. errMsg = "删除失败"
  879. err = errors.New("获取下一级预测指标信息失败,Err:" + tmpErr.Error())
  880. return
  881. }
  882. // 如果没找到,那么查找下一个分类的第一个表格
  883. if nextItem == nil {
  884. currClassifyInfo, tmpErr := data_manage.GetEdbClassifyById(edbInfo.ClassifyId)
  885. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  886. errMsg = "删除失败"
  887. err = errors.New("获取当前预测指标分类信息失败,Err:" + tmpErr.Error())
  888. return
  889. }
  890. nextItem, err = data_manage.GetNextEdbInfo(edbInfo.ClassifyId, currClassifyInfo.Sort, int(currClassifyInfo.ClassifyType), edbInfo.EdbInfoType)
  891. if err != nil && err.Error() != utils.ErrNoRow() {
  892. errMsg = "删除失败"
  893. err = errors.New("获取下一级预测指标信息失败,Err:" + tmpErr.Error())
  894. return
  895. }
  896. }
  897. }
  898. //新增操作日志
  899. {
  900. edbLog := new(data_manage.EdbInfoLog)
  901. edbLog.EdbInfoId = edbInfo.EdbInfoId
  902. edbLog.SourceName = edbInfo.SourceName
  903. edbLog.Source = edbInfo.Source
  904. edbLog.EdbCode = edbInfo.EdbCode
  905. edbLog.EdbName = edbInfo.EdbName
  906. edbLog.ClassifyId = edbInfo.ClassifyId
  907. edbLog.SysUserId = sysUser.AdminId
  908. edbLog.SysUserRealName = sysUser.RealName
  909. edbLog.CreateTime = time.Now()
  910. edbLog.Content = requestBody
  911. edbLog.Status = "删除指标"
  912. edbLog.Method = requestUrl
  913. go data_manage.AddEdbInfoLog(edbLog)
  914. }
  915. // 删除es中的数据
  916. DeleteEdbInfoToEs(edbInfoId)
  917. }
  918. return
  919. }
  920. // MoveEdbClassify 移动指标分类
  921. func MoveEdbClassify(req data_manage.MoveEdbClassifyReq, sysUser *system.Admin, classifyType uint8) (err error, errMsg string) {
  922. // req.ClassifyId, req.ParentClassifyId, req.PrevClassifyId, req.NextClassifyId
  923. classifyId := req.ClassifyId
  924. parentClassifyId := req.ParentClassifyId
  925. prevClassifyId := req.PrevClassifyId
  926. nextClassifyId := req.NextClassifyId
  927. edbInfoId := req.EdbInfoId
  928. prevEdbInfoId := req.PrevEdbInfoId
  929. nextEdbInfoId := req.NextEdbInfoId
  930. //首先确定移动的对象是分类还是指标
  931. //判断上一个节点是分类还是指标
  932. //判断下一个节点是分类还是指标
  933. //同时更新分类目录下的分类sort和指标sort
  934. //更新当前移动的分类或者指标sort
  935. var parentEdbClassifyInfo *data_manage.EdbClassify
  936. if parentClassifyId > 0 {
  937. parentEdbClassifyInfo, err = data_manage.GetEdbClassifyById(parentClassifyId)
  938. if err != nil {
  939. errMsg = "移动失败"
  940. err = errors.New("获取上级分类信息失败,Err:" + err.Error())
  941. return
  942. }
  943. }
  944. //如果有传入 上一个兄弟节点分类id
  945. var (
  946. edbClassifyInfo *data_manage.EdbClassify
  947. prevClassify *data_manage.EdbClassify
  948. nextClassify *data_manage.EdbClassify
  949. edbInfo *data_manage.EdbInfo
  950. prevEdbInfo *data_manage.EdbInfo
  951. nextEdbInfo *data_manage.EdbInfo
  952. prevSort int
  953. nextSort int
  954. )
  955. // 移动对象为分类, 判断权限
  956. if edbInfoId == 0 {
  957. edbClassifyInfo, err = data_manage.GetEdbClassifyById(classifyId)
  958. if err != nil {
  959. if err.Error() == utils.ErrNoRow() {
  960. errMsg = "当前分类不存在"
  961. err = errors.New("获取分类信息失败,Err:" + err.Error())
  962. return
  963. }
  964. errMsg = "移动失败"
  965. err = errors.New("获取分类信息失败,Err:" + err.Error())
  966. return
  967. }
  968. if parentClassifyId > 0 && parentEdbClassifyInfo.Level == 6 {
  969. errMsg = "最高只支持添加6级分类"
  970. err = errors.New(errMsg)
  971. return
  972. }
  973. // 如果是移动目录, 那么校验一下父级目录下是否有重名目录
  974. exists, e := data_manage.GetEdbClassifyByParentIdAndName(parentClassifyId, edbClassifyInfo.ClassifyName, classifyId)
  975. if e != nil && e.Error() != utils.ErrNoRow() {
  976. errMsg = "移动失败"
  977. err = fmt.Errorf("获取父级分类下的同名分类失败, Err: %s", e.Error())
  978. return
  979. }
  980. if exists != nil {
  981. errMsg = "移动失败,分类名称已存在"
  982. return
  983. }
  984. // 权限校验
  985. {
  986. // 已授权分类id
  987. permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbClassifyPermissionList(sysUser.AdminId, classifyId)
  988. if tmpErr != nil {
  989. errMsg = "移动失败"
  990. err = errors.New("获取已授权分类id数据失败,Err:" + tmpErr.Error())
  991. return
  992. }
  993. // 数据权限
  994. haveOperaAuth := data_manage_permission.CheckEdbClassifyPermissionByPermissionIdList(edbClassifyInfo.IsJoinPermission, edbClassifyInfo.ClassifyId, permissionClassifyIdList)
  995. if edbClassifyInfo.ClassifyType == 0 { // 普通指标
  996. button := GetEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId, haveOperaAuth)
  997. if !button.MoveButton {
  998. errMsg = "无操作权限"
  999. err = errors.New(errMsg)
  1000. return
  1001. }
  1002. } else if edbClassifyInfo.ClassifyType == 1 { // 预测指标
  1003. button := GetPredictEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId, haveOperaAuth)
  1004. if !button.MoveButton {
  1005. errMsg = "无操作权限"
  1006. err = errors.New(errMsg)
  1007. return
  1008. }
  1009. }
  1010. }
  1011. } else {
  1012. edbInfo, err = data_manage.GetEdbInfoById(req.EdbInfoId)
  1013. if err != nil {
  1014. if err.Error() == utils.ErrNoRow() {
  1015. errMsg = "当前指标不存在"
  1016. err = errors.New("获取分类信息失败,Err:" + err.Error())
  1017. return
  1018. }
  1019. errMsg = "移动失败"
  1020. err = errors.New("获取分类信息失败,Err:" + err.Error())
  1021. return
  1022. }
  1023. if parentClassifyId == 0 {
  1024. errMsg = "移动失败,指标必须挂在分类下"
  1025. err = errors.New(errMsg)
  1026. return
  1027. }
  1028. var haveOperaAuth bool
  1029. // 权限校验
  1030. {
  1031. haveOperaAuth, err = data_manage_permission.CheckEdbPermissionByEdbInfoId(edbInfo.EdbInfoId, edbInfo.ClassifyId, edbInfo.IsJoinPermission, sysUser.AdminId)
  1032. if err != nil {
  1033. errMsg = "移动失败"
  1034. err = errors.New("获取指标权限信息失败,Err:" + err.Error())
  1035. return
  1036. }
  1037. }
  1038. // 移动权限校验
  1039. button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType, haveOperaAuth)
  1040. if !button.MoveButton {
  1041. errMsg = "无操作权限"
  1042. err = errors.New(errMsg)
  1043. return
  1044. }
  1045. }
  1046. if prevClassifyId > 0 {
  1047. prevClassify, err = data_manage.GetEdbClassifyById(prevClassifyId)
  1048. if err != nil {
  1049. errMsg = "移动失败"
  1050. err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
  1051. return
  1052. }
  1053. prevSort = prevClassify.Sort
  1054. } else if prevEdbInfoId > 0 {
  1055. prevEdbInfo, err = data_manage.GetEdbInfoById(prevEdbInfoId)
  1056. if err != nil {
  1057. errMsg = "移动失败"
  1058. err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
  1059. return
  1060. }
  1061. prevSort = prevEdbInfo.Sort
  1062. }
  1063. if nextClassifyId > 0 {
  1064. //下一个兄弟节点
  1065. nextClassify, err = data_manage.GetEdbClassifyById(nextClassifyId)
  1066. if err != nil {
  1067. errMsg = "移动失败"
  1068. err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
  1069. return
  1070. }
  1071. nextSort = nextClassify.Sort
  1072. } else if nextEdbInfoId > 0 {
  1073. //下一个兄弟节点
  1074. nextEdbInfo, err = data_manage.GetEdbInfoById(nextEdbInfoId)
  1075. if err != nil {
  1076. errMsg = "移动失败"
  1077. err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
  1078. return
  1079. }
  1080. nextSort = nextEdbInfo.Sort
  1081. }
  1082. err, errMsg = moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
  1083. return
  1084. }
  1085. // moveEdbClassify 移动指标分类
  1086. 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) {
  1087. updateCol := make([]string, 0)
  1088. // 移动对象为分类, 判断分类是否存在
  1089. if edbClassifyInfo != nil {
  1090. oldParentId := edbClassifyInfo.ParentId
  1091. oldLevel := edbClassifyInfo.Level
  1092. var classifyIds []int
  1093. if oldParentId != parentClassifyId {
  1094. //更新子分类对应的level
  1095. childList, e, m := GetChildClassifyByClassifyId(edbClassifyInfo.ClassifyId)
  1096. if e != nil {
  1097. errMsg = "移动失败"
  1098. err = errors.New("查询子分类失败,Err:" + e.Error() + m)
  1099. return
  1100. }
  1101. if len(childList) > 0 {
  1102. for _, v := range childList {
  1103. if v.ClassifyId == edbClassifyInfo.ClassifyId {
  1104. continue
  1105. }
  1106. classifyIds = append(classifyIds, v.ClassifyId)
  1107. }
  1108. }
  1109. }
  1110. //判断上级id是否一致,如果不一致的话,那么需要移动该分类层级
  1111. if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
  1112. if edbClassifyInfo.Level != parentEdbClassifyInfo.Level+1 { //禁止层级调整
  1113. errMsg = "移动失败"
  1114. err = errors.New("不支持目录层级变更")
  1115. return
  1116. }
  1117. edbClassifyInfo.ParentId = parentEdbClassifyInfo.ClassifyId
  1118. edbClassifyInfo.RootId = parentEdbClassifyInfo.RootId
  1119. edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1
  1120. edbClassifyInfo.ModifyTime = time.Now()
  1121. updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime")
  1122. } else if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 {
  1123. errMsg = "移动失败"
  1124. err = errors.New("不支持目录层级变更")
  1125. return
  1126. }
  1127. if prevSort > 0 {
  1128. //如果是移动在两个兄弟节点之间
  1129. if nextSort > 0 {
  1130. //下一个兄弟节点
  1131. //如果上一个兄弟与下一个兄弟的排序权重是一致的,那么需要将下一个兄弟(以及下个兄弟的同样排序权重)的排序权重+2,自己变成上一个兄弟的排序权重+1
  1132. if prevSort == nextSort || prevSort == edbClassifyInfo.Sort {
  1133. //变更兄弟节点的排序
  1134. updateSortStr := `sort + 2`
  1135. //变更分类
  1136. if prevClassify != nil {
  1137. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
  1138. } else {
  1139. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  1140. }
  1141. //变更指标
  1142. if prevEdbInfo != nil {
  1143. //变更兄弟节点的排序
  1144. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
  1145. } else {
  1146. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  1147. }
  1148. } else {
  1149. //如果下一个兄弟的排序权重正好是上个兄弟节点的下一层,那么需要再加一层了
  1150. if nextSort-prevSort == 1 {
  1151. //变更兄弟节点的排序
  1152. updateSortStr := `sort + 1`
  1153. //变更分类
  1154. if prevClassify != nil {
  1155. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
  1156. } else {
  1157. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  1158. }
  1159. //变更指标
  1160. if prevEdbInfo != nil {
  1161. //变更兄弟节点的排序
  1162. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
  1163. } else {
  1164. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  1165. }
  1166. }
  1167. }
  1168. }
  1169. edbClassifyInfo.Sort = prevSort + 1
  1170. edbClassifyInfo.ModifyTime = time.Now()
  1171. updateCol = append(updateCol, "Sort", "ModifyTime")
  1172. } else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
  1173. //处理只拖动到目录里,默认放到目录底部的情况
  1174. var maxSort int
  1175. maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
  1176. if err != nil {
  1177. errMsg = "移动失败"
  1178. err = errors.New("查询组内排序信息失败,Err:" + err.Error())
  1179. return
  1180. }
  1181. edbClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
  1182. edbClassifyInfo.ModifyTime = time.Now()
  1183. updateCol = append(updateCol, "Sort", "ModifyTime")
  1184. } else {
  1185. // 拖动到父级分类的第一位
  1186. firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
  1187. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  1188. errMsg = "移动失败"
  1189. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
  1190. return
  1191. }
  1192. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  1193. if firstClassify != nil && firstClassify.Sort == 0 {
  1194. updateSortStr := ` sort + 1 `
  1195. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType)
  1196. //该分类下的所有指标也需要+1
  1197. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
  1198. } else {
  1199. //如果该分类下存在指标,且第一个指标的排序等于0,那么需要调整排序
  1200. firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
  1201. if tErr != nil && tErr.Error() != utils.ErrNoRow() {
  1202. errMsg = "移动失败"
  1203. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
  1204. return
  1205. }
  1206. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  1207. if firstEdb != nil && firstEdb.Sort == 0 {
  1208. updateSortStr := ` sort + 1 `
  1209. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
  1210. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
  1211. }
  1212. }
  1213. edbClassifyInfo.Sort = 0 //那就是排在第一位
  1214. edbClassifyInfo.ModifyTime = time.Now()
  1215. updateCol = append(updateCol, "Sort", "ModifyTime")
  1216. }
  1217. //更新
  1218. if len(updateCol) > 0 {
  1219. err = edbClassifyInfo.Update(updateCol)
  1220. if err != nil {
  1221. errMsg = "移动失败"
  1222. err = errors.New("修改失败,Err:" + err.Error())
  1223. return
  1224. }
  1225. //更新对应分类的root_id和层级
  1226. if oldParentId != parentClassifyId {
  1227. if len(classifyIds) > 0 {
  1228. levelStep := edbClassifyInfo.Level - oldLevel
  1229. err = data_manage.UpdateEdbClassifyChildByParentClassifyId(classifyIds, edbClassifyInfo.RootId, levelStep)
  1230. if err != nil {
  1231. errMsg = "移动失败"
  1232. err = errors.New("更新子分类失败,Err:" + err.Error())
  1233. return
  1234. }
  1235. }
  1236. }
  1237. }
  1238. } else {
  1239. if edbInfo == nil {
  1240. errMsg = "当前指标不存在"
  1241. err = errors.New(errMsg)
  1242. return
  1243. }
  1244. //如果改变了分类,那么移动该指标数据
  1245. if edbInfo.ClassifyId != parentClassifyId {
  1246. edbInfo.ClassifyId = parentClassifyId
  1247. edbInfo.ModifyTime = time.Now()
  1248. updateCol = append(updateCol, "ClassifyId", "ModifyTime")
  1249. }
  1250. if prevSort > 0 {
  1251. //如果是移动在两个兄弟节点之间
  1252. if nextSort > 0 {
  1253. //下一个兄弟节点
  1254. //如果上一个兄弟与下一个兄弟的排序权重是一致的,那么需要将下一个兄弟(以及下个兄弟的同样排序权重)的排序权重+2,自己变成上一个兄弟的排序权重+1
  1255. if prevSort == nextSort || prevSort == edbInfo.Sort {
  1256. //变更兄弟节点的排序
  1257. updateSortStr := `sort + 2`
  1258. //变更分类
  1259. if prevClassify != nil {
  1260. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
  1261. } else {
  1262. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  1263. }
  1264. //变更指标
  1265. if prevEdbInfo != nil {
  1266. //变更兄弟节点的排序
  1267. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
  1268. } else {
  1269. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  1270. }
  1271. } else {
  1272. //如果下一个兄弟的排序权重正好是上个兄弟节点的下一层,那么需要再加一层了
  1273. if nextSort-prevSort == 1 {
  1274. //变更兄弟节点的排序
  1275. updateSortStr := `sort + 1`
  1276. //变更分类
  1277. if prevClassify != nil {
  1278. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevSort, updateSortStr, classifyType)
  1279. } else {
  1280. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  1281. }
  1282. //变更指标
  1283. if prevEdbInfo != nil {
  1284. //变更兄弟节点的排序
  1285. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
  1286. } else {
  1287. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  1288. }
  1289. }
  1290. }
  1291. }
  1292. edbInfo.Sort = prevSort + 1
  1293. edbInfo.ModifyTime = time.Now()
  1294. updateCol = append(updateCol, "Sort", "ModifyTime")
  1295. } else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
  1296. //处理只拖动到目录里,默认放到目录底部的情况
  1297. var maxSort int
  1298. maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
  1299. if err != nil {
  1300. errMsg = "移动失败"
  1301. err = errors.New("查询组内排序信息失败,Err:" + err.Error())
  1302. return
  1303. }
  1304. edbInfo.Sort = maxSort + 1 //那就是排在组内最后一位
  1305. edbInfo.ModifyTime = time.Now()
  1306. updateCol = append(updateCol, "Sort", "ModifyTime")
  1307. } else {
  1308. // 拖动到父级分类的第一位
  1309. firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
  1310. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  1311. errMsg = "移动失败"
  1312. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
  1313. return
  1314. }
  1315. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  1316. if firstClassify != nil && firstClassify.Sort == 0 {
  1317. updateSortStr := ` sort + 1 `
  1318. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, classifyType)
  1319. //该分类下的所有指标也需要+1
  1320. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
  1321. } else {
  1322. //如果该分类下存在指标,且第一个指标的排序等于0,那么需要调整排序
  1323. firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
  1324. if tErr != nil && tErr.Error() != utils.ErrNoRow() {
  1325. errMsg = "移动失败"
  1326. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
  1327. return
  1328. }
  1329. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  1330. if firstEdb != nil && firstEdb.Sort == 0 {
  1331. updateSortStr := ` sort + 1 `
  1332. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
  1333. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
  1334. }
  1335. }
  1336. edbInfo.Sort = 0 //那就是排在第一位
  1337. edbInfo.ModifyTime = time.Now()
  1338. updateCol = append(updateCol, "Sort", "ModifyTime")
  1339. }
  1340. //更新
  1341. if len(updateCol) > 0 {
  1342. err = edbInfo.Update(updateCol)
  1343. if err != nil {
  1344. errMsg = "移动失败"
  1345. err = errors.New("修改失败,Err:" + err.Error())
  1346. return
  1347. }
  1348. }
  1349. }
  1350. return
  1351. }
  1352. // GetEdbOpButton 获取ETA指标的操作权限
  1353. func GetEdbOpButton(sysUser *system.Admin, belongUserId, edbType, edbInfoType int, haveOperaAuth bool) (button data_manage.EdbClassifyItemsButton) {
  1354. // 没有数据权限就直接返回
  1355. if !haveOperaAuth {
  1356. return
  1357. }
  1358. //2、用户对于自己添加的分类,有权限编辑、移动和删除该分类;
  1359. //3、ficc管理员和超管对所有分类有编辑、移动和删除权限;
  1360. if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN || sysUser.AdminId == belongUserId || sysUser.EdbPermission == 1 {
  1361. button.AddButton = true
  1362. button.OpButton = true
  1363. button.DeleteButton = true
  1364. button.MoveButton = true
  1365. }
  1366. // ETA指标的基础指标才允许插入值
  1367. if edbInfoType == 0 && edbType == 1 {
  1368. button.InsertNewDataButton = true
  1369. }
  1370. button.ShowEdbRelation = true
  1371. button.ShowChartRelation = true
  1372. return
  1373. }
  1374. // GetEdbClassifyOpButton 获取ETA指标分类的操作权限
  1375. func GetEdbClassifyOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.EdbClassifyItemsButton) {
  1376. // 没有数据权限就直接返回
  1377. if !haveOperaAuth {
  1378. return
  1379. }
  1380. //ficc管理员和超管和ficc研究员有权限创建和管理分类,可以编辑分类名称(分类名称不允许重复),可以拖动分类,改变分类顺序,可以拖动分类下模型,改变顺序,可以删除分类,若分类下有预测指标,则不允许删除;
  1381. //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) {
  1382. button.AddButton = true
  1383. button.OpButton = true
  1384. button.DeleteButton = true
  1385. button.MoveButton = true
  1386. //}
  1387. return
  1388. }
  1389. // GetPredictEdbOpButton 获取ETA预测指标的操作权限
  1390. func GetPredictEdbOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.EdbClassifyItemsButton) {
  1391. // 没有数据权限就直接返回
  1392. if !haveOperaAuth {
  1393. return
  1394. }
  1395. //预测指标的添加人对该预测指标有全部操作权限,ficc管理员、超管对所有预测指标有全部操作权限;
  1396. if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN || sysUser.AdminId == belongUserId || sysUser.PredictEdbPermission == 1 {
  1397. button.AddButton = true
  1398. button.OpButton = true
  1399. button.DeleteButton = true
  1400. button.MoveButton = true
  1401. }
  1402. button.ShowEdbRelation = true
  1403. button.ShowChartRelation = true
  1404. return
  1405. }
  1406. // GetPredictEdbClassifyOpButton 获取ETA预测指标分类的操作权限
  1407. func GetPredictEdbClassifyOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.EdbClassifyItemsButton) {
  1408. // 没有数据权限就直接返回
  1409. if !haveOperaAuth {
  1410. return
  1411. }
  1412. //ficc管理员和超管和ficc研究员有权限创建和管理分类,可以编辑分类名称(分类名称不允许重复),可以拖动分类,改变分类顺序,可以拖动分类下模型,改变顺序,可以删除分类,若分类下有预测指标,则不允许删除;
  1413. //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) {
  1414. button.AddButton = true
  1415. button.OpButton = true
  1416. button.DeleteButton = true
  1417. button.MoveButton = true
  1418. //}
  1419. return
  1420. }
  1421. func GetEdbClassifyMaxSort(parentId int, classifyType uint8) (maxSort int, err error) {
  1422. //获取该层级下最大的排序数
  1423. classifyMaxSort, err := data_manage.GetEdbClassifyMaxSort(parentId, classifyType)
  1424. if err != nil {
  1425. return
  1426. }
  1427. maxSort = classifyMaxSort
  1428. edbMaxSort, err := data_manage.GetEdbInfoMaxSortByClassifyId(parentId)
  1429. if err != nil {
  1430. return
  1431. }
  1432. if maxSort < edbMaxSort {
  1433. maxSort = edbMaxSort
  1434. }
  1435. return
  1436. }