refactor:重构素币兑换清单导入

@@ -867,6 +867,230 @@ func (cashPoolService *CashPoolService) UpdateExchangeCashActivity(updateExchang
 	}
 }
 
+// 更新兑换素币清单
+func (cashPoolService *CashPoolService) UpdateExchangeCashPerson(updateExchangeCashPersonCommand *command.UpdateExchangeCashPersonCommand) (interface{}, error) {
+	if err := updateExchangeCashPersonCommand.ValidateCommand(); err != nil {
+		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
+	}
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+
+	// 兑换素币清单仓储初始化
+	var exchangeCashPersonListRepository domain.ExchangeCashPersonListRepository
+	if value, err := factory.CreateExchangeCashPersonListRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	} else {
+		exchangeCashPersonListRepository = value
+	}
+
+	// 兑换现金活动仓储初始化
+	var exchangeCashActivityRepository domain.ExchangeActivityRepository
+	if value, err := factory.CreateExchangeCashActivityRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	} else {
+		exchangeCashActivityRepository = value
+	}
+
+	// 现金池仓储初始化
+	var cashPoolRepository domain.CashPoolRepository
+	if value, err  := factory.CreateCashPoolRepository(map[string] interface{} {
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	} else {
+		cashPoolRepository = value
+	}
+
+	// 操作素币服务初始化
+	var operationSuMoneyService service.OperationSuMoneyService
+	if value, err := factory.CreateOperationSuMoneyService(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	} else {
+		operationSuMoneyService = value
+	}
+
+	// 用户DAO初始化
+	var employeeDao *dao.EmployeeDao
+	if value, err := factory.CreateEmployeeDao(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	} else {
+		employeeDao = value
+	}
+
+	// 获取兑换清单员工
+	personFound, err := exchangeCashPersonListRepository.FindOne(map[string]interface{}{"listId": updateExchangeCashPersonCommand.ListId})
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if personFound == nil {
+		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateExchangeCashPersonCommand.ListId)))
+	}
+
+	// 获取兑换清单员工已兑换素币
+	personFoundExchangedSuMoney := personFound.ExchangedSuMoney
+
+	// 获取相关兑换活动
+	activityFound, err := exchangeCashActivityRepository.FindOne(map[string]interface{}{"activityId": personFound.ExchangeCashActivityId})
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if activityFound == nil {
+		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(personFound.ExchangeCashActivityId)))
+	}
+
+	// 更新兑换清单，个人已兑换现金计算
+	updateExchangeCashPersonCommand.ExchangedCash = updateExchangeCashPersonCommand.ExchangedSuMoney * activityFound.Rate
+
+	// 更新兑换素币清单
+	if err := personFound.Update(tool_funs.SimpleStructToMap(updateExchangeCashPersonCommand)); err != nil {
+		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+	}
+
+	// 保存兑换素币清单更新
+	personUpdated, err := exchangeCashPersonListRepository.Save(personFound)
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+
+	// 更新素币兑换活动命令
+	updateExchangeCashActivityCommand :=  &command.UpdateExchangeCashActivityCommand{
+		ExchangeCashActivityId: personFound.ExchangeCashActivityId,
+		ExchangedSuMoney:       activityFound.ExchangedSuMoney + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney),
+		ExchangedCash:          activityFound.ExchangedCash + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityFound.Rate,
+		Deadline:               activityFound.Deadline,
+		CountDown:              activityFound.CountDown,
+		ExchangeRate:           activityFound.Rate,
+	}
+
+	// 操作素币服务以及生成素币兑换流水记录命令
+	operationSuMoneyCommand := &command.OperationSuMoneyCommand{
+		Uid:                  personFound.EmployeeInfo.Uid,
+		Operator:             updateExchangeCashPersonCommand.Operator,
+		SuMoney:              0,
+		OperationType:        0,
+		OperationDescription: activityFound.ExchangeActivityName + "调整",
+	}
+
+	// 判断操作素币类型
+	if updateExchangeCashPersonCommand.ExchangedSuMoney > personFoundExchangedSuMoney {   // 追加素币兑换
+		operationSuMoneyCommand.SuMoney = math.Abs(updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney)
+		operationSuMoneyCommand.OperationType = 4
+	} else {  // 撤回素币兑换
+		operationSuMoneyCommand.SuMoney = math.Abs(updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney)
+		operationSuMoneyCommand.OperationType = 41
+	}
+
+	// 操作素币并生成素币流水
+	task, err := operationSuMoneyService.Operation(operationSuMoneyCommand.Uid, operationSuMoneyCommand.Operator, operationSuMoneyCommand.SuMoney, operationSuMoneyCommand.OperationType, operationSuMoneyCommand.OperationDescription)
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if task == nil {
+		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(operationSuMoneyCommand.Uid)))
+	}
+
+	// 更新兑换活动
+	if err := activityFound.Update(tool_funs.SimpleStructToMap(updateExchangeCashActivityCommand)); err != nil {
+		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+	}
+
+	// 保存兑换活动更新
+	activityUpdated, err := exchangeCashActivityRepository.Save(activityFound)
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if activityUpdated == nil {
+		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateExchangeCashActivityCommand.ExchangeCashActivityId)))
+	}
+
+	// 统计平台素币兑换状况
+	systemSuMoneyStatistics, err := employeeDao.CalculateSystemSuMoney(activityUpdated.CompanyId)
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if systemSuMoneyStatistics == nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "无效的公司")
+	}
+	systemExchangedSuMoney := systemSuMoneyStatistics["systemExchangedSuMoney"].(float64)
+	systemUnExchangeSuMoney := systemSuMoneyStatistics["systemUnExchangeSuMoney"].(float64)
+
+	// 获取当前现金池
+	_, cashPoolsFound, err := cashPoolRepository.Find(map[string]interface{}{
+		"companyId": activityUpdated.CompanyId,
+	})
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if cashPoolsFound == nil {
+		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(activityFound.CompanyId)))
+	}
+
+	// 判断是否超过平台未兑换现金
+	if activityUpdated.ExchangedSuMoney * activityUpdated.Rate > cashPoolsFound[0].UnExchangeCash {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已超过投入现金池的未兑换现金")
+	}
+
+	systemExchangedCash := cashPoolsFound[0].ExchangedCash + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityUpdated.Rate
+	//systemExchangedSuMoney := cashPoolsFound[0].ExchangedSuMoney + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney)
+
+	// 计算现金池平均兑换汇率
+	var newRate float64
+	if systemExchangedSuMoney == 0 {
+		newRate = 0
+	} else {
+		newRate = systemExchangedCash / systemExchangedSuMoney
+	}
+
+	// 更新现金池命令
+	updateCashPoolCommand := &command.UpdateCashPoolCommand{
+		CashPoolId:        cashPoolsFound[0].CashPoolId,
+		Cash: 	           cashPoolsFound[0].Cash,
+		ExchangedCash:     systemExchangedCash,
+		UnExchangeCash:    cashPoolsFound[0].UnExchangeCash - (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityUpdated.Rate,
+		Rate:              newRate,
+		ExchangedSuMoney:  systemExchangedSuMoney,
+		UnExchangeSuMoney: systemUnExchangeSuMoney,
+		LastRate: 		   cashPoolsFound[0].LastRate,
+	}
+
+	// 更新现金池
+	if err := cashPoolsFound[0].Update(tool_funs.SimpleStructToMap(updateCashPoolCommand)); err != nil {
+		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+	}
+
+	// 保存现金池更新
+	cashPoolUpdated, err := cashPoolRepository.Save(cashPoolsFound[0])
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if cashPoolUpdated == nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+
+	if err := transactionContext.CommitTransaction(); err != nil {
+		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+	}
+
+	return personUpdated, nil
+}
+
+
 // 新增导入兑换素币清单
 func (cashPoolService *CashPoolService) ImportCreateExchangeCashPerson(createExchangeCashPersonCommand *command.CreateExchangeCashPersonCommand) (interface{}, error) {
 	if err := createExchangeCashPersonCommand.ValidateCommand(); err != nil {
@@ -979,155 +1203,274 @@ func (cashPoolService *CashPoolService) ImportCreateExchangeCashPerson(createExc
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
-
-	// 更新兑换素币清单命令
-	updateExchangeCashPersonCommand := command.UpdateExchangeCashPersonCommand{
-		ListId:  peopleFound[0].ListId,
-		ExchangedSuMoney: peopleFound[0].ExchangedSuMoney,
-		ExchangedCash:    peopleFound[0].ExchangedCash,
-	}
-	
 	if count > 0 {  // 追加素币兑换或撤回素币兑换
-		operationSuMoneyCommand := &command.OperationSuMoneyCommand{
-			Uid:                  employeeFound.EmployeeInfo.Uid,
-			Operator:             createExchangeCashPersonCommand.Operator,
-			SuMoney:              createExchangeCashPersonCommand.ExchangedSuMoney,
-			OperationType:        4,
-			OperationDescription: "素币兑换现金",
-		}
+		// 获取兑换清单员工已兑换素币
+		personFoundExchangedSuMoney := peopleFound[0].ExchangedSuMoney
+
 		if createExchangeCashPersonCommand.ExchangedSuMoney < peopleFound[0].ExchangedSuMoney {  // 当前兑换的素币小于已兑换素币，撤回兑换素币
-			//suMoneyDecrement := peopleFound[0].ExchangedSuMoney - createExchangeCashPersonCommand.ExchangedSuMoney  // 减量
+			// 减量
+			suMoneyDecrement := peopleFound[0].ExchangedSuMoney - createExchangeCashPersonCommand.ExchangedSuMoney
+
 			// 更新兑换素币清单命令
+			updateExchangeCashPersonCommand := command.UpdateExchangeCashPersonCommand{
+				ListId:  peopleFound[0].ListId,
+				ExchangedSuMoney: personFoundExchangedSuMoney - suMoneyDecrement,
+				ExchangedCash:    (personFoundExchangedSuMoney - suMoneyDecrement) * activityFound.Rate,
+			}
 
-			// 操作素币命令
-			operationSuMoneyCommand.OperationType = domain.SU_MONEY_TRANSACTION_RECORD_TYPE_EXCHANGE_CASH_RESTORE
-			operationSuMoneyCommand.OperationDescription = ""
+			// 更新兑换素币清单
+			if err := peopleFound[0].Update(tool_funs.SimpleStructToMap(updateExchangeCashPersonCommand)); err != nil {
+				return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+			}
 
-		} else if createExchangeCashPersonCommand.ExchangedSuMoney > peopleFound[0].ExchangedSuMoney {   // 当前兑换素币大于已兑换素币，追加兑换素币
-			//suMoneyIncrement := createExchangeCashPersonCommand.ExchangedSuMoney - peopleFound[0].ExchangedSuMoney  // 增量
-			// 更新兑换素币清单命令
+			// 保存兑换素币清单更新
+			personUpdated, err := exchangeCashPersonListRepository.Save(peopleFound[0])
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+
+			// 更新素币兑换活动命令
+			updateExchangeCashActivityCommand :=  &command.UpdateExchangeCashActivityCommand{
+				ExchangeCashActivityId: peopleFound[0].ExchangeCashActivityId,
+				ExchangedSuMoney:       activityFound.ExchangedSuMoney + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney),
+				ExchangedCash:          activityFound.ExchangedCash + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityFound.Rate,
+				Deadline:               activityFound.Deadline,
+				CountDown:              activityFound.CountDown,
+				ExchangeRate:           activityFound.Rate,
+			}
+
+			// 更新兑换活动
+			if err := activityFound.Update(tool_funs.SimpleStructToMap(updateExchangeCashActivityCommand)); err != nil {
+				return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+			}
+
+			// 保存兑换现金活动更新
+			activityUpdated, err := exchangeCashActivityRepository.Save(activityFound)
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if activityUpdated == nil {
+				return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(createExchangeCashPersonCommand.ExchangeCashActivityId)))
+			}
 
 			// 操作素币命令
-			operationSuMoneyCommand.OperationType = domain.SU_MONEY_TRANSACTION_RECORD_TYPE_EXCHANGE_CASH
-			operationSuMoneyCommand.OperationDescription = ""
+			operationSuMoneyCommand := &command.OperationSuMoneyCommand{
+				Uid:                  employeeFound.EmployeeInfo.Uid,
+				Operator:             createExchangeCashPersonCommand.Operator,
+				SuMoney:              createExchangeCashPersonCommand.ExchangedSuMoney,
+				OperationType:        domain.SU_MONEY_TRANSACTION_RECORD_TYPE_EXCHANGE_CASH_RESTORE,
+				OperationDescription: activityFound.ExchangeActivityName + "调整",
+			}
 
+			// 操作素币，生成素币流水
+			task, err := operationSuMoneyService.Operation(operationSuMoneyCommand.Uid, operationSuMoneyCommand.Operator, operationSuMoneyCommand.SuMoney, operationSuMoneyCommand.OperationType, operationSuMoneyCommand.OperationDescription)
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if task == nil {
+				return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(operationSuMoneyCommand.Uid)))
+			}
 
-		}
-		// 更新兑换素币清单
-		if err := peopleFound[0].Update(tool_funs.SimpleStructToMap(updateExchangeCashPersonCommand)); err != nil {
-			return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-		}
+			// 获取当前现金池
+			_, cashPoolsFound, err := cashPoolRepository.Find(map[string]interface{}{
+				"companyId": activityFound.CompanyId,
+			})
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if len(cashPoolsFound) == 0 {
+				return nil, application.ThrowError(application.RES_NO_FIND_ERROR, "当前现金池为空，请先投入现金")
+			}
 
-		// 保存兑换素币清单更新
-		personUpdated, err := exchangeCashPersonListRepository.Save(peopleFound[0])
-		if err != nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-		}
+			// 判断兑换活动的现金是否超过现金池未兑换现金
+			if activityUpdated.ExchangedSuMoney * updateExchangeCashActivityCommand.ExchangeRate > cashPoolsFound[0].UnExchangeCash {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已超过现金池未兑换现金")
+			}
 
-		// 操作素币，生成素币流水
-		task, err := operationSuMoneyService.Operation(operationSuMoneyCommand.Uid, operationSuMoneyCommand.Operator, operationSuMoneyCommand.SuMoney, operationSuMoneyCommand.OperationType, operationSuMoneyCommand.OperationDescription)
-		if err != nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-		}
-		if task == nil {
-			return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(operationSuMoneyCommand.Uid)))
-		}
+			// 获取平台素币兑换情况
+			systemSuMoneyStatistics, err := employeeDao.CalculateSystemSuMoney(activityFound.CompanyId)
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if systemSuMoneyStatistics == nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "无效的公司")
+			}
+			systemExchangedSuMoney := systemSuMoneyStatistics["systemExchangedSuMoney"].(float64)
+			systemUnExchangeSuMoney := systemSuMoneyStatistics["systemUnExchangeSuMoney"].(float64)
 
-		// 更新兑换活动命令
-		updateExchangeCashActivityCommand :=  &command.UpdateExchangeCashActivityCommand{
-			ExchangeCashActivityId: personUpdated.ExchangeCashActivityId,
-			ExchangeActivityName:   activityFound.ExchangeActivityName,
-			ExchangedSuMoney:       activityFound.ExchangedSuMoney + createExchangeCashPersonCommand.ExchangedSuMoney,
-			ExchangedCash:          activityFound.ExchangedCash + createExchangeCashPersonCommand.ExchangedSuMoney * activityFound.Rate,
-			Deadline:               activityFound.Deadline,
-			CountDown:              activityFound.CountDown,
-			ExchangeRate:           activityFound.Rate,
-		}
+			// 计算平均兑换汇率
+			var newRate float64
+			if systemExchangedSuMoney == 0 {
+				newRate = 0
+			} else {
+				newRate = (cashPoolsFound[0].ExchangedCash + personUpdated.ExchangedCash) / systemExchangedSuMoney
+			}
 
-		// 更新兑换活动
-		if err := activityFound.Update(tool_funs.SimpleStructToMap(updateExchangeCashActivityCommand)); err != nil {
-			return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-		}
+			// 更新现金池命令
+			updateCashPoolCommand := &command.UpdateCashPoolCommand{
+				CashPoolId:        cashPoolsFound[0].CashPoolId,
+				Cash:              cashPoolsFound[0].Cash,
+				ExchangedCash:     cashPoolsFound[0].ExchangedCash + personUpdated.ExchangedCash,
+				UnExchangeCash:    cashPoolsFound[0].UnExchangeCash - personUpdated.ExchangedCash,
+				ExchangedSuMoney:  systemExchangedSuMoney,
+				UnExchangeSuMoney: systemUnExchangeSuMoney,
+				Rate:              newRate,
+				LastRate: 		   cashPoolsFound[0].LastRate,
+			}
 
-		// 保存兑换现金活动更新
-		activityUpdated, err := exchangeCashActivityRepository.Save(activityFound)
-		if err != nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-		}
-		if activityUpdated == nil {
-			return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(createExchangeCashPersonCommand.ExchangeCashActivityId)))
-		}
+			// 更新现金池
+			if err := cashPoolsFound[0].Update(tool_funs.SimpleStructToMap(updateCashPoolCommand)); err != nil {
+				return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+			}
 
-		// 获取当前现金池
-		_, cashPoolsFound, err := cashPoolRepository.Find(map[string]interface{}{
-			"companyId": activityFound.CompanyId,
-		})
-		if err != nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-		}
-		if len(cashPoolsFound) == 0 {
-			return nil, application.ThrowError(application.RES_NO_FIND_ERROR, "当前现金池为空，请先投入现金")
-		}
+			// 保存现金池更新
+			cashPoolUpdated, err := cashPoolRepository.Save(cashPoolsFound[0])
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if cashPoolUpdated == nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
 
-		// 判断兑换活动的现金是否超过现金池未兑换现金
-		if activityUpdated.ExchangedSuMoney * updateExchangeCashActivityCommand.ExchangeRate > cashPoolsFound[0].UnExchangeCash {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已超过现金池未兑换现金")
-		}
+			if err := transactionContext.CommitTransaction(); err != nil {
+				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+			}
 
-		// 获取平台素币兑换情况
-		systemSuMoneyStatistics, err := employeeDao.CalculateSystemSuMoney(activityFound.CompanyId)
-		if err != nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-		}
-		if systemSuMoneyStatistics == nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "无效的公司")
-		}
-		systemExchangedSuMoney := systemSuMoneyStatistics["systemExchangedSuMoney"].(float64)
-		systemUnExchangeSuMoney := systemSuMoneyStatistics["systemUnExchangeSuMoney"].(float64)
+			return personUpdated, nil
+		} else if createExchangeCashPersonCommand.ExchangedSuMoney > peopleFound[0].ExchangedSuMoney {   // 当前兑换素币大于已兑换素币，追加兑换素币
+			// 增量
+			suMoneyIncrement := createExchangeCashPersonCommand.ExchangedSuMoney - peopleFound[0].ExchangedSuMoney
 
-		// 计算平均兑换汇率
-		var newRate float64
-		if systemExchangedSuMoney == 0 {
-			newRate = 0
-		} else {
-			newRate = (cashPoolsFound[0].ExchangedCash + personUpdated.ExchangedCash) / systemExchangedSuMoney
-		}
+			// 更新兑换素币清单命令
+			updateExchangeCashPersonCommand := command.UpdateExchangeCashPersonCommand{
+				ListId:  peopleFound[0].ListId,
+				ExchangedSuMoney: personFoundExchangedSuMoney + suMoneyIncrement,
+				ExchangedCash:    (personFoundExchangedSuMoney + suMoneyIncrement) * activityFound.Rate,
+			}
 
-		// 更新现金池命令
-		updateCashPoolCommand := &command.UpdateCashPoolCommand{
-			CashPoolId:        cashPoolsFound[0].CashPoolId,
-			Cash:              cashPoolsFound[0].Cash,
-			ExchangedCash:     cashPoolsFound[0].ExchangedCash + personUpdated.ExchangedCash,
-			UnExchangeCash:    cashPoolsFound[0].UnExchangeCash - personUpdated.ExchangedCash,
-			ExchangedSuMoney:  systemExchangedSuMoney,
-			UnExchangeSuMoney: systemUnExchangeSuMoney,
-			Rate:              newRate,
-			LastRate: 		   cashPoolsFound[0].LastRate,
-		}
+			// 更新兑换素币清单
+			if err := peopleFound[0].Update(tool_funs.SimpleStructToMap(updateExchangeCashPersonCommand)); err != nil {
+				return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+			}
+
+			// 保存兑换素币清单更新
+			personUpdated, err := exchangeCashPersonListRepository.Save(peopleFound[0])
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+
+			// 更新素币兑换活动命令
+			updateExchangeCashActivityCommand :=  &command.UpdateExchangeCashActivityCommand{
+				ExchangeCashActivityId: peopleFound[0].ExchangeCashActivityId,
+				ExchangedSuMoney:       activityFound.ExchangedSuMoney + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney),
+				ExchangedCash:          activityFound.ExchangedCash + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityFound.Rate,
+				Deadline:               activityFound.Deadline,
+				CountDown:              activityFound.CountDown,
+				ExchangeRate:           activityFound.Rate,
+			}
+
+			// 更新兑换活动
+			if err := activityFound.Update(tool_funs.SimpleStructToMap(updateExchangeCashActivityCommand)); err != nil {
+				return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+			}
+
+			// 保存兑换现金活动更新
+			activityUpdated, err := exchangeCashActivityRepository.Save(activityFound)
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if activityUpdated == nil {
+				return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(createExchangeCashPersonCommand.ExchangeCashActivityId)))
+			}
+
+			// 操作素币命令
+			operationSuMoneyCommand := &command.OperationSuMoneyCommand{
+				Uid:                  employeeFound.EmployeeInfo.Uid,
+				Operator:             createExchangeCashPersonCommand.Operator,
+				SuMoney:              createExchangeCashPersonCommand.ExchangedSuMoney,
+				OperationType:        domain.SU_MONEY_TRANSACTION_RECORD_TYPE_EXCHANGE_CASH_RESTORE,
+				OperationDescription: activityFound.ExchangeActivityName + "调整",
+			}
+
+			// 操作素币，生成素币流水
+			task, err := operationSuMoneyService.Operation(operationSuMoneyCommand.Uid, operationSuMoneyCommand.Operator, operationSuMoneyCommand.SuMoney, operationSuMoneyCommand.OperationType, operationSuMoneyCommand.OperationDescription)
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if task == nil {
+				return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(operationSuMoneyCommand.Uid)))
+			}
+
+			// 获取当前现金池
+			_, cashPoolsFound, err := cashPoolRepository.Find(map[string]interface{}{
+				"companyId": activityFound.CompanyId,
+			})
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if len(cashPoolsFound) == 0 {
+				return nil, application.ThrowError(application.RES_NO_FIND_ERROR, "当前现金池为空，请先投入现金")
+			}
+
+			// 判断兑换活动的现金是否超过现金池未兑换现金
+			if activityUpdated.ExchangedSuMoney * updateExchangeCashActivityCommand.ExchangeRate > cashPoolsFound[0].UnExchangeCash {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已超过现金池未兑换现金")
+			}
+
+			// 获取平台素币兑换情况
+			systemSuMoneyStatistics, err := employeeDao.CalculateSystemSuMoney(activityFound.CompanyId)
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if systemSuMoneyStatistics == nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "无效的公司")
+			}
+			systemExchangedSuMoney := systemSuMoneyStatistics["systemExchangedSuMoney"].(float64)
+			systemUnExchangeSuMoney := systemSuMoneyStatistics["systemUnExchangeSuMoney"].(float64)
 
-		// 更新现金池
-		if err := cashPoolsFound[0].Update(tool_funs.SimpleStructToMap(updateCashPoolCommand)); err != nil {
-			return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-		}
+			// 计算平均兑换汇率
+			var newRate float64
+			if systemExchangedSuMoney == 0 {
+				newRate = 0
+			} else {
+				newRate = (cashPoolsFound[0].ExchangedCash + personUpdated.ExchangedCash) / systemExchangedSuMoney
+			}
 
-		// 保存现金池更新
-		cashPoolUpdated, err := cashPoolRepository.Save(cashPoolsFound[0])
-		if err != nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-		}
-		if cashPoolUpdated == nil {
-			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-		}
+			// 更新现金池命令
+			updateCashPoolCommand := &command.UpdateCashPoolCommand{
+				CashPoolId:        cashPoolsFound[0].CashPoolId,
+				Cash:              cashPoolsFound[0].Cash,
+				ExchangedCash:     cashPoolsFound[0].ExchangedCash + personUpdated.ExchangedCash,
+				UnExchangeCash:    cashPoolsFound[0].UnExchangeCash - personUpdated.ExchangedCash,
+				ExchangedSuMoney:  systemExchangedSuMoney,
+				UnExchangeSuMoney: systemUnExchangeSuMoney,
+				Rate:              newRate,
+				LastRate: 		   cashPoolsFound[0].LastRate,
+			}
 
-		if err := transactionContext.CommitTransaction(); err != nil {
-			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+			// 更新现金池
+			if err := cashPoolsFound[0].Update(tool_funs.SimpleStructToMap(updateCashPoolCommand)); err != nil {
+				return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
+			}
+
+			// 保存现金池更新
+			cashPoolUpdated, err := cashPoolRepository.Save(cashPoolsFound[0])
+			if err != nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+			if cashPoolUpdated == nil {
+				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+			}
+
+			if err := transactionContext.CommitTransaction(); err != nil {
+				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+			}
+
+			return personUpdated, nil
 		}
-		return nil, nil
 	} else if count == 0 {  // 新增
-		// 新增兑换清单命令
-		newPersonExchangedCash, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", createExchangeCashPersonCommand.ExchangedSuMoney * activityFound.Rate), 64)
-
 		// 新增兑换素币清单命令
+		newPersonExchangedCash, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", createExchangeCashPersonCommand.ExchangedSuMoney * activityFound.Rate), 64)
 		newPerson := &domain.ExchangeCashPersonList{
 			EmployeeInfo: &domain.EmployeeInfo{
 				Uid:             employeeFound.EmployeeInfo.Uid,
@@ -1612,248 +1955,6 @@ func (cashPoolService *CashPoolService) ListExchangeCashPerson(listExchangeCashP
 }
 
 // 更新兑换素币清单
-func (cashPoolService *CashPoolService) UpdateExchangeCashPerson(updateExchangeCashPersonCommand *command.UpdateExchangeCashPersonCommand) (interface{}, error) {
-	if err := updateExchangeCashPersonCommand.ValidateCommand(); err != nil {
-		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
-	}
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-
-	// 兑换素币清单仓储初始化
-	var exchangeCashPersonListRepository domain.ExchangeCashPersonListRepository
-	if value, err := factory.CreateExchangeCashPersonListRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		exchangeCashPersonListRepository = value
-	}
-
-	// 兑换现金活动仓储初始化
-	var exchangeCashActivityRepository domain.ExchangeActivityRepository
-	if value, err := factory.CreateExchangeCashActivityRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		exchangeCashActivityRepository = value
-	}
-
-	// 现金池仓储初始化
-	var cashPoolRepository domain.CashPoolRepository
-	if value, err  := factory.CreateCashPoolRepository(map[string] interface{} {
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		cashPoolRepository = value
-	}
-
-	// 操作素币服务初始化
-	var operationSuMoneyService service.OperationSuMoneyService
-	if value, err := factory.CreateOperationSuMoneyService(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		operationSuMoneyService = value
-	}
-
-	// 用户DAO初始化
-	var employeeDao *dao.EmployeeDao
-	if value, err := factory.CreateEmployeeDao(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	} else {
-		employeeDao = value
-	}
-
-	// 获取兑换清单员工
-	personFound, err := exchangeCashPersonListRepository.FindOne(map[string]interface{}{"listId": updateExchangeCashPersonCommand.ListId})
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	if personFound == nil {
-		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateExchangeCashPersonCommand.ListId)))
-	}
-
-	// 获取兑换清单员工已兑换素币
-	personFoundExchangedSuMoney := personFound.ExchangedSuMoney
-
-	// 获取相关兑换活动
-	activityFound, err := exchangeCashActivityRepository.FindOne(map[string]interface{}{"activityId": personFound.ExchangeCashActivityId})
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	if activityFound == nil {
-		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(personFound.ExchangeCashActivityId)))
-	}
-
-	// 更新兑换清单，个人已兑换现金计算
-	updateExchangeCashPersonCommand.ExchangedCash = updateExchangeCashPersonCommand.ExchangedSuMoney * activityFound.Rate
-
-	// 更新兑换素币清单
-	if err := personFound.Update(tool_funs.SimpleStructToMap(updateExchangeCashPersonCommand)); err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-
-	// 保存兑换素币清单更新
-	personUpdated, err := exchangeCashPersonListRepository.Save(personFound)
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-
-	// 更新素币兑换活动命令
-	updateExchangeCashActivityCommand :=  &command.UpdateExchangeCashActivityCommand{
-		ExchangeCashActivityId: personFound.ExchangeCashActivityId,
-		ExchangedSuMoney:       activityFound.ExchangedSuMoney + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney),
-		ExchangedCash:          activityFound.ExchangedCash + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityFound.Rate,
-		Deadline:               activityFound.Deadline,
-		CountDown:              activityFound.CountDown,
-		ExchangeRate:           activityFound.Rate,
-	}
-
-	// 操作素币服务以及生成素币兑换流水记录命令
-	operationSuMoneyCommand := &command.OperationSuMoneyCommand{
-		Uid:                  personFound.EmployeeInfo.Uid,
-		Operator:             updateExchangeCashPersonCommand.Operator,
-		SuMoney:              0,
-		OperationType:        0,
-		OperationDescription: activityFound.ExchangeActivityName + "调整",
-	}
-
-	// 判断操作素币类型
-	if updateExchangeCashPersonCommand.ExchangedSuMoney > personFoundExchangedSuMoney {   // 追加素币兑换
-		operationSuMoneyCommand.SuMoney = math.Abs(updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney)
-		operationSuMoneyCommand.OperationType = 4
-	} else {  // 撤回素币兑换
-		operationSuMoneyCommand.SuMoney = math.Abs(updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney)
-		operationSuMoneyCommand.OperationType = 41
-	}
-
-	// 操作素币并生成素币流水
-	task, err := operationSuMoneyService.Operation(operationSuMoneyCommand.Uid, operationSuMoneyCommand.Operator, operationSuMoneyCommand.SuMoney, operationSuMoneyCommand.OperationType, operationSuMoneyCommand.OperationDescription)
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	if task == nil {
-		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(operationSuMoneyCommand.Uid)))
-	}
-
-	// 更新兑换活动
-	if err := activityFound.Update(tool_funs.SimpleStructToMap(updateExchangeCashActivityCommand)); err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-
-	// 保存兑换活动更新
-	activityUpdated, err := exchangeCashActivityRepository.Save(activityFound)
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	if activityUpdated == nil {
-		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateExchangeCashActivityCommand.ExchangeCashActivityId)))
-	}
-
-	//// 统计活动已兑换素币
-	//activitySuMoneyStatistics, err := cashPoolDao.CalculateActivityExchangedSuMoney(activityUpdated.ActivityId)
-	//if err != nil {
-	//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	//}
-	//if activitySuMoneyStatistics == nil {
-	//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "无效的公司")
-	//}
-	//activitySuMoney := activitySuMoneyStatistics["activityExchangedSuMoney"].(float64)
-
-	//// 统计平台现金兑换情况
-	//systemCashStatistics, err := employeeDao.CalculateSystemCash(activityUpdated.CompanyId)
-	//if err != nil {
-	//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	//}
-	//if systemCashStatistics == nil {
-	//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "无效的公司")
-	//}
-	////systemExchangedCash := systemCashStatistics["systemExchangedCash"].(float64)
-	//systemUnExchangeCash := systemCashStatistics["systemUnExchangeCash"].(float64)
-
-	// 统计平台素币兑换状况
-	systemSuMoneyStatistics, err := employeeDao.CalculateSystemSuMoney(activityUpdated.CompanyId)
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	if systemSuMoneyStatistics == nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "无效的公司")
-	}
-	systemExchangedSuMoney := systemSuMoneyStatistics["systemExchangedSuMoney"].(float64)
-	systemUnExchangeSuMoney := systemSuMoneyStatistics["systemUnExchangeSuMoney"].(float64)
-
-	// 获取当前现金池
-	_, cashPoolsFound, err := cashPoolRepository.Find(map[string]interface{}{
-		"companyId": activityUpdated.CompanyId,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	if cashPoolsFound == nil {
-		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(activityFound.CompanyId)))
-	}
-
-	// 判断是否超过平台未兑换现金
-	if activityUpdated.ExchangedSuMoney * activityUpdated.Rate > cashPoolsFound[0].UnExchangeCash {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已超过投入现金池的未兑换现金")
-	}
-
-	systemExchangedCash := cashPoolsFound[0].ExchangedCash + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityUpdated.Rate
-	//systemExchangedSuMoney := cashPoolsFound[0].ExchangedSuMoney + (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney)
-
-	// 计算现金池平均兑换汇率
-	var newRate float64
-	if systemExchangedSuMoney == 0 {
-		newRate = 0
-	} else {
-		newRate = systemExchangedCash / systemExchangedSuMoney
-	}
-
-	// 更新现金池命令
-	updateCashPoolCommand := &command.UpdateCashPoolCommand{
-		CashPoolId:        cashPoolsFound[0].CashPoolId,
-		Cash: 	           cashPoolsFound[0].Cash,
-		ExchangedCash:     systemExchangedCash,
-		UnExchangeCash:    cashPoolsFound[0].UnExchangeCash - (updateExchangeCashPersonCommand.ExchangedSuMoney - personFoundExchangedSuMoney) * activityUpdated.Rate,
-		Rate:              newRate,
-		ExchangedSuMoney:  systemExchangedSuMoney,
-		UnExchangeSuMoney: systemUnExchangeSuMoney,
-		LastRate: 		   cashPoolsFound[0].LastRate,
-	}
-
-	// 更新现金池
-	if err := cashPoolsFound[0].Update(tool_funs.SimpleStructToMap(updateCashPoolCommand)); err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-
-	// 保存现金池更新
-	cashPoolUpdated, err := cashPoolRepository.Save(cashPoolsFound[0])
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	if cashPoolUpdated == nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-
-	if err := transactionContext.CommitTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-
-	return personUpdated, nil
-}
 
 // 移除兑换素币清单
 func (cashPoolService *CashPoolService) RemoveExchangeCashPerson(removeExchangeCashPersonCommand *command.RemoveExchangeCashPersonCommand) (interface{}, error) {