edb_classify.go 55 KB

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