edb_classify.go 34 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012
  1. package data
  2. import (
  3. "errors"
  4. "eta/eta_api/models"
  5. "eta/eta_api/models/data_manage"
  6. "eta/eta_api/models/system"
  7. "eta/eta_api/utils"
  8. "fmt"
  9. "strconv"
  10. "time"
  11. )
  12. func EdbClassifyListMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) {
  13. childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回
  14. allEdbInfo, _ := GetEdbClassifyEdbInfo()
  15. if len(childs) > 0 {
  16. node.Children = append(node.Children, childs[0:]...) //添加子节点
  17. for _, v := range childs { //查询子节点的子节点,并添加到子节点
  18. _, has := edbClassifyHaveChild(allNode, v)
  19. if has {
  20. EdbClassifyListMakeTree(allNode, v) //递归添加节点
  21. } else {
  22. edbInfoList := allEdbInfo[v.ClassifyId]
  23. v.Children = edbInfoList
  24. if v.Children == nil {
  25. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  26. v.Children = childrenArr
  27. }
  28. }
  29. }
  30. } else {
  31. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  32. node.Children = childrenArr
  33. }
  34. }
  35. func edbClassifyHaveChild(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) (childs []*data_manage.EdbClassifyItems, yes bool) {
  36. for _, v := range allNode {
  37. if v.ParentId == node.ClassifyId {
  38. childs = append(childs, v)
  39. }
  40. }
  41. if len(childs) > 0 {
  42. yes = true
  43. }
  44. return
  45. }
  46. // GetClassifyTreeRecursive 递归获取分类树形结构
  47. func GetClassifyTreeRecursive(list []*data_manage.EdbClassifyItems, parentId int) []*data_manage.EdbClassifyItems {
  48. res := make([]*data_manage.EdbClassifyItems, 0)
  49. for _, v := range list {
  50. if v.ParentId == parentId {
  51. v.Children = GetClassifyTreeRecursive(list, v.ClassifyId)
  52. res = append(res, v)
  53. }
  54. }
  55. return res
  56. }
  57. func GetFullClassifyByClassifyId(targetClassifyId int) (targetList []*data_manage.EdbClassifyIdItems, err error, errMsg string) {
  58. //判断是否是挂在顶级目录下
  59. targetClassify, err := data_manage.GetEdbClassifyById(targetClassifyId)
  60. if err != nil {
  61. if err.Error() == utils.ErrNoRow() {
  62. errMsg = "当前分类不存在"
  63. err = errors.New(errMsg)
  64. return
  65. }
  66. errMsg = "获取失败"
  67. err = errors.New("获取分类信息失败,Err:" + err.Error())
  68. return
  69. }
  70. if targetClassify.ParentId == 0 {
  71. targetItem := new(data_manage.EdbClassifyIdItems)
  72. targetItem.ClassifyId = targetClassify.ClassifyId
  73. targetItem.ParentId = targetClassify.ParentId
  74. targetItem.RootId = targetClassify.RootId
  75. targetItem.UniqueCode = targetClassify.UniqueCode
  76. targetItem.Level = targetClassify.Level
  77. targetItem.ClassifyName = targetClassify.ClassifyName
  78. targetList = append(targetList, targetItem)
  79. return
  80. }
  81. tmpList, err := data_manage.GetEdbClassifyByRootIdLevel(targetClassify.RootId, targetClassify.ClassifyType)
  82. if err != nil && err.Error() != utils.ErrNoRow() {
  83. errMsg = "获取失败"
  84. err = errors.New("获取数据失败,Err:" + err.Error())
  85. return
  86. }
  87. idMap := make(map[int]struct{})
  88. if len(tmpList) > 0 {
  89. for _, v := range tmpList {
  90. addFlag := false
  91. if v.ClassifyId == targetClassify.ClassifyId {
  92. idMap[v.ClassifyId] = struct{}{}
  93. idMap[v.ParentId] = struct{}{}
  94. addFlag = true
  95. } else if _, ok := idMap[v.ClassifyId]; ok {
  96. idMap[v.ParentId] = struct{}{}
  97. addFlag = true
  98. }
  99. if addFlag {
  100. targetItem := new(data_manage.EdbClassifyIdItems)
  101. targetItem.ClassifyId = v.ClassifyId
  102. targetItem.ParentId = v.ParentId
  103. targetItem.RootId = v.RootId
  104. targetItem.UniqueCode = v.UniqueCode
  105. targetItem.Level = v.Level
  106. targetItem.ClassifyName = v.ClassifyName
  107. targetList = append(targetList, targetItem)
  108. }
  109. }
  110. }
  111. return
  112. }
  113. func GetEdbClassifyEdbInfo() (result map[int][]*data_manage.EdbClassifyItems, err error) {
  114. cMap := make(map[int][]*data_manage.EdbClassifyItems)
  115. items, err := data_manage.GetEdbInfoAll(0)
  116. if err != nil {
  117. return
  118. }
  119. for _, v := range items {
  120. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  121. v.Children = childrenArr
  122. if items, ok := cMap[v.ClassifyId]; ok {
  123. items = append(items, v)
  124. cMap[v.ClassifyId] = items
  125. } else {
  126. infoList := make([]*data_manage.EdbClassifyItems, 0)
  127. infoList = append(infoList, v)
  128. cMap[v.ClassifyId] = infoList
  129. }
  130. }
  131. result = cMap
  132. return
  133. }
  134. func EdbClassifyItemsMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) {
  135. childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回
  136. if len(childs) > 0 {
  137. node.Children = append(node.Children, childs[0:]...) //添加子节点
  138. for _, v := range childs { //查询子节点的子节点,并添加到子节点
  139. _, has := edbClassifyHaveChild(allNode, v)
  140. if has {
  141. EdbClassifyItemsMakeTree(allNode, v) //递归添加节点
  142. } else {
  143. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  144. v.Children = childrenArr
  145. }
  146. }
  147. } else {
  148. childrenArr := make([]*data_manage.EdbClassifyItems, 0)
  149. node.Children = childrenArr
  150. }
  151. }
  152. // GetEdbClassifyListByAdminId 根据账户类型获取分类id集合
  153. func GetEdbClassifyListByAdminId(adminId int64) (classifyIdList []string, err error) {
  154. list, err := models.GetEdbdataClassify(adminId)
  155. if err != nil {
  156. return
  157. }
  158. for _, parent := range list {
  159. if parent.Child != nil {
  160. for _, classify := range parent.Child {
  161. classifyIdList = append(classifyIdList, fmt.Sprint(classify.ClassifyId))
  162. }
  163. }
  164. }
  165. return
  166. }
  167. // GetEdbClassifyNameListByAdminId 根据账户类型获取分类名称集合
  168. func GetEdbClassifyNameListByAdminId(adminId int64) (classifyNameList []string, edbDataClassifyMap map[string]*models.EdbdataClassify, err error) {
  169. list, err := models.GetEdbdataClassify(adminId)
  170. edbDataClassifyMap = make(map[string]*models.EdbdataClassify)
  171. if err != nil {
  172. return
  173. }
  174. for _, parent := range list {
  175. if parent.Child != nil {
  176. for _, classify := range parent.Child {
  177. classifyNameList = append(classifyNameList, classify.ClassifyName)
  178. edbDataClassifyMap[classify.ClassifyName] = classify
  179. }
  180. }
  181. }
  182. return
  183. }
  184. // AddEdbClassify 添加指标分类
  185. func AddEdbClassify(classifyName string, parentId, level int, classifyType uint8, sysUserId int, sysUserName string) (classifyInfo *data_manage.EdbClassify, err error, errMsg string) {
  186. count, err := data_manage.GetEdbClassifyCount(classifyName, parentId, classifyType)
  187. if err != nil {
  188. errMsg = `判断名称是否已存在失败`
  189. return
  190. }
  191. if count > 0 {
  192. errMsg = `分类名称已存在,请重新输入`
  193. return
  194. }
  195. if level > 6 {
  196. errMsg = `最高只支持添加6级分类`
  197. return
  198. }
  199. //获取该层级下最大的排序数
  200. maxSort, err := GetEdbClassifyMaxSort(parentId, classifyType)
  201. if err != nil {
  202. errMsg = "获取失败"
  203. err = errors.New("查询排序信息失败,Err:" + err.Error())
  204. return
  205. }
  206. //查询顶级rootId
  207. parentClassify, err := data_manage.GetEdbClassifyById(parentId)
  208. if err != nil {
  209. if err.Error() == utils.ErrNoRow() {
  210. errMsg = "父级分类不存在"
  211. err = errors.New(errMsg)
  212. return
  213. }
  214. errMsg = "获取失败"
  215. err = errors.New("获取分类信息失败,Err:" + err.Error())
  216. return
  217. }
  218. timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
  219. classifyInfo = &data_manage.EdbClassify{
  220. //ClassifyId: 0,
  221. ClassifyType: classifyType,
  222. ClassifyName: classifyName,
  223. ParentId: parentId,
  224. RootId: parentClassify.RootId,
  225. HasData: 0,
  226. CreateTime: time.Now(),
  227. ModifyTime: time.Now(),
  228. SysUserId: sysUserId,
  229. SysUserRealName: sysUserName,
  230. Level: level + 1,
  231. UniqueCode: utils.MD5(utils.DATA_PREFIX + "_" + timestamp),
  232. Sort: maxSort + 1,
  233. }
  234. _, err = data_manage.AddEdbClassify(classifyInfo)
  235. if err != nil {
  236. errMsg = "保存分类失败"
  237. }
  238. return
  239. }
  240. // EditEdbClassify 编辑指标分类
  241. func EditEdbClassify(classifyId int, classifyName string, sysUser *system.Admin) (err error, errMsg string) {
  242. item, err := data_manage.GetEdbClassifyById(classifyId)
  243. if err != nil {
  244. errMsg = `保存失败`
  245. return
  246. }
  247. // 权限校验
  248. {
  249. if item.ClassifyType == 0 { // 普通指标
  250. button := GetEdbClassifyOpButton(sysUser, item.SysUserId)
  251. if !button.OpButton {
  252. errMsg = "无操作权限"
  253. err = errors.New(errMsg)
  254. return
  255. }
  256. } else if item.ClassifyType == 1 { // 预测指标
  257. button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId)
  258. if !button.OpButton {
  259. errMsg = "无操作权限"
  260. err = errors.New(errMsg)
  261. return
  262. }
  263. }
  264. }
  265. // 名字相同,那么就直接返回
  266. if item.ClassifyName == classifyName {
  267. return
  268. }
  269. // 判断名称是否已存在
  270. count, err := data_manage.GetEdbClassifyCount(classifyName, item.ParentId, item.ClassifyType)
  271. if err != nil {
  272. errMsg = "判断名称是否已存在失败"
  273. return
  274. }
  275. if count > 0 {
  276. errMsg = "分类名称已存在,请重新输入"
  277. return
  278. }
  279. // 修改数据
  280. err = data_manage.EditEdbClassify(classifyId, classifyName)
  281. if err != nil {
  282. errMsg = "保存失败"
  283. }
  284. return
  285. }
  286. // DeleteCheck 删除检测
  287. func DeleteCheck(classifyId, edbInfoId int, sysUser *system.Admin) (deleteStatus int, tipsMsg string, err error, errMsg string) {
  288. //删除分类
  289. if classifyId > 0 && edbInfoId == 0 {
  290. // 查找分类
  291. item, tmpErr := data_manage.GetEdbClassifyById(classifyId)
  292. if tmpErr != nil {
  293. errMsg = `查找分类失败`
  294. err = tmpErr
  295. return
  296. }
  297. // 权限校验
  298. {
  299. if item.ClassifyType == 0 { // 普通指标
  300. button := GetEdbClassifyOpButton(sysUser, item.SysUserId)
  301. if !button.DeleteButton {
  302. errMsg = "无操作权限"
  303. err = errors.New(errMsg)
  304. return
  305. }
  306. } else if item.ClassifyType == 1 { // 预测指标
  307. button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId)
  308. if !button.DeleteButton {
  309. errMsg = "无操作权限"
  310. err = errors.New(errMsg)
  311. return
  312. }
  313. }
  314. }
  315. //判断分类下,是否含有指标
  316. count, tmpErr := data_manage.GetEdbInfoCountByClassifyId(classifyId)
  317. if tmpErr != nil {
  318. errMsg = "删除失败"
  319. err = errors.New("分类下是否含有指标失败,Err:" + tmpErr.Error())
  320. return
  321. }
  322. if count > 0 {
  323. deleteStatus = 1
  324. tipsMsg = "若目录关联指标不可删除"
  325. }
  326. }
  327. if deleteStatus != 1 && edbInfoId == 0 {
  328. classifyCount, tmpErr := data_manage.GetClassifyCountByClassifyId(classifyId)
  329. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  330. errMsg = "删除失败"
  331. err = errors.New("分类下是否含有指标失败,Err:" + tmpErr.Error())
  332. return
  333. }
  334. if classifyCount > 0 {
  335. deleteStatus = 2
  336. tipsMsg = "确认删除当前目录及包含的子目录吗"
  337. }
  338. }
  339. //删除指标
  340. if edbInfoId > 0 {
  341. //判断指标是否用于作图,如果用于作图,则不可删除
  342. chartCount, tmpErr := data_manage.GetChartEdbMappingCount(edbInfoId)
  343. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  344. errMsg = "删除失败"
  345. err = errors.New("判断指标是否被用于作图失败,Err:" + tmpErr.Error())
  346. return
  347. }
  348. if chartCount > 0 {
  349. deleteStatus = 3
  350. tipsMsg = "当前指标已用作画图,不可删除"
  351. }
  352. //判断指标是否用于计算
  353. {
  354. calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId)
  355. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  356. errMsg = "删除失败"
  357. err = errors.New("判断指标是否被用于计算失败,GetEdbInfoCalculateCount Err:" + tmpErr.Error())
  358. return
  359. }
  360. if calculateCount > 0 {
  361. deleteStatus = 4
  362. tipsMsg = "当前指标已用作,指标运算,不可删除"
  363. }
  364. }
  365. }
  366. return
  367. }
  368. // Delete 删除分类/指标
  369. func Delete(classifyId, edbInfoId int, sysUser *system.Admin, requestBody, requestUrl string) (nextItem *data_manage.EdbInfo, err error, errMsg string) {
  370. //删除分类
  371. if classifyId > 0 && edbInfoId == 0 {
  372. // 查找分类
  373. item, tmpErr := data_manage.GetEdbClassifyById(classifyId)
  374. if tmpErr != nil {
  375. errMsg = `查找分类失败`
  376. err = tmpErr
  377. return
  378. }
  379. // 权限校验
  380. {
  381. if item.ClassifyType == 0 { // 普通指标
  382. button := GetEdbClassifyOpButton(sysUser, item.SysUserId)
  383. if !button.DeleteButton {
  384. errMsg = "无操作权限"
  385. err = errors.New(errMsg)
  386. return
  387. }
  388. } else if item.ClassifyType == 1 { // 预测指标
  389. button := GetPredictEdbClassifyOpButton(sysUser, item.SysUserId)
  390. if !button.DeleteButton {
  391. errMsg = "无操作权限"
  392. err = errors.New(errMsg)
  393. return
  394. }
  395. }
  396. }
  397. //判断是否含有指标
  398. count, tmpErr := data_manage.GetEdbInfoCountByClassifyId(classifyId)
  399. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  400. errMsg = "删除失败"
  401. err = errors.New("分类下是否含有指标失败,Err:" + tmpErr.Error())
  402. return
  403. }
  404. if count > 0 {
  405. errMsg = "该目录下存在关联指标,不可删除"
  406. return
  407. }
  408. tmpErr = data_manage.DeleteEdbClassify(classifyId)
  409. if tmpErr != nil {
  410. errMsg = "删除失败"
  411. err = errors.New("删除失败,Err:" + tmpErr.Error())
  412. return
  413. }
  414. }
  415. //删除指标
  416. if edbInfoId > 0 {
  417. edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId)
  418. if tmpErr != nil {
  419. if tmpErr.Error() == utils.ErrNoRow() {
  420. errMsg = "指标已删除,请刷新页面"
  421. err = errors.New("指标不存在,Err:" + tmpErr.Error())
  422. return
  423. } else {
  424. errMsg = "删除失败"
  425. err = errors.New("删除失败,获取指标信息失败,Err:" + tmpErr.Error())
  426. return
  427. }
  428. }
  429. if edbInfo == nil {
  430. errMsg = "指标已删除,请刷新页面"
  431. return
  432. }
  433. //判断指标是否用于作图,如果用于作图,则不可删除
  434. chartCount, tmpErr := data_manage.GetChartEdbMappingCount(edbInfoId)
  435. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  436. errMsg = "删除失败"
  437. err = errors.New("判断指标是否被用于作图失败,Err:" + tmpErr.Error())
  438. return
  439. }
  440. if chartCount > 0 {
  441. errMsg = "当前指标已用作画图,不可删除"
  442. return
  443. }
  444. //如果是普通指标,那么还需要判断是否被预测指标作为源指标
  445. if edbInfo.EdbInfoType == 0 {
  446. predictEdbInfoCount, tmpErr := data_manage.GetPredictEdbConfCount(edbInfoId)
  447. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  448. errMsg = "删除失败"
  449. err = errors.New("判断指标是否被用于预测指标失败,Err:" + tmpErr.Error())
  450. return
  451. }
  452. if predictEdbInfoCount > 0 {
  453. errMsg = "当前指标已用作预测指标,不可删除"
  454. return
  455. }
  456. }
  457. //判断指标是否用作其他指标的计算
  458. {
  459. calculateCount, tmpErr := data_manage.GetEdbInfoCalculateMappingCount(edbInfoId)
  460. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  461. errMsg = "删除失败"
  462. err = errors.New("判断指标是否被用于计算失败,GetEdbInfoCalculateCount Err:" + tmpErr.Error())
  463. return
  464. }
  465. if calculateCount > 0 {
  466. errMsg = "当前指标已用作,指标运算,不可删除"
  467. return
  468. }
  469. }
  470. //真实删除
  471. tmpErr = data_manage.DeleteEdbInfoAndData(edbInfo.EdbInfoId, edbInfo.Source)
  472. if tmpErr != nil {
  473. errMsg = "删除失败"
  474. err = errors.New("删除失败,Err:" + tmpErr.Error())
  475. return
  476. }
  477. // 返回下一个表格的信息
  478. {
  479. var condition string
  480. var pars []interface{}
  481. condition += " AND edb_info_type=? AND classify_id=? "
  482. pars = append(pars, edbInfo.EdbInfoType, edbInfo.ClassifyId)
  483. condition += " AND (sort>? OR (sort=? AND edb_info_id<?) ) "
  484. pars = append(pars, edbInfo.Sort, edbInfo.Sort, edbInfo.EdbInfoId)
  485. nextItem, tmpErr = data_manage.GetNextEdbInfoByCondition(condition, pars)
  486. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  487. errMsg = "删除失败"
  488. err = errors.New("获取下一级预测指标信息失败,Err:" + tmpErr.Error())
  489. return
  490. }
  491. // 如果没找到,那么查找下一个分类的第一个表格
  492. if nextItem == nil {
  493. currClassifyInfo, tmpErr := data_manage.GetEdbClassifyById(edbInfo.ClassifyId)
  494. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  495. errMsg = "删除失败"
  496. err = errors.New("获取当前预测指标分类信息失败,Err:" + tmpErr.Error())
  497. return
  498. }
  499. nextItem, err = data_manage.GetNextEdbInfo(edbInfo.ClassifyId, currClassifyInfo.Sort, int(currClassifyInfo.ClassifyType), edbInfo.EdbInfoType)
  500. if err != nil && err.Error() != utils.ErrNoRow() {
  501. errMsg = "删除失败"
  502. err = errors.New("获取下一级预测指标信息失败,Err:" + tmpErr.Error())
  503. return
  504. }
  505. }
  506. }
  507. //新增操作日志
  508. {
  509. edbLog := new(data_manage.EdbInfoLog)
  510. edbLog.EdbInfoId = edbInfo.EdbInfoId
  511. edbLog.SourceName = edbInfo.SourceName
  512. edbLog.Source = edbInfo.Source
  513. edbLog.EdbCode = edbInfo.EdbCode
  514. edbLog.EdbName = edbInfo.EdbName
  515. edbLog.ClassifyId = edbInfo.ClassifyId
  516. edbLog.SysUserId = sysUser.AdminId
  517. edbLog.SysUserRealName = sysUser.RealName
  518. edbLog.CreateTime = time.Now()
  519. edbLog.Content = requestBody
  520. edbLog.Status = "删除指标"
  521. edbLog.Method = requestUrl
  522. go data_manage.AddEdbInfoLog(edbLog)
  523. }
  524. // 删除es中的数据
  525. DeleteEdbInfoToEs(edbInfoId)
  526. }
  527. return
  528. }
  529. // MoveEdbClassify 移动指标分类
  530. func MoveEdbClassify(req data_manage.MoveEdbClassifyReq, sysUser *system.Admin, classifyType uint8) (err error, errMsg string) {
  531. // req.ClassifyId, req.ParentClassifyId, req.PrevClassifyId, req.NextClassifyId
  532. classifyId := req.ClassifyId
  533. parentClassifyId := req.ParentClassifyId
  534. prevClassifyId := req.PrevClassifyId
  535. nextClassifyId := req.PrevClassifyId
  536. edbInfoId := req.EdbInfoId
  537. prevEdbInfoId := req.PrevEdbInfoId
  538. nextEdbInfoId := req.NextEdbInfoId
  539. //首先确定移动的对象是分类还是指标
  540. //判断上一个节点是分类还是指标
  541. //判断下一个节点是分类还是指标
  542. //同时更新分类目录下的分类sort和指标sort
  543. //更新当前移动的分类或者指标sort
  544. var parentEdbClassifyInfo *data_manage.EdbClassify
  545. if parentClassifyId > 0 {
  546. parentEdbClassifyInfo, err = data_manage.GetEdbClassifyById(parentClassifyId)
  547. if err != nil {
  548. errMsg = "移动失败"
  549. err = errors.New("获取上级分类信息失败,Err:" + err.Error())
  550. return
  551. }
  552. }
  553. //如果有传入 上一个兄弟节点分类id
  554. var (
  555. edbClassifyInfo *data_manage.EdbClassify
  556. prevClassify *data_manage.EdbClassify
  557. nextClassify *data_manage.EdbClassify
  558. edbInfo *data_manage.EdbInfo
  559. prevEdbInfo *data_manage.EdbInfo
  560. nextEdbInfo *data_manage.EdbInfo
  561. prevSort int
  562. nextSort int
  563. )
  564. // 移动对象为分类, 判断权限
  565. if edbInfoId == 0 {
  566. edbClassifyInfo, err = data_manage.GetEdbClassifyById(classifyId)
  567. if err != nil {
  568. if err.Error() == utils.ErrNoRow() {
  569. errMsg = "当前分类不存在"
  570. err = errors.New("获取分类信息失败,Err:" + err.Error())
  571. return
  572. }
  573. errMsg = "移动失败"
  574. err = errors.New("获取分类信息失败,Err:" + err.Error())
  575. return
  576. }
  577. if parentClassifyId > 0 && parentEdbClassifyInfo.Level == 6 {
  578. errMsg = "最高只支持添加6级分类"
  579. err = errors.New(errMsg)
  580. return
  581. }
  582. // 权限校验
  583. {
  584. if edbClassifyInfo.ClassifyType == 0 { // 普通指标
  585. button := GetEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId)
  586. if !button.MoveButton {
  587. errMsg = "无操作权限"
  588. err = errors.New(errMsg)
  589. return
  590. }
  591. } else if edbClassifyInfo.ClassifyType == 1 { // 预测指标
  592. button := GetPredictEdbClassifyOpButton(sysUser, edbClassifyInfo.SysUserId)
  593. if !button.MoveButton {
  594. errMsg = "无操作权限"
  595. err = errors.New(errMsg)
  596. return
  597. }
  598. }
  599. }
  600. } else {
  601. edbInfo, err = data_manage.GetEdbInfoById(req.EdbInfoId)
  602. if err != nil {
  603. if err.Error() == utils.ErrNoRow() {
  604. errMsg = "当前指标不存在"
  605. err = errors.New("获取分类信息失败,Err:" + err.Error())
  606. return
  607. }
  608. errMsg = "移动失败"
  609. err = errors.New("获取分类信息失败,Err:" + err.Error())
  610. return
  611. }
  612. if parentClassifyId == 0 {
  613. errMsg = "移动失败,指标必须挂在分类下"
  614. err = errors.New(errMsg)
  615. return
  616. }
  617. // 移动权限校验
  618. button := GetEdbOpButton(sysUser, edbInfo.SysUserId, edbInfo.EdbType, edbInfo.EdbInfoType)
  619. if !button.MoveButton {
  620. errMsg = "无操作权限"
  621. err = errors.New(errMsg)
  622. return
  623. }
  624. }
  625. if prevClassifyId > 0 {
  626. prevClassify, err = data_manage.GetEdbClassifyById(prevClassifyId)
  627. if err != nil {
  628. errMsg = "移动失败"
  629. err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
  630. return
  631. }
  632. prevSort = prevClassify.Sort
  633. } else if prevEdbInfoId > 0 {
  634. prevEdbInfo, err = data_manage.GetEdbInfoById(prevEdbInfoId)
  635. if err != nil {
  636. errMsg = "移动失败"
  637. err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
  638. return
  639. }
  640. prevSort = prevEdbInfo.Sort
  641. }
  642. if nextClassifyId > 0 {
  643. //下一个兄弟节点
  644. nextClassify, err = data_manage.GetEdbClassifyById(nextClassifyId)
  645. if err != nil {
  646. errMsg = "移动失败"
  647. err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
  648. return
  649. }
  650. nextSort = nextClassify.Sort
  651. } else if nextEdbInfoId > 0 {
  652. //下一个兄弟节点
  653. nextEdbInfo, err = data_manage.GetEdbInfoById(nextEdbInfoId)
  654. if err != nil {
  655. errMsg = "移动失败"
  656. err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
  657. return
  658. }
  659. nextSort = nextEdbInfo.Sort
  660. }
  661. err, errMsg = moveEdbClassify(parentEdbClassifyInfo, edbClassifyInfo, prevClassify, nextClassify, edbInfo, prevEdbInfo, nextEdbInfo, parentClassifyId, prevSort, nextSort, classifyType)
  662. return
  663. }
  664. // moveEdbClassify 移动指标分类
  665. 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) {
  666. updateCol := make([]string, 0)
  667. // 移动对象为分类, 判断分类是否存在
  668. if edbClassifyInfo != nil {
  669. //判断上级id是否一致,如果不一致的话,那么需要移动该分类层级
  670. if edbClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
  671. edbClassifyInfo.ParentId = parentEdbClassifyInfo.ClassifyId
  672. edbClassifyInfo.RootId = parentEdbClassifyInfo.RootId
  673. edbClassifyInfo.Level = parentEdbClassifyInfo.Level + 1
  674. edbClassifyInfo.ModifyTime = time.Now()
  675. updateCol = append(updateCol, "ParentId", "RootId", "Level", "ModifyTime")
  676. }
  677. if prevSort > 0 {
  678. //如果是移动在两个兄弟节点之间
  679. if nextSort > 0 {
  680. //下一个兄弟节点
  681. //如果上一个兄弟与下一个兄弟的排序权重是一致的,那么需要将下一个兄弟(以及下个兄弟的同样排序权重)的排序权重+2,自己变成上一个兄弟的排序权重+1
  682. if prevSort == nextSort || prevSort == edbClassifyInfo.Sort {
  683. //变更兄弟节点的排序
  684. updateSortStr := `sort + 2`
  685. //变更分类
  686. if prevClassify != nil {
  687. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
  688. } else {
  689. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  690. }
  691. //变更指标
  692. if prevEdbInfo != nil {
  693. //变更兄弟节点的排序
  694. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
  695. } else {
  696. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  697. }
  698. } else {
  699. //如果下一个兄弟的排序权重正好是上个兄弟节点的下一层,那么需要再加一层了
  700. if nextSort-prevSort == 1 {
  701. //变更兄弟节点的排序
  702. updateSortStr := `sort + 1`
  703. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  704. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  705. }
  706. }
  707. }
  708. edbClassifyInfo.Sort = prevClassify.Sort + 1
  709. edbClassifyInfo.ModifyTime = time.Now()
  710. updateCol = append(updateCol, "Sort", "ModifyTime")
  711. } else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
  712. //处理只拖动到目录里,默认放到目录底部的情况
  713. var maxSort int
  714. maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
  715. if err != nil {
  716. errMsg = "移动失败"
  717. err = errors.New("查询组内排序信息失败,Err:" + err.Error())
  718. return
  719. }
  720. edbClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
  721. edbClassifyInfo.ModifyTime = time.Now()
  722. updateCol = append(updateCol, "Sort", "ModifyTime")
  723. } else {
  724. // 拖动到父级分类的第一位
  725. firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
  726. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  727. errMsg = "移动失败"
  728. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
  729. return
  730. }
  731. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  732. if firstClassify != nil && firstClassify.Sort == 0 {
  733. updateSortStr := ` sort + 1 `
  734. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, edbClassifyInfo.ClassifyType)
  735. //该分类下的所有指标也需要+1
  736. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
  737. } else {
  738. //如果该分类下存在指标,且第一个指标的排序等于0,那么需要调整排序
  739. firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
  740. if tErr != nil && tErr.Error() != utils.ErrNoRow() {
  741. errMsg = "移动失败"
  742. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
  743. return
  744. }
  745. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  746. if firstEdb != nil && firstEdb.Sort == 0 {
  747. updateSortStr := ` sort + 1 `
  748. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
  749. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
  750. }
  751. }
  752. edbClassifyInfo.Sort = 0 //那就是排在第一位
  753. edbClassifyInfo.ModifyTime = time.Now()
  754. updateCol = append(updateCol, "Sort", "ModifyTime")
  755. }
  756. //更新
  757. if len(updateCol) > 0 {
  758. err = edbClassifyInfo.Update(updateCol)
  759. if err != nil {
  760. errMsg = "移动失败"
  761. err = errors.New("修改失败,Err:" + err.Error())
  762. return
  763. }
  764. }
  765. } else {
  766. if edbInfo == nil {
  767. errMsg = "当前指标不存在"
  768. err = errors.New(errMsg)
  769. return
  770. }
  771. //如果改变了分类,那么移动该指标数据
  772. if edbInfo.ClassifyId != parentClassifyId {
  773. edbInfo.ClassifyId = parentClassifyId
  774. edbInfo.ModifyTime = time.Now()
  775. updateCol = append(updateCol, "ClassifyId", "ModifyTime")
  776. }
  777. if prevSort > 0 {
  778. //如果是移动在两个兄弟节点之间
  779. if nextSort > 0 {
  780. //下一个兄弟节点
  781. //如果上一个兄弟与下一个兄弟的排序权重是一致的,那么需要将下一个兄弟(以及下个兄弟的同样排序权重)的排序权重+2,自己变成上一个兄弟的排序权重+1
  782. if prevSort == nextSort || prevSort == edbInfo.Sort {
  783. //变更兄弟节点的排序
  784. updateSortStr := `sort + 2`
  785. //变更分类
  786. if prevClassify != nil {
  787. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, prevClassify.ClassifyId, prevClassify.Sort, updateSortStr, classifyType)
  788. } else {
  789. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  790. }
  791. //变更指标
  792. if prevEdbInfo != nil {
  793. //变更兄弟节点的排序
  794. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, prevEdbInfo.EdbInfoId, updateSortStr)
  795. } else {
  796. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  797. }
  798. } else {
  799. //如果下一个兄弟的排序权重正好是上个兄弟节点的下一层,那么需要再加一层了
  800. if nextSort-prevSort == 1 {
  801. //变更兄弟节点的排序
  802. updateSortStr := `sort + 1`
  803. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, classifyType)
  804. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
  805. }
  806. }
  807. }
  808. edbInfo.Sort = prevEdbInfo.Sort + 1
  809. edbInfo.ModifyTime = time.Now()
  810. updateCol = append(updateCol, "Sort", "ModifyTime")
  811. } else if prevClassify == nil && nextClassify == nil && prevEdbInfo == nil && nextEdbInfo == nil && parentClassifyId > 0 {
  812. //处理只拖动到目录里,默认放到目录底部的情况
  813. var maxSort int
  814. maxSort, err = GetEdbClassifyMaxSort(parentClassifyId, classifyType)
  815. if err != nil {
  816. errMsg = "移动失败"
  817. err = errors.New("查询组内排序信息失败,Err:" + err.Error())
  818. return
  819. }
  820. edbInfo.Sort = maxSort + 1 //那就是排在组内最后一位
  821. edbInfo.ModifyTime = time.Now()
  822. updateCol = append(updateCol, "Sort", "ModifyTime")
  823. } else {
  824. // 拖动到父级分类的第一位
  825. firstClassify, tmpErr := data_manage.GetFirstEdbClassifyByParentId(parentClassifyId)
  826. if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
  827. errMsg = "移动失败"
  828. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
  829. return
  830. }
  831. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  832. if firstClassify != nil && firstClassify.Sort == 0 {
  833. updateSortStr := ` sort + 1 `
  834. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, edbClassifyInfo.ClassifyType)
  835. //该分类下的所有指标也需要+1
  836. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
  837. } else {
  838. //如果该分类下存在指标,且第一个指标的排序等于0,那么需要调整排序
  839. firstEdb, tErr := data_manage.GetFirstEdbInfoByClassifyId(parentClassifyId)
  840. if tErr != nil && tErr.Error() != utils.ErrNoRow() {
  841. errMsg = "移动失败"
  842. err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
  843. return
  844. }
  845. //如果该分类下存在其他分类,且第一个其他分类的排序等于0,那么需要调整排序
  846. if firstEdb != nil && firstEdb.Sort == 0 {
  847. updateSortStr := ` sort + 1 `
  848. _ = data_manage.UpdateEdbInfoSortByClassifyId(parentClassifyId, 0, firstEdb.EdbInfoId-1, updateSortStr)
  849. _ = data_manage.UpdateEdbClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, classifyType)
  850. }
  851. }
  852. edbInfo.Sort = 0 //那就是排在第一位
  853. edbInfo.ModifyTime = time.Now()
  854. updateCol = append(updateCol, "Sort", "ModifyTime")
  855. }
  856. //更新
  857. if len(updateCol) > 0 {
  858. err = edbInfo.Update(updateCol)
  859. if err != nil {
  860. errMsg = "移动失败"
  861. err = errors.New("修改失败,Err:" + err.Error())
  862. return
  863. }
  864. }
  865. }
  866. return
  867. }
  868. // GetEdbOpButton 获取ETA指标的操作权限
  869. func GetEdbOpButton(sysUser *system.Admin, belongUserId, edbType, edbInfoType int) (button data_manage.EdbClassifyItemsButton) {
  870. //2、用户对于自己添加的分类,有权限编辑、移动和删除该分类;
  871. //3、ficc管理员和超管对所有分类有编辑、移动和删除权限;
  872. if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN || sysUser.AdminId == belongUserId || sysUser.EdbPermission == 1 {
  873. button.AddButton = true
  874. button.OpButton = true
  875. button.DeleteButton = true
  876. button.MoveButton = true
  877. // ETA指标的基础指标才允许插入值
  878. if edbInfoType == 0 && edbType == 1 {
  879. button.InsertNewDataButton = true
  880. }
  881. }
  882. button.ShowEdbRelation = true
  883. button.ShowChartRelation = true
  884. return
  885. }
  886. // GetEdbClassifyOpButton 获取ETA指标分类的操作权限
  887. func GetEdbClassifyOpButton(sysUser *system.Admin, belongUserId int) (button data_manage.EdbClassifyItemsButton) {
  888. //ficc管理员和超管和ficc研究员有权限创建和管理分类,可以编辑分类名称(分类名称不允许重复),可以拖动分类,改变分类顺序,可以拖动分类下模型,改变顺序,可以删除分类,若分类下有预测指标,则不允许删除;
  889. //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) {
  890. button.AddButton = true
  891. button.OpButton = true
  892. button.DeleteButton = true
  893. button.MoveButton = true
  894. //}
  895. return
  896. }
  897. // GetPredictEdbOpButton 获取ETA预测指标的操作权限
  898. func GetPredictEdbOpButton(sysUser *system.Admin, belongUserId int) (button data_manage.EdbClassifyItemsButton) {
  899. //预测指标的添加人对该预测指标有全部操作权限,ficc管理员、超管对所有预测指标有全部操作权限;
  900. if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN || sysUser.AdminId == belongUserId || sysUser.PredictEdbPermission == 1 {
  901. button.AddButton = true
  902. button.OpButton = true
  903. button.DeleteButton = true
  904. button.MoveButton = true
  905. }
  906. button.ShowEdbRelation = true
  907. button.ShowChartRelation = true
  908. return
  909. }
  910. // GetPredictEdbClassifyOpButton 获取ETA预测指标分类的操作权限
  911. func GetPredictEdbClassifyOpButton(sysUser *system.Admin, belongUserId int) (button data_manage.EdbClassifyItemsButton) {
  912. //ficc管理员和超管和ficc研究员有权限创建和管理分类,可以编辑分类名称(分类名称不允许重复),可以拖动分类,改变分类顺序,可以拖动分类下模型,改变顺序,可以删除分类,若分类下有预测指标,则不允许删除;
  913. //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) {
  914. button.AddButton = true
  915. button.OpButton = true
  916. button.DeleteButton = true
  917. button.MoveButton = true
  918. //}
  919. return
  920. }
  921. func GetEdbClassifyMaxSort(parentId int, classifyType uint8) (maxSort int, err error) {
  922. //获取该层级下最大的排序数
  923. classifyMaxSort, err := data_manage.GetEdbClassifyMaxSort(parentId, classifyType)
  924. if err != nil {
  925. return
  926. }
  927. maxSort = classifyMaxSort
  928. edbMaxSort, err := data_manage.GetEdbInfoMaxSortByClassifyId(parentId)
  929. if err != nil {
  930. return
  931. }
  932. if maxSort < edbMaxSort {
  933. maxSort = edbMaxSort
  934. }
  935. return
  936. }