edb_classify.go 38 KB

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