edb_classify.go 52 KB

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