eta_api/services/data/excel/excel_classify.go

package excel

import (
	"errors"
	"eta_gn/eta_api/models/data_manage/excel"
	"eta_gn/eta_api/models/data_manage/excel/request"
	"eta_gn/eta_api/utils"
	"time"
)

func GetExcelClassifyMaxSort(parentId int, source int) (maxSort int, err error) {
	maxSort, err = excel.GetExcelClassifyMaxSort(parentId, source)
	if err != nil {
		return
	}
	edbMaxSort, err := excel.GetExcelMaxSortByClassifyId(parentId, source)
	if err != nil {
		return
	}
	if maxSort < edbMaxSort {
		maxSort = edbMaxSort
	}
	return
}

func MoveExcelClassify(req request.MoveExcelClassifyReq) (err error, errMsg string) {
	classifyId := req.ClassifyId
	parentClassifyId := req.ParentClassifyId
	prevClassifyId := req.PrevClassifyId
	nextClassifyId := req.NextClassifyId

	excelInfoId := req.ExcelInfoId
	prevExcelInfoId := req.PrevExcelInfoId
	nextExcelInfoId := req.NextExcelInfoId
	source := req.Source

	var parentExcelClassifyInfo *excel.ExcelClassify
	if parentClassifyId > 0 {
		parentExcelClassifyInfo, err = excel.GetExcelClassifyById(parentClassifyId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取上级分类信息失败,Err:" + err.Error())
			return
		}
	}

	var (
		excelClassifyInfo *excel.ExcelClassify
		prevClassify      *excel.ExcelClassify
		nextClassify      *excel.ExcelClassify

		excelInfo     *excel.ExcelInfo
		prevExcelInfo *excel.ExcelInfo
		nextExcelInfo *excel.ExcelInfo
		prevSort      int
		nextSort      int
	)

	if excelInfoId == 0 {
		excelClassifyInfo, err = excel.GetExcelClassifyById(classifyId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "当前分类不存在"
				err = errors.New("获取分类信息失败,Err:" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = errors.New("获取分类信息失败,Err:" + err.Error())
			return
		}

	} else {
		excelInfo, err = excel.GetExcelInfoById(excelInfoId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "当前表格不存在"
				err = errors.New("获取分类信息失败,Err:" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = errors.New("获取分类信息失败,Err:" + err.Error())
			return
		}
		if parentClassifyId == 0 {
			errMsg = "移动失败,表格必须挂在分类下"
			err = errors.New(errMsg)
			return
		}
	}

	if prevClassifyId > 0 {
		prevClassify, err = excel.GetExcelClassifyById(prevClassifyId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		prevSort = prevClassify.Sort
	} else if prevExcelInfoId > 0 {
		prevExcelInfo, err = excel.GetExcelInfoById(prevExcelInfoId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		prevSort = prevExcelInfo.Sort
	}

	if nextClassifyId > 0 {
		nextClassify, err = excel.GetExcelClassifyById(nextClassifyId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		nextSort = nextClassify.Sort
	} else if nextExcelInfoId > 0 {
		nextExcelInfo, err = excel.GetExcelInfoById(nextExcelInfoId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		nextSort = nextExcelInfo.Sort
	}

	err, errMsg = moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify, nextClassify, excelInfo, prevExcelInfo, nextExcelInfo, parentClassifyId, prevSort, nextSort, source)
	return
}

func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify, nextClassify *excel.ExcelClassify, excelInfo, prevExcelInfo, nextExcelInfo *excel.ExcelInfo, parentClassifyId int, prevSort, nextSort int, source int) (err error, errMsg string) {
	updateCol := make([]string, 0)

	if excelClassifyInfo != nil {
		oldParentId := excelClassifyInfo.ParentId
		if oldParentId != parentClassifyId {
		}
		if excelClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
			if excelClassifyInfo.Level != parentExcelClassifyInfo.Level+1 { //禁止层级调整
				errMsg = "移动失败"
				err = errors.New("不支持目录层级变更")
				return
			}
			excelClassifyInfo.ParentId = parentExcelClassifyInfo.ExcelClassifyId
			excelClassifyInfo.Level = parentExcelClassifyInfo.Level + 1
			excelClassifyInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
		} else if excelClassifyInfo.ParentId != parentClassifyId && parentClassifyId == 0 {
			errMsg = "移动失败"
			err = errors.New("不支持目录层级变更")
			return
		}

		if prevSort > 0 {
			if nextSort > 0 {
				if prevSort == nextSort || prevSort == excelClassifyInfo.Sort {
					updateSortStr := `sort + 2`

					if prevClassify != nil {
						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevClassify.Sort, updateSortStr, source)
					} else {
						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
					}

					if prevExcelInfo != nil {
						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
					} else {
						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
					}
				} else {
					if nextSort-prevSort == 1 {
						updateSortStr := `sort + 1`

						if prevClassify != nil {
							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevSort, updateSortStr, source)
						} else {
							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
						}

						if prevExcelInfo != nil {
							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
						} else {
							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
						}

					}
				}
			}

			excelClassifyInfo.Sort = prevSort + 1
			excelClassifyInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		} else if prevClassify == nil && nextClassify == nil && prevExcelInfo == nil && nextExcelInfo == nil && parentClassifyId > 0 {
			var maxSort int
			maxSort, err = GetExcelClassifyMaxSort(parentClassifyId, source)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("查询组内排序信息失败,Err:" + err.Error())
				return
			}
			excelClassifyInfo.Sort = maxSort + 1 //那就是排在组内最后一位
			excelClassifyInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		} else {
			firstClassify, tmpErr := excel.GetFirstExcelClassifyByParentId(parentClassifyId)
			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
				errMsg = "移动失败"
				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
				return
			}

			if firstClassify != nil && firstClassify.ExcelClassifyId > 0 && firstClassify.Sort == 0 {
				updateSortStr := ` sort + 1 `
				_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, firstClassify.ExcelClassifyId-1, 0, updateSortStr, source)
				_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr, source)
			} else {
				firstExcel, tErr := excel.GetFirstExcelInfoByClassifyId(parentClassifyId)
				if tErr != nil && !utils.IsErrNoRow(tErr) {
					errMsg = "移动失败"
					err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
					return
				}

				if firstExcel != nil && firstExcel.ExcelClassifyId > 0 && firstExcel.Sort == 0 {
					updateSortStr := ` sort + 1 `
					_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, firstExcel.ExcelInfoId-1, updateSortStr, source)
					_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
				}
			}

			excelClassifyInfo.Sort = 0 //那就是排在第一位
			excelClassifyInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		}

		if len(updateCol) > 0 {
			err = excelClassifyInfo.Update(updateCol)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("修改失败,Err:" + err.Error())
				return
			}
		}
	} else {
		if excelInfo == nil {
			errMsg = "当前表格不存在"
			err = errors.New(errMsg)
			return
		}
		if excelInfo.ExcelClassifyId != parentClassifyId {
			excelInfo.ExcelClassifyId = parentClassifyId
			excelInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "ExcelClassifyId", "ModifyTime")
		}
		if prevSort > 0 {
			if nextSort > 0 {
				if prevSort == nextSort || prevSort == excelInfo.Sort {
					updateSortStr := `sort + 2`

					if prevClassify != nil {
						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevClassify.Sort, updateSortStr, source)
					} else {
						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
					}

					if prevExcelInfo != nil {
						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
					} else {
						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
					}
				} else {
					if nextSort-prevSort == 1 {
						updateSortStr := `sort + 1`
						if prevClassify != nil {
							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevSort, updateSortStr, source)
						} else {
							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
						}

						if prevExcelInfo != nil {
							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
						} else {
							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
						}
					}
				}
			}

			excelInfo.Sort = prevSort + 1
			excelInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		} else if prevClassify == nil && nextClassify == nil && prevExcelInfo == nil && nextExcelInfo == nil && parentClassifyId > 0 {
			var maxSort int
			maxSort, err = GetExcelClassifyMaxSort(parentClassifyId, source)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("查询组内排序信息失败,Err:" + err.Error())
				return
			}
			excelInfo.Sort = maxSort + 1 //那就是排在组内最后一位
			excelInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		} else {
			firstClassify, tmpErr := excel.GetFirstExcelClassifyByParentId(parentClassifyId)
			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
				errMsg = "移动失败"
				err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
				return
			}

			if firstClassify != nil && firstClassify.ExcelClassifyId > 0 && firstClassify.Sort == 0 {
				updateSortStr := ` sort + 1 `
				_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, firstClassify.ExcelClassifyId-1, 0, updateSortStr, source)
				_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr, source)
			} else {
				firstExcel, tErr := excel.GetFirstExcelInfoByClassifyId(parentClassifyId)
				if tErr != nil && !utils.IsErrNoRow(tErr) {
					errMsg = "移动失败"
					err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tErr.Error())
					return
				}

				if firstExcel != nil && firstExcel.ExcelClassifyId > 0 && firstExcel.Sort == 0 {
					updateSortStr := ` sort + 1 `
					_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, firstExcel.ExcelInfoId-1, updateSortStr, source)
					_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
				}
			}

			excelInfo.Sort = 0 //那就是排在第一位
			excelInfo.ModifyTime = time.Now()
			updateCol = append(updateCol, "Sort", "ModifyTime")
		}

		if len(updateCol) > 0 {
			err = excelInfo.Update(updateCol)
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("修改失败,Err:" + err.Error())
				return
			}
		}
	}
	return
}

func GetChildClassifyByClassifyId(targetClassifyId int, source int) (targetList []*excel.ExcelClassifyItems, err error, errMsg string) {
	targetClassify, err := excel.GetExcelClassifyById(targetClassifyId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			errMsg = "当前分类不存在"
			err = errors.New(errMsg)
			return
		}
		errMsg = "获取失败"
		err = errors.New("获取分类信息失败，Err:" + err.Error())
		return
	}
	tmpList, err := excel.GetExcelClassifyBySourceOrderByLevel(source)
	if err != nil && !utils.IsErrNoRow(err) {
		errMsg = "获取失败"
		err = errors.New("获取数据失败，Err:" + err.Error())
		return
	}
	idMap := make(map[int]struct{})
	if len(tmpList) > 0 {
		for _, v := range tmpList {
			if v.ExcelClassifyId == targetClassify.ExcelClassifyId {
				idMap[v.ExcelClassifyId] = struct{}{}
			}
		}
		for _, v := range tmpList {
			if _, ok := idMap[v.ParentId]; ok {
				idMap[v.ExcelClassifyId] = struct{}{}
			}
		}
		for _, v := range tmpList {
			if _, ok := idMap[v.ExcelClassifyId]; ok {
				targetItem := new(excel.ExcelClassifyItems)
				targetItem.ExcelClassifyId = v.ExcelClassifyId
				targetItem.ParentId = v.ParentId
				targetItem.UniqueCode = v.UniqueCode
				targetItem.Level = v.Level
				targetList = append(targetList, targetItem)
			}
		}
	}

	return
}