表格分类移动

controllers/data_manage/excel/excel_info.go

@@ -762,176 +762,176 @@ func (c *ExcelInfoController) Move() {
 		c.Data["json"] = br
 		c.ServeJSON()
 	}()
-
-	sysUser := c.SysUser
-	if sysUser == nil {
-		br.Msg = "请登录"
-		br.ErrMsg = "请登录，SysUser Is Empty"
-		br.Ret = 408
-		return
-	}
-
-	var req request.MoveExcelInfoReq
-	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
-	if err != nil {
-		br.Msg = "参数解析异常！"
-		br.ErrMsg = "参数解析失败，Err:" + err.Error()
-		return
-	}
-
-	if req.ExcelInfoId <= 0 {
-		br.Msg = "参数错误"
-		br.ErrMsg = "表格id小于等于0"
-		br.IsSendEmail = false
-		return
-	}
-
-	if req.ExcelClassifyId <= 0 {
-		br.Msg = "请选择分类"
-		br.IsSendEmail = false
-		return
-	}
-
-	//判断分类是否存在
-	_, err = excel3.GetExcelClassifyById(req.ExcelClassifyId)
-	if err != nil {
-		br.Msg = "移动失败"
-		br.ErrMsg = "获取分类信息失败" + err.Error()
-
-		if err.Error() == utils.ErrNoRow() {
-			br.Msg = "分类已被删除，不可移动，请刷新页面"
-			br.ErrMsg = "分类已被删除，不可移动，请刷新页面"
-			br.IsSendEmail = false
+	/*
+		sysUser := c.SysUser
+		if sysUser == nil {
+			br.Msg = "请登录"
+			br.ErrMsg = "请登录，SysUser Is Empty"
+			br.Ret = 408
+			return
 		}
-		return
-	}
 
-	// 获取表格信息
-	excelInfo, err := excel3.GetExcelInfoById(req.ExcelInfoId)
-	if err != nil {
-		br.Msg = "移动失败"
-		br.ErrMsg = "获取表格信息失败,Err:" + err.Error()
-		return
-	}
+		var req request.MoveExcelInfoReq
+		err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+		if err != nil {
+			br.Msg = "参数解析异常！"
+			br.ErrMsg = "参数解析失败，Err:" + err.Error()
+			return
+		}
 
-	//如果改变了分类，那么移动该表格数据
-	if excelInfo.ExcelClassifyId != req.ExcelClassifyId {
-		//查询需要修改的分类下是否存在同一个表格名称
-		tmpExcelInfo, tmpErr := excel3.GetExcelInfoByClassifyIdAndName(req.ExcelClassifyId, excelInfo.ExcelName)
-		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
-			br.Msg = "移动失败"
-			br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
+		if req.ExcelInfoId <= 0 {
+			br.Msg = "参数错误"
+			br.ErrMsg = "表格id小于等于0"
+			br.IsSendEmail = false
 			return
 		}
-		if tmpExcelInfo != nil {
-			br.Msg = "移动失败，同一个分类下表格名称不允许重复"
-			br.ErrMsg = "移动失败，同一个分类下表格名称不允许重复"
+
+		if req.ExcelClassifyId <= 0 {
+			br.Msg = "请选择分类"
 			br.IsSendEmail = false
 			return
 		}
 
-		// 变更表格的所属分类
-		excelInfo.ExcelClassifyId = req.ExcelClassifyId
-		err = excelInfo.Update([]string{"ExcelClassifyId"})
+		//判断分类是否存在
+		_, err = excel3.GetExcelClassifyById(req.ExcelClassifyId)
 		if err != nil {
 			br.Msg = "移动失败"
-			br.ErrMsg = "移动失败,Err:" + err.Error()
+			br.ErrMsg = "获取分类信息失败" + err.Error()
+
+			if err.Error() == utils.ErrNoRow() {
+				br.Msg = "分类已被删除，不可移动，请刷新页面"
+				br.ErrMsg = "分类已被删除，不可移动，请刷新页面"
+				br.IsSendEmail = false
+			}
 			return
 		}
-	}
 
-	//移动排序
-	updateCol := make([]string, 0)
-	//如果有传入 上一个兄弟节点分类id
-	if req.PrevExcelInfoId > 0 {
-		prevExcelInfo, err := excel3.GetExcelInfoById(req.PrevExcelInfoId)
+		// 获取表格信息
+		excelInfo, err := excel3.GetExcelInfoById(req.ExcelInfoId)
 		if err != nil {
 			br.Msg = "移动失败"
-			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+			br.ErrMsg = "获取表格信息失败,Err:" + err.Error()
 			return
 		}
 
-		//如果是移动在两个兄弟节点之间
-		if req.NextExcelInfoId > 0 {
-			//下一个兄弟节点
-			nextExcelInfo, err := excel3.GetExcelInfoById(req.NextExcelInfoId)
+		//如果改变了分类，那么移动该表格数据
+		if excelInfo.ExcelClassifyId != req.ExcelClassifyId {
+			//查询需要修改的分类下是否存在同一个表格名称
+			tmpExcelInfo, tmpErr := excel3.GetExcelInfoByClassifyIdAndName(req.ExcelClassifyId, excelInfo.ExcelName)
+			if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+				br.Msg = "移动失败"
+				br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
+				return
+			}
+			if tmpExcelInfo != nil {
+				br.Msg = "移动失败，同一个分类下表格名称不允许重复"
+				br.ErrMsg = "移动失败，同一个分类下表格名称不允许重复"
+				br.IsSendEmail = false
+				return
+			}
+
+			// 变更表格的所属分类
+			excelInfo.ExcelClassifyId = req.ExcelClassifyId
+			err = excelInfo.Update([]string{"ExcelClassifyId"})
 			if err != nil {
 				br.Msg = "移动失败"
-				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+				br.ErrMsg = "移动失败,Err:" + err.Error()
 				return
 			}
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevExcelInfo.Sort == nextExcelInfo.Sort || prevExcelInfo.Sort == excelInfo.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-				_ = excel3.UpdateExcelInfoSortByClassifyId(prevExcelInfo.ExcelClassifyId, prevExcelInfo.Sort, prevExcelInfo.ExcelInfoId, updateSortStr)
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点下一层，那么需要再加一层了
-				if nextExcelInfo.Sort-prevExcelInfo.Sort == 1 {
+		}
+
+		//移动排序
+		updateCol := make([]string, 0)
+		//如果有传入 上一个兄弟节点分类id
+		if req.PrevExcelInfoId > 0 {
+			prevExcelInfo, err := excel3.GetExcelInfoById(req.PrevExcelInfoId)
+			if err != nil {
+				br.Msg = "移动失败"
+				br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+				return
+			}
+
+			//如果是移动在两个兄弟节点之间
+			if req.NextExcelInfoId > 0 {
+				//下一个兄弟节点
+				nextExcelInfo, err := excel3.GetExcelInfoById(req.NextExcelInfoId)
+				if err != nil {
+					br.Msg = "移动失败"
+					br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+					return
+				}
+				//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+				if prevExcelInfo.Sort == nextExcelInfo.Sort || prevExcelInfo.Sort == excelInfo.Sort {
 					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
+					updateSortStr := `sort + 2`
 					_ = excel3.UpdateExcelInfoSortByClassifyId(prevExcelInfo.ExcelClassifyId, prevExcelInfo.Sort, prevExcelInfo.ExcelInfoId, updateSortStr)
+				} else {
+					//如果下一个兄弟的排序权重正好是上个兄弟节点下一层，那么需要再加一层了
+					if nextExcelInfo.Sort-prevExcelInfo.Sort == 1 {
+						//变更兄弟节点的排序
+						updateSortStr := `sort + 1`
+						_ = excel3.UpdateExcelInfoSortByClassifyId(prevExcelInfo.ExcelClassifyId, prevExcelInfo.Sort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
+					}
 				}
 			}
-		}
 
-		// 变更表格在当前分类下的排序
-		excelInfo.Sort = prevExcelInfo.Sort + 1
-		excelInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
+			// 变更表格在当前分类下的排序
+			excelInfo.Sort = prevExcelInfo.Sort + 1
+			excelInfo.ModifyTime = time.Now()
+			updateCol = append(updateCol, "Sort", "ModifyTime")
 
-	} else {
-		firstClassify, err := excel3.GetFirstExcelInfoByClassifyId(req.ExcelClassifyId)
-		if err != nil && err.Error() != utils.ErrNoRow() {
-			br.Msg = "移动失败"
-			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
-			return
-		}
+		} else {
+			firstClassify, err := excel3.GetFirstExcelInfoByClassifyId(req.ExcelClassifyId)
+			if err != nil && err.Error() != utils.ErrNoRow() {
+				br.Msg = "移动失败"
+				br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+				return
+			}
 
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = excel3.UpdateExcelInfoSortByClassifyId(firstClassify.ExcelClassifyId, 0, firstClassify.ExcelInfoId+1, updateSortStr)
+			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+			if firstClassify != nil && firstClassify.Sort == 0 {
+				updateSortStr := ` sort + 1 `
+				_ = excel3.UpdateExcelInfoSortByClassifyId(firstClassify.ExcelClassifyId, 0, firstClassify.ExcelInfoId+1, updateSortStr)
+			}
+
+			// 变更表格在当前分类下的排序
+			excelInfo.Sort = 0 //那就是排在第一位
+			excelInfo.ModifyTime = time.Now()
+			updateCol = append(updateCol, "Sort", "ModifyTime")
 		}
 
-		// 变更表格在当前分类下的排序
-		excelInfo.Sort = 0 //那就是排在第一位
-		excelInfo.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
+		//更新
+		if len(updateCol) > 0 {
+			err = excelInfo.Update(updateCol)
+			if err != nil {
+				br.Msg = "移动失败"
+				br.ErrMsg = "修改失败,Err:" + err.Error()
+				return
+			}
+		}
 
-	//更新
-	if len(updateCol) > 0 {
-		err = excelInfo.Update(updateCol)
 		if err != nil {
 			br.Msg = "移动失败"
 			br.ErrMsg = "修改失败,Err:" + err.Error()
 			return
 		}
-	}
-
-	if err != nil {
-		br.Msg = "移动失败"
-		br.ErrMsg = "修改失败,Err:" + err.Error()
-		return
-	}
-
-	//新增操作日志
-	//{
-	//	ExcelLog := new(data_manage.ExcelInfoLog)
-	//	ExcelLog.ExcelName = ExcelInfo.ExcelName
-	//	ExcelLog.ExcelInfoId = req.ExcelInfoId
-	//	ExcelLog.ExcelClassifyId = ExcelInfo.ExcelClassifyId
-	//	ExcelLog.SysUserId = sysUser.AdminId
-	//	ExcelLog.SysUserRealName = sysUser.RealName
-	//	ExcelLog.UniqueCode = ExcelInfo.UniqueCode
-	//	ExcelLog.CreateTime = time.Now()
-	//	ExcelLog.Content = string(c.Ctx.Input.RequestBody)
-	//	ExcelLog.Status = "移动表格"
-	//	ExcelLog.Method = c.Ctx.Input.URL()
-	//	go data_manage.AddExcelInfoLog(ExcelLog)
-	//}
 
+		//新增操作日志
+		//{
+		//	ExcelLog := new(data_manage.ExcelInfoLog)
+		//	ExcelLog.ExcelName = ExcelInfo.ExcelName
+		//	ExcelLog.ExcelInfoId = req.ExcelInfoId
+		//	ExcelLog.ExcelClassifyId = ExcelInfo.ExcelClassifyId
+		//	ExcelLog.SysUserId = sysUser.AdminId
+		//	ExcelLog.SysUserRealName = sysUser.RealName
+		//	ExcelLog.UniqueCode = ExcelInfo.UniqueCode
+		//	ExcelLog.CreateTime = time.Now()
+		//	ExcelLog.Content = string(c.Ctx.Input.RequestBody)
+		//	ExcelLog.Status = "移动表格"
+		//	ExcelLog.Method = c.Ctx.Input.URL()
+		//	go data_manage.AddExcelInfoLog(ExcelLog)
+		//}
+	*/
 	br.Ret = 200
 	br.Success = true
 	br.IsAddLog = true

models/data_manage/excel/excel_classify.go

@@ -122,13 +122,13 @@ func GetFirstExcelClassifyByParentId(parentId int) (item *ExcelClassify, err err
 }
 
 // UpdateExcelClassifySortByParentId 根据图表父类id更新排序
-func UpdateExcelClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string) (err error) {
+func UpdateExcelClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string, source int) (err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` update excel_classify set sort = ` + updateSort + ` WHERE parent_id=? and sort > ? AND is_delete=0 `
+	sql := ` update excel_classify set sort = ` + updateSort + ` WHERE parent_id=? and source=? and sort > ? AND is_delete=0 `
 	if classifyId > 0 {
 		sql += ` or ( excel_classify_id > ` + fmt.Sprint(classifyId) + ` and sort= ` + fmt.Sprint(nowSort) + `)`
 	}
-	_, err = o.Raw(sql, parentId, nowSort).Exec()
+	_, err = o.Raw(sql, parentId, source, nowSort).Exec()
 	return
 }
 
@@ -140,10 +140,10 @@ func (ExcelClassify *ExcelClassify) Update(cols []string) (err error) {
 }
 
 // GetExcelClassifyMaxSort 获取图表分类下最大的排序数
-func GetExcelClassifyMaxSort(parentId int) (sort int, err error) {
+func GetExcelClassifyMaxSort(parentId int, source int) (sort int, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT Max(sort) AS sort FROM excel_classify WHERE parent_id=? AND is_delete=0 `
-	err = o.Raw(sql, parentId).QueryRow(&sort)
+	sql := `SELECT Max(sort) AS sort FROM excel_classify WHERE parent_id=? AND source = ? AND is_delete=0 `
+	err = o.Raw(sql, parentId, source).QueryRow(&sort)
 	return
 }
 

models/data_manage/excel/excel_info.go

@@ -253,15 +253,15 @@ func GetFirstExcelInfoByClassifyId(classifyId int) (item *ExcelInfo, err error)
 }
 
 // UpdateExcelInfoSortByClassifyId 根据表格id更新排序
-func UpdateExcelInfoSortByClassifyId(classifyId, nowSort, prevExcelInfoId int, updateSort string) (err error) {
+func UpdateExcelInfoSortByClassifyId(classifyId, nowSort, prevExcelInfoId int, updateSort string, source int) (err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` update excel_info set sort = ` + updateSort + ` WHERE excel_classify_id=? AND is_delete=0 AND ( sort > ? `
+	sql := ` update excel_info set sort = ` + updateSort + ` WHERE excel_classify_id=? AND source=? AND is_delete=0 AND ( sort > ? `
 	// todo 前一个兄弟节点后移
 	if prevExcelInfoId > 0 {
 		sql += ` or (excel_info_id < ` + fmt.Sprint(prevExcelInfoId) + ` and sort = ` + fmt.Sprint(nowSort) + `)`
 	}
 	sql += `)`
-	_, err = o.Raw(sql, classifyId, nowSort).Exec()
+	_, err = o.Raw(sql, classifyId, source, nowSort).Exec()
 	return
 }
 

services/data/excel/excel_classify.go

@@ -11,7 +11,7 @@ import (
 
 func GetExcelClassifyMaxSort(parentId int, source int) (maxSort int, err error) {
 	//获取该层级下最大的排序数
-	maxSort, err = excel.GetExcelClassifyMaxSort(parentId)
+	maxSort, err = excel.GetExcelClassifyMaxSort(parentId, source)
 	if err != nil {
 		return
 	}
@@ -195,17 +195,17 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 
 					//变更分类
 					if prevClassify != nil {
-						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevClassify.Sort, updateSortStr)
+						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevClassify.Sort, updateSortStr, source)
 					} else {
-						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
+						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
 					}
 
 					//变更表格
 					if prevExcelInfo != nil {
 						//变更兄弟节点的排序
-						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr)
+						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
 					} else {
-						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
 					}
 				} else {
 					//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
@@ -215,17 +215,17 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 
 						//变更分类
 						if prevClassify != nil {
-							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevSort, updateSortStr)
+							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevSort, updateSortStr, source)
 						} else {
-							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
+							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
 						}
 
 						//变更表格
 						if prevExcelInfo != nil {
 							//变更兄弟节点的排序
-							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr)
+							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
 						} else {
-							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
 						}
 
 					}
@@ -259,9 +259,9 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
 			if firstClassify != nil && firstClassify.Sort == 0 {
 				updateSortStr := ` sort + 1 `
-				_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr)
+				_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, firstClassify.ClassifyId-1, 0, updateSortStr, source)
 				//该分类下的所有表格也需要+1
-				_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
+				_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr, source)
 			} else {
 				//如果该分类下存在表格，且第一个表格的排序等于0，那么需要调整排序
 				firstExcel, tErr := excel.GetFirstExcelInfoByClassifyId(parentClassifyId)
@@ -274,8 +274,8 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 				//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
 				if firstExcel != nil && firstExcel.Sort == 0 {
 					updateSortStr := ` sort + 1 `
-					_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, firstExcel.ExcelInfoId-1, updateSortStr)
-					_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr)
+					_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, firstExcel.ExcelInfoId-1, updateSortStr, source)
+					_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
 				}
 			}
 
@@ -328,17 +328,17 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 
 					//变更分类
 					if prevClassify != nil {
-						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevClassify.Sort, updateSortStr)
+						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevClassify.Sort, updateSortStr, source)
 					} else {
-						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
+						_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
 					}
 
 					//变更表格
 					if prevExcelInfo != nil {
 						//变更兄弟节点的排序
-						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr)
+						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
 					} else {
-						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+						_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
 					}
 				} else {
 					//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
@@ -347,17 +347,17 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 						updateSortStr := `sort + 1`
 						//变更分类
 						if prevClassify != nil {
-							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevSort, updateSortStr)
+							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, prevClassify.ExcelClassifyId, prevSort, updateSortStr, source)
 						} else {
-							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr)
+							_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, prevSort, updateSortStr, source)
 						}
 
 						//变更表格
 						if prevExcelInfo != nil {
 							//变更兄弟节点的排序
-							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr)
+							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, prevExcelInfo.ExcelInfoId, updateSortStr, source)
 						} else {
-							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr)
+							_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, prevSort, 0, updateSortStr, source)
 						}
 					}
 				}
@@ -390,9 +390,9 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 			//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
 			if firstClassify != nil && firstClassify.Sort == 0 {
 				updateSortStr := ` sort + 1 `
-				_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, firstClassify.ExcelClassifyId-1, 0, updateSortStr)
+				_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, firstClassify.ExcelClassifyId-1, 0, updateSortStr, source)
 				//该分类下的所有表格也需要+1
-				_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr)
+				_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, 0, updateSortStr, source)
 			} else {
 				//如果该分类下存在表格，且第一个表格的排序等于0，那么需要调整排序
 				firstExcel, tErr := excel.GetFirstExcelInfoByClassifyId(parentClassifyId)
@@ -405,8 +405,8 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 				//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
 				if firstExcel != nil && firstExcel.Sort == 0 {
 					updateSortStr := ` sort + 1 `
-					_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, firstExcel.ExcelInfoId-1, updateSortStr)
-					_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr)
+					_ = excel.UpdateExcelInfoSortByClassifyId(parentClassifyId, 0, firstExcel.ExcelInfoId-1, updateSortStr, source)
+					_ = excel.UpdateExcelClassifySortByParentId(parentClassifyId, 0, 0, updateSortStr, source)
 				}
 			}