edb_classify.go 43 KB

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