package service

import (
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"github.com/shopspring/decimal"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/dividendsEstimate/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/dividendsEstimate/dto"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/dividendsEstimate/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/event/subscriber"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain/service"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/utils"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/log"
	"strconv"
	"time"
)

// DividendsEstimateService 分红预算服务
type DividendsEstimateService struct {
}

// ListDividendsIncentivesEstimate 返回业绩激励分红预算信息列表
func (dividendsEstimateService *DividendsEstimateService) ListDividendsIncentivesEstimate(listDividendsIncentivesEstimateQuery *query.ListDividendsIncentivesEstimateQuery) (interface{}, error) {
	if err := listDividendsIncentivesEstimateQuery.ValidateQuery(); 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 dividendsOrderRepository domain.DividendsOrderRepository
	if value, err := factory.CreateDividendsOrderRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsOrderRepository = value
	}
	// 分红退货单仓储初始化
	var dividendsReturnedOrderRepository domain.DividendsReturnedOrderRepository
	if value, err := factory.CreateDividendsReturnedOrderRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsReturnedOrderRepository = value
	}

	// 订单产品仓储初始化
	var orderGoodRepository domain.OrderGoodRepository
	if value, err := factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		orderGoodRepository = value
	}

	// 获取订单产品
	listDividendsIncentivesEstimateQuery.OrderGoodDividendsStatus = int32(1)
	if count, orderGoods, err := orderGoodRepository.Find(tool_funs.SimpleStructToMap(listDividendsIncentivesEstimateQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		var dividendsIncentivesEstimateDtos []*dto.DividendsIncentivesEstimateDto
		for _, orderGood := range orderGoods {
			dividendsIncentivesEstimateDto := &dto.DividendsIncentivesEstimateDto{}
			if orderGood.DividendsOrderNumber != "" { // 查询分红订单
				dividendsOrder, err := dividendsOrderRepository.FindOne(map[string]interface{}{
					"dividendsOrderNumber": orderGood.DividendsOrderNumber,
					"companyId":            listDividendsIncentivesEstimateQuery.CompanyId,
					"orgId":                listDividendsIncentivesEstimateQuery.OrgId,
				})
				if err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				if dividendsOrder == nil {
					return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("分红订单%s不存在", orderGood.DividendsOrderNumber))
				}
				if err := dividendsIncentivesEstimateDto.LoadDto(orderGood, dividendsOrder.DividendsOrderNumber, dividendsOrder.DividendsOriginalOrderNum, dividendsOrder.CustomerName, dividendsOrder.Region.RegionName, dividendsOrder.OrderTime); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				dividendsIncentivesEstimateDtos = append(dividendsIncentivesEstimateDtos, dividendsIncentivesEstimateDto)
			} else if orderGood.DividendsReturnedOrderNumber != "" { // 查询分红退货单
				dividendsReturnedOrder, err := dividendsReturnedOrderRepository.FindOne(map[string]interface{}{
					"companyId":                    listDividendsIncentivesEstimateQuery.CompanyId,
					"orgId":                        listDividendsIncentivesEstimateQuery.OrgId,
					"dividendsReturnedOrderNumber": orderGood.DividendsReturnedOrderNumber,
				})
				if err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				if dividendsReturnedOrder == nil {
					return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("分红退货单%s不存在", orderGood.DividendsReturnedOrderNumber))
				}
				if err := dividendsIncentivesEstimateDto.LoadDto(orderGood, dividendsReturnedOrder.DividendsReturnedOrderNumber, dividendsReturnedOrder.OriginalOrderNum, dividendsReturnedOrder.DividendsReturnedCustomerName, dividendsReturnedOrder.Region.RegionName, dividendsReturnedOrder.OrderTime); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				dividendsIncentivesEstimateDtos = append(dividendsIncentivesEstimateDtos, dividendsIncentivesEstimateDto)
			}
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"total": count,
			"list":  dividendsIncentivesEstimateDtos,
		}, nil
	}
}

// ListMoneyIncentivesEstimate 返回金额激励分红预算信息列表
func (dividendsEstimateService *DividendsEstimateService) ListMoneyIncentivesEstimate(listMoneyIncentivesEstimateQuery *query.ListMoneyIncentivesEstimateQuery) (interface{}, error) {
	if err := listMoneyIncentivesEstimateQuery.ValidateQuery(); 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 cooperationContractRepository domain.CooperationContractRepository
	if value, err := factory.CreateCooperationContractRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationContractRepository = value
	}
	// 查找共创合约
	listMoneyIncentivesEstimateQuery.IncentivesType = 2
	if count, cooperationContracts, err := cooperationContractRepository.Find(tool_funs.SimpleStructToMap(listMoneyIncentivesEstimateQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		// 数据传输对象
		var moneyIncentivesEstimateDtos []*dto.MoneyIncentivesEstimateDto
		for _, cooperationContract := range cooperationContracts {
			moneyIncentivesEstimateDto := &dto.MoneyIncentivesEstimateDto{}
			if err := moneyIncentivesEstimateDto.LoadDto(cooperationContract, nil); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
			moneyIncentivesEstimateDtos = append(moneyIncentivesEstimateDtos, moneyIncentivesEstimateDto)
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"grid": map[string]interface{}{
				"total": count,
				"list":  moneyIncentivesEstimateDtos,
			},
		}, nil
	}
}

// CancelDividendsEstimate 取消分红预算单
func (dividendsEstimateService *DividendsEstimateService) CancelDividendsEstimate(cancelDividendsEstimateCommand *command.CancelDividendsEstimateCommand) (interface{}, error) {
	if err := cancelDividendsEstimateCommand.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 cancelDividendsEstimateService service.CancelDividendsEstimate
	if value, err := factory.CreateCancelDividendsEstimateService(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cancelDividendsEstimateService = value
	}

	// 用户REST服务初始化
	var userService service.UserService
	if value, err := factory.CreateUserService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		userService = value
	}

	// 获取操作人
	var operator *domain.User
	if data, err := userService.OperatorFrom(cancelDividendsEstimateCommand.CompanyId, cancelDividendsEstimateCommand.OrgId, cancelDividendsEstimateCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取操作人失败")
	} else {
		operator = data
	}

	// 分红预算仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}

	// 获取当前被取消的分红预算单
	dividendsEstimate, err := dividendsEstimateRepository.FindOne(map[string]interface{}{"dividendsEstimateId": cancelDividendsEstimateCommand.DividendsEstimateId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if dividendsEstimate == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(cancelDividendsEstimateCommand.DividendsEstimateId, 10)))
	}

	// 校验重复取消
	if dividendsEstimate.IsCanceled {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已取消的分红单不能重复取消")
	}

	// 校验是否能够取消
	if dividendsEstimate.DividendsType == domain.ORDER_DIVIDENDS || dividendsEstimate.DividendsType == domain.RETURN_WRITE_OFF { // 订单分红、退货冲销
		if count, dividendsEstimatesRelative, err2 := dividendsEstimateRepository.Find(map[string]interface{}{
			"orderOrReturnedOrderNum": dividendsEstimate.OrderOrReturnedOrderNum,
			"companyId":               dividendsEstimate.Company.CompanyId,
			"orgId":                   dividendsEstimate.Org.OrgId,
		}); err2 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err2.Error())
		} else {
			if count > 0 {
				for _, dividendsEstimateRelative := range dividendsEstimatesRelative {
					if dividendsEstimateRelative.DividendsAccountStatus == domain.ACCOUNTED {
						return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已有相关分红预算单已结算，无法取消")
					}
				}
			}
		}
	} else if dividendsEstimate.DividendsType == domain.MONEY_INCENTIVES { // 金额激励分红
		if count, dividendsEstimatesRelative, err3 := dividendsEstimateRepository.Find(map[string]interface{}{
			"cooperationContractNumber": dividendsEstimate.CooperationContractNumber,
			"companyId":                 dividendsEstimate.Company.CompanyId,
			"orgId":                     dividendsEstimate.Org.OrgId,
		}); err3 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err3.Error())
		} else {
			if count > 0 {
				for _, dividendsEstimateRelative := range dividendsEstimatesRelative {
					if dividendsEstimateRelative.DividendsAccountStatus == domain.ACCOUNTED {
						return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已有相关分红预算单已结算，无法取消")
					}
				}
			}
		}
	}

	// 取消分红预算
	if dividendsEstimatesCanceled, err := cancelDividendsEstimateService.CancelEstimate([]int64{cancelDividendsEstimateCommand.DividendsEstimateId}, operator); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return dividendsEstimatesCanceled[1], nil
	}
}

// BatchCancelDividendsEstimate 批量取消分红预算单
func (dividendsEstimateService *DividendsEstimateService) BatchCancelDividendsEstimate(batchCancelEstimateCommand *command.BatchCancelDividendsEstimateCommand) (interface{}, error) {
	if err := batchCancelEstimateCommand.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 cancelDividendsEstimateService service.CancelDividendsEstimate
	if value, err := factory.CreateCancelDividendsEstimateService(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cancelDividendsEstimateService = value
	}

	// 用户REST服务初始化
	var userService service.UserService
	if value, err := factory.CreateUserService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		userService = value
	}

	// 获取操作人
	var operator *domain.User
	if data, err := userService.OperatorFrom(batchCancelEstimateCommand.CompanyId, batchCancelEstimateCommand.OrgId, batchCancelEstimateCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取操作人失败")
	} else {
		operator = data
	}

	// 分红预算仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}

	// 分红预算ID类型转换
	dividendsEstimateIds, err := utils.SliceAtoi(batchCancelEstimateCommand.DividendsEstimateIds)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "分红预算单参数转换错误")
	}

	// 获取分红预算
	if count, dividendsEstimates, err := dividendsEstimateRepository.Find(map[string]interface{}{
		"dividendsEstimateIds": dividendsEstimateIds,
		"offsetLimit":          false,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			// 校验分红预算是否可以取消，已有相关分红预算单已结算，无法取消
			for _, dividendsEstimate := range dividendsEstimates {
				// 校验重复取消
				if dividendsEstimate.IsCanceled {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已取消的分红单不能重复取消")
				}

				// 校验是否能够取消
				if dividendsEstimate.DividendsType == domain.ORDER_DIVIDENDS || dividendsEstimate.DividendsType == domain.RETURN_WRITE_OFF { // 订单分红/退货冲销
					if countRelativeDividendsEstimates, dividendsEstimatesRelative, err2 := dividendsEstimateRepository.Find(map[string]interface{}{
						"companyId":                 dividendsEstimate.Company.CompanyId,
						"orgId":                     dividendsEstimate.Org.OrgId,
						"orderOrReturnedOrderNum":   dividendsEstimate.OrderOrReturnedOrderNum,
						"dividendsParticipateTypes": []int32{1, 2, 3},
						"cooperationContractNumber": dividendsEstimate.CooperationContractNumber,
						"offsetLimit":               false,
						"dividendsStage":            dividendsEstimate.DividendsStage,
						"dividendsTypes":            []int32{1, 2},
						"orderGoodId":               dividendsEstimate.OrderGoodId,
					}); err2 != nil {
						return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err2.Error())
					} else {
						if countRelativeDividendsEstimates > 0 {
							for _, dividendsEstimateRelative := range dividendsEstimatesRelative {
								if dividendsEstimateRelative.DividendsAccountStatus == domain.ACCOUNTED {
									return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已有相关分红预算单已结算，无法取消")
								}
							}
						}
					}
				} else if dividendsEstimate.DividendsType == domain.MONEY_INCENTIVES { // 金额激励分红
					if countRelativeDividendsEstimates, dividendsEstimatesRelative, err3 := dividendsEstimateRepository.Find(map[string]interface{}{
						"companyId":                       dividendsEstimate.Company.CompanyId,
						"orgId":                           dividendsEstimate.Org.OrgId,
						"cooperationContractNumber":       dividendsEstimate.CooperationContractNumber,
						"cooperationContractUndertakerId": dividendsEstimate.CooperationContractUndertakerId,
						"dividendsParticipateTypes":       []int32{1, 2, 3},
						"offsetLimit":                     false,
						"dividendsStage":                  dividendsEstimate.DividendsStage,
						"dividendsType":                   int32(3),
					}); err3 != nil {
						return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err3.Error())
					} else {
						if countRelativeDividendsEstimates > 0 {
							for _, dividendsEstimateRelative := range dividendsEstimatesRelative {
								if dividendsEstimateRelative.DividendsAccountStatus == domain.ACCOUNTED {
									return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "已有相关分红预算单已结算，无法取消")
								}
							}
						}
					}
				}
			}

			// 批量取消分红预算单
			if dividendsEstimatesCanceled, errCancel := cancelDividendsEstimateService.CancelEstimate(dividendsEstimateIds, operator); errCancel != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, errCancel.Error())
			} else {
				if errTx := transactionContext.CommitTransaction(); errTx != nil {
					return nil, application.ThrowError(application.TRANSACTION_ERROR, errTx.Error())
				}
				return dividendsEstimatesCanceled, nil
			}
		} else {
			return map[string]interface{}{}, nil
		}
	}
}

// CreateDividendsEstimate 创建分红预算单 (预留)
func (dividendsEstimateService *DividendsEstimateService) CreateDividendsEstimate(createDividendsEstimateCommand *command.CreateDividendsEstimateCommand) (interface{}, error) {
	if err := createDividendsEstimateCommand.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()
	}()

	// 公司REST服务初始化
	var companyService service.CompanyService
	if value, err := factory.CreateCompanyService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		companyService = value
	}

	// 获取公司信息
	var company *domain.Company
	if data, err := companyService.CompanyFrom(createDividendsEstimateCommand.CompanyId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		company = data
	}

	// 组织机构REST服务初始化
	var organizationService service.OrgService
	if value, err := factory.CreateOrganizationService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organizationService = value
	}

	// 获取组织机构信息
	var organization *domain.Org
	if data, err := organizationService.OrgFrom(createDividendsEstimateCommand.CompanyId, createDividendsEstimateCommand.OrgId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organization = data
	}

	// 用户REST服务初始化
	var userService service.UserService
	if value, err := factory.CreateUserService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		userService = value
	}

	// 获取操作人
	var operator *domain.User
	if data, err := userService.OperatorFrom(createDividendsEstimateCommand.CompanyId, createDividendsEstimateCommand.OrgId, createDividendsEstimateCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		operator = data
	}

	newDividendsEstimate := &domain.DividendsEstimate{
		DividendsEstimateId:          0,
		DividendsAccountStatus:       0,
		DividendsAmount:              0,
		DividendsEstimateOrderNumber: "",
		DividendsEstimateTime:        time.Time{},
		DividendsParticipateType:     0,
		DividendsType:                0,
		OrderOrReturnedOrderNum:      "",
		CooperationContractNumber:    "",
		DividendsUser:                nil,
		Org:                          organization,
		Company:                      company,
		Operator:                     operator,
		OperateTime:                  time.Time{},
		CreatedAt:                    time.Now(),
		DeletedAt:                    time.Time{},
		UpdatedAt:                    time.Time{},
	}

	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}
	if dividendsEstimate, err := dividendsEstimateRepository.Save(newDividendsEstimate); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return dividendsEstimate, nil
	}
}

// ConfirmDividendsIncentivesEstimate 确定业绩激励分红预算
func (dividendsEstimateService *DividendsEstimateService) ConfirmDividendsIncentivesEstimate(confirmDividendsIncentivesEstimateCommand *command.ConfirmDividendsIncentivesEstimateCommand) (interface{}, error) {
	start := time.Now()
	if err := confirmDividendsIncentivesEstimateCommand.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()
	}()

	// 订单产品ID类型转换
	orderGoodIds, err := utils.SliceAtoi(confirmDividendsIncentivesEstimateCommand.OrderGoodIds)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 公司REST服务初始化
	var companyService service.CompanyService
	if value, err := factory.CreateCompanyService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		companyService = value
	}

	// 获取公司信息
	startGetCompany := time.Now()
	var company *domain.Company
	if data, err := companyService.CompanyFrom(confirmDividendsIncentivesEstimateCommand.CompanyId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		company = data
	}
	fmt.Println("获取公司信息耗时：", time.Since(startGetCompany))

	// 组织机构REST服务初始化
	var organizationService service.OrgService
	if value, err := factory.CreateOrganizationService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organizationService = value
	}

	// 获取组织机构信息
	startGetOrg := time.Now()
	var organization *domain.Org
	if data, err := organizationService.OrgFrom(confirmDividendsIncentivesEstimateCommand.CompanyId, confirmDividendsIncentivesEstimateCommand.OrgId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organization = data
	}
	fmt.Println("获取组织机构数据耗时：", time.Since(startGetOrg))

	// 用户REST服务初始化
	var userService service.UserService
	if value, err := factory.CreateUserService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		userService = value
	}

	// 获取操作人
	startGetOperator := time.Now()
	var operator *domain.User
	if data, err := userService.OperatorFrom(confirmDividendsIncentivesEstimateCommand.CompanyId, confirmDividendsIncentivesEstimateCommand.OrgId, confirmDividendsIncentivesEstimateCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		operator = data
	}
	fmt.Println("获取操作人耗时：", time.Since(startGetOperator))

	// 订单产品仓储初始化
	var orderGoodRepository domain.OrderGoodRepository
	if value, err := factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		orderGoodRepository = value
	}

	// 分红预算仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}

	// 分红预算单DAO初始化
	var dividendsEstimateDao *dao.DividendsEstimateDao
	if value, err := factory.CreateDividendsEstimateDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		dividendsEstimateDao = value
	}

	// 分红订单仓储初始化
	var dividendsOrderRepository domain.DividendsOrderRepository
	if value, err := factory.CreateDividendsOrderRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsOrderRepository = value
	}

	// 分红退货单仓储初始化
	var dividendsReturnedOrderRepository domain.DividendsReturnedOrderRepository
	if value, err := factory.CreateDividendsReturnedOrderRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsReturnedOrderRepository = value
	}

	// 共创合约仓储初始化
	var cooperationContractRepository domain.CooperationContractRepository
	if value, err := factory.CreateCooperationContractRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationContractRepository = value
	}

	// 初始化确认业绩激励分红预算领域服务
	var confirmDividendsIncentivesEstimateService service.ConfirmDividendsIncentivesEstimateService
	if value, err := factory.CreateConfirmDividendsIncentivesEstimateService(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		confirmDividendsIncentivesEstimateService = value
		_ = confirmDividendsIncentivesEstimateService.Subscribe(&subscriber.DividendsEstimateSubscriber{
			TransactionContext: transactionContext.(*pgTransaction.TransactionContext),
		})
	}

	// 统计成功预算的分红订单
	estimateSuccessfullyDividendsOrders := make(map[string]string)

	// 统计预算失败的分红订单
	estimateFailedDividendsOrders := make(map[string]string)

	// 获取订单产品
	startGetOrderGoods := time.Now()
	if _, orderGoods, err := orderGoodRepository.Find(map[string]interface{}{
		"orderGoodIds": orderGoodIds,
		"offsetLimit":  false,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		fmt.Println("获取订单产品耗时：", time.Since(startGetOrderGoods))

		dividendsEstimates := make([]*domain.DividendsEstimate, 0)

		var cooperationContractNumbers []string

		// 获取订单产品合约编号
		for _, orderGood := range orderGoods {
			cooperationContractNumbers = append(cooperationContractNumbers, orderGood.CooperationContractNumber)
		}

		newCooperationContractNumbers := utils.RemoveDuplicationString(cooperationContractNumbers)

		cooperationContractsMap := make(map[string]*domain.CooperationContract, 0)

		// 查询共创合约
		startQueryContracts := time.Now()
		if len(newCooperationContractNumbers) > 0 {
			if count, cooperationContractsFound, err := cooperationContractRepository.Find(map[string]interface{}{
				"cooperationContractNumbers": newCooperationContractNumbers,
				"companyId":                  confirmDividendsIncentivesEstimateCommand.CompanyId,
				"orgId":                      confirmDividendsIncentivesEstimateCommand.OrgId,
				"offsetLimit":                false,
			}); err != nil {
				return nil, err
			} else {
				if count > 0 {
					for _, cooperationContractFound := range cooperationContractsFound {
						cooperationContractsMap[cooperationContractFound.CooperationContractNumber] = cooperationContractFound
					}
				}
			}
		} else {
			return map[string]interface{}{
				"report": fmt.Sprintf("已完成0单订单分红预算，生成0单分红预算，失败原因：产品未关联合约"),
			}, nil
		}
		fmt.Println("查询共创合约耗时：", time.Since(startQueryContracts))

		// 统计当前企业分红预算单数
		count, err := dividendsEstimateDao.CountDividendsEstimate(map[string]interface{}{
			"companyId": confirmDividendsIncentivesEstimateCommand.CompanyId,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}

		var countDividendsEstimate int64

		orderGoodsToConfirm := make([]*domain.OrderGood, 0)
		returnedOrderGoodsToConfirm := make([]*domain.OrderGood, 0)

		for _, orderGood := range orderGoods {
			if orderGood.DividendsOrderNumber != "" {
				orderGoodsToConfirm = append(orderGoodsToConfirm, orderGood)
			} else if orderGood.DividendsReturnedOrderNumber != "" {
				returnedOrderGoodsToConfirm = append(returnedOrderGoodsToConfirm, orderGood)
			}
		}

		startConfirm := time.Now()
		if len(orderGoodsToConfirm) > 0 { // 分红订单产品预算
			if dividendsEstimateDetails, err := confirmDividendsIncentivesEstimateService.Confirm(orderGoodsToConfirm, confirmDividendsIncentivesEstimateCommand.CompanyId, confirmDividendsIncentivesEstimateCommand.OrgId, cooperationContractsMap); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				for _, dividendsEstimateDetail := range dividendsEstimateDetails {
					if dividendsEstimateDetail.IsSuccessfully {
						//  生成分红预算单号
						dividendsEstimateOrderNumber, err := dividendsEstimateDetail.GenerateSpecificDividendsEstimateNumber(int64(count), countDividendsEstimate)
						if err != nil {
							return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
						}

						// 记录成功的订单号
						estimateSuccessfullyDividendsOrders[dividendsEstimateDetail.OrderOrReturnedOrderNumber] = dividendsEstimateDetail.OrderOrReturnedOrderNumber

						// 统计分红预算单数目
						countDividendsEstimate = countDividendsEstimate + 1

						dividendsEstimate := &domain.DividendsEstimate{
							DividendsEstimateId:             0,
							DividendsAccountStatus:          domain.TO_BE_ACCOUNT,
							DividendsAmount:                 dividendsEstimateDetail.DividendsAmount,
							DividendsEstimateOrderNumber:    dividendsEstimateOrderNumber,
							DividendsEstimateTime:           time.Now(),
							DividendsParticipateType:        dividendsEstimateDetail.DividendsParticipateType,
							DividendsType:                   domain.ORDER_DIVIDENDS,
							DividendsTypeName:               "订单分红",
							OrderOrReturnedOrderNum:         dividendsEstimateDetail.OrderOrReturnedOrderNumber,
							CooperationContractNumber:       dividendsEstimateDetail.CooperationContractNumber,
							DividendsUser:                   dividendsEstimateDetail.DividendsUser,
							DividendsPercentage:             dividendsEstimateDetail.DividendsPercentage,
							DividendsStage:                  dividendsEstimateDetail.DividendsStage,
							Org:                             organization,
							Company:                         company,
							Operator:                        operator,
							OperateTime:                     time.Time{},
							IsCanceled:                      false,
							CreatedAt:                       time.Now(),
							DeletedAt:                       time.Time{},
							UpdatedAt:                       time.Time{},
							OrderGoodId:                     dividendsEstimateDetail.OrderGoodId,
							OrderGoodAmount:                 dividendsEstimateDetail.OrderGoodAmount,
							PaymentStatus:                   int32(1),
							CooperationContractUndertakerId: dividendsEstimateDetail.CooperationContractUndertakerId,
						}

						dividendsEstimates = append(dividendsEstimates, dividendsEstimate)
					} else {
						// 记录失败的订单号和原因
						estimateFailedDividendsOrders[dividendsEstimateDetail.OrderOrReturnedOrderNumber] = dividendsEstimateDetail.Reason
					}
				}
			}
		} else if len(returnedOrderGoodsToConfirm) > 0 { // 退货单产品预算
			if dividendsReturnedEstimateDetails, err := confirmDividendsIncentivesEstimateService.Confirm(returnedOrderGoodsToConfirm, confirmDividendsIncentivesEstimateCommand.CompanyId, confirmDividendsIncentivesEstimateCommand.OrgId, cooperationContractsMap); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				for _, dividendsReturnedEstimateDetail := range dividendsReturnedEstimateDetails {
					if dividendsReturnedEstimateDetail.IsSuccessfully {
						//  生成分红预算单号
						dividendsEstimateOrderNumber, err := dividendsReturnedEstimateDetail.GenerateSpecificDividendsEstimateNumber(int64(count), countDividendsEstimate)
						if err != nil {
							return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
						}

						// 记录成功的退货单号
						estimateSuccessfullyDividendsOrders[dividendsReturnedEstimateDetail.OrderOrReturnedOrderNumber] = dividendsReturnedEstimateDetail.OrderOrReturnedOrderNumber

						// 统计生成的预算单数量
						countDividendsEstimate = countDividendsEstimate + 1

						dividendsEstimate := &domain.DividendsEstimate{
							DividendsEstimateId:             0,
							DividendsAccountStatus:          domain.TO_BE_ACCOUNT,
							DividendsAmount:                 dividendsReturnedEstimateDetail.DividendsAmount,
							DividendsEstimateOrderNumber:    dividendsEstimateOrderNumber,
							DividendsEstimateTime:           time.Now(),
							DividendsParticipateType:        dividendsReturnedEstimateDetail.DividendsParticipateType,
							DividendsType:                   domain.RETURN_WRITE_OFF,
							DividendsTypeName:               "退货冲销",
							OrderOrReturnedOrderNum:         dividendsReturnedEstimateDetail.OrderOrReturnedOrderNumber,
							CooperationContractNumber:       dividendsReturnedEstimateDetail.CooperationContractNumber,
							DividendsUser:                   dividendsReturnedEstimateDetail.DividendsUser,
							DividendsPercentage:             dividendsReturnedEstimateDetail.DividendsPercentage,
							DividendsStage:                  dividendsReturnedEstimateDetail.DividendsStage,
							Org:                             organization,
							Company:                         company,
							Operator:                        operator,
							OperateTime:                     time.Time{},
							IsCanceled:                      false,
							CreatedAt:                       time.Now(),
							DeletedAt:                       time.Time{},
							UpdatedAt:                       time.Time{},
							OrderGoodId:                     dividendsReturnedEstimateDetail.OrderGoodId,
							OrderGoodAmount:                 dividendsReturnedEstimateDetail.OrderGoodAmount,
							PaymentStatus:                   int32(1),
							CooperationContractUndertakerId: dividendsReturnedEstimateDetail.CooperationContractUndertakerId,
						}

						dividendsEstimates = append(dividendsEstimates, dividendsEstimate)
					} else {
						//	 记录失败的退货单号和原因
						estimateFailedDividendsOrders[dividendsReturnedEstimateDetail.OrderOrReturnedOrderNumber] = dividendsReturnedEstimateDetail.Reason
					}
				}
			}
		}
		fmt.Println("订单分红耗时：", time.Since(startConfirm))

		startInsert := time.Now()
		if dividendsEstimatesSaved, err := dividendsEstimateRepository.SaveMany(dividendsEstimates); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			fmt.Println("插入预算单耗时：", time.Since(startInsert))
			// 获取产品ID
			orderGoodSavedIds := make([]int64, 0)
			for _, dividendsEstimate := range dividendsEstimates {
				orderGoodSavedIds = append(orderGoodSavedIds, dividendsEstimate.OrderGoodId)
			}

			// 更新订单产品分红状态
			startUpdateGoodStatus := time.Now()
			var orderGoodsSaved []*domain.OrderGood
			if len(orderGoodSavedIds) > 0 {
				// 订单产品ID去重
				newOrderGoodIds := utils.RemoveDuplicationInt64(orderGoodSavedIds)
				if countOrderGood, orderGoodsFound, err := orderGoodRepository.Find(map[string]interface{}{
					"orderGoodIds": newOrderGoodIds,
					"offsetLimit":  false,
				}); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				} else {
					if countOrderGood > 0 {
						for i, _ := range orderGoodsFound {
							orderGoodsFound[i].OrderGoodDividendsStatus = int32(2) // 已分红
						}
						orderGoodsSaved = orderGoodsFound
						if _, err6 := orderGoodRepository.UpdateMany(orderGoodsFound); err6 != nil {
							return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err6.Error())
						}
					}
				}
			}
			fmt.Println("更新订单产品分红状态耗时：", time.Since(startUpdateGoodStatus))

			// 分离分红订单和退货单
			dividendsOrderNumbers := make([]string, 0)
			dividendsReturnedOrderNumbers := make([]string, 0)
			if len(estimateSuccessfullyDividendsOrders) > 0 {
				for k, _ := range estimateSuccessfullyDividendsOrders {
					if k != "" {
						if k[:2] == "RE" { // 分红退货单
							dividendsReturnedOrderNumbers = append(dividendsReturnedOrderNumbers, k)
						} else if k[:2] == "SL" { // 分红订单
							dividendsOrderNumbers = append(dividendsOrderNumbers, k)
						}
					}
				}
			}

			// 查找分红订单
			startUpdateOrder := time.Now()
			if len(dividendsOrderNumbers) > 0 {
				if countDividendsOrdersFound, dividendsOrdersFound, err := dividendsOrderRepository.Find(map[string]interface{}{
					"dividendsOrderNumbers": dividendsOrderNumbers,
					"companyId":             confirmDividendsIncentivesEstimateCommand.CompanyId,
					"orgId":                 confirmDividendsIncentivesEstimateCommand.OrgId,
					"offsetLimit":           false,
				}); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				} else {
					if countDividendsOrdersFound > 0 {
						for i, dividendsOrderFound := range dividendsOrdersFound {
							for i, _ := range dividendsOrderFound.Goods {
								for _, good := range orderGoodsSaved {
									if dividendsOrderFound.Goods[i].OrderGoodId == good.OrderGoodId {
										dividendsOrderFound.Goods[i].OrderGoodDividendsStatus = good.OrderGoodDividendsStatus
									}
								}
							}

							var dividendsGoodCount int
							for _, orderGood := range dividendsOrderFound.Goods {
								if orderGood.OrderGoodDividendsStatus == 2 {
									dividendsGoodCount = dividendsGoodCount + 1
								}
							}

							if dividendsGoodCount == len(dividendsOrderFound.Goods) { // 2已分红
								dividendsOrdersFound[i].DividendStatus = 2
							} else if dividendsGoodCount > 0 && dividendsGoodCount < len(dividendsOrderFound.Goods) { // 3部分分红
								dividendsOrdersFound[i].DividendStatus = 3
							} else if dividendsGoodCount == 0 { // 1未分红
								dividendsOrdersFound[i].DividendStatus = 1
							}
						}

						//	保存订单状态
						if _, err6 := dividendsOrderRepository.UpdateMany(dividendsOrdersFound); err6 != nil {
							return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
						}
					}
				}
			}
			fmt.Println("更新订单耗时：", time.Since(startUpdateOrder))

			// 查找分红退货单
			startUpdateReturnedOrder := time.Now()
			if len(dividendsReturnedOrderNumbers) > 0 {
				if countDividendsReturnedOrdersFound, dividendsReturnedOrdersFound, err := dividendsReturnedOrderRepository.Find(map[string]interface{}{
					"dividendsReturnedOrderNumbers": dividendsReturnedOrderNumbers,
					"companyId":                     confirmDividendsIncentivesEstimateCommand.CompanyId,
					"orgId":                         confirmDividendsIncentivesEstimateCommand.OrgId,
					"offsetLimit":                   false,
				}); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				} else {
					if countDividendsReturnedOrdersFound > 0 {
						for i, dividendsReturnedOrderFound := range dividendsReturnedOrdersFound {
							for i, _ := range dividendsReturnedOrderFound.Goods {
								for _, good := range orderGoodsSaved {
									if dividendsReturnedOrderFound.Goods[i].OrderGoodId == good.OrderGoodId {
										dividendsReturnedOrderFound.Goods[i].OrderGoodDividendsStatus = good.OrderGoodDividendsStatus
									}
								}
							}

							var dividendsGoodCount int
							for _, orderGood := range dividendsReturnedOrderFound.Goods {
								if orderGood.OrderGoodDividendsStatus == 2 {
									dividendsGoodCount = dividendsGoodCount + 1
								}
							}

							if dividendsGoodCount == len(dividendsReturnedOrderFound.Goods) { // 2已分红
								dividendsReturnedOrdersFound[i].DividendStatus = 2
							} else if dividendsGoodCount > 0 && dividendsGoodCount < len(dividendsReturnedOrderFound.Goods) { // 3部分分红
								dividendsReturnedOrdersFound[i].DividendStatus = 3
							} else if dividendsGoodCount == 0 { // 1未分红
								dividendsReturnedOrdersFound[i].DividendStatus = 1
							}
						}
						//	保存退货单状态
						if _, err6 := dividendsReturnedOrderRepository.UpdateMany(dividendsReturnedOrdersFound); err6 != nil {
							return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
						}
					}
				}
			}

			fmt.Println("更新退货单耗时：", time.Since(startUpdateReturnedOrder))

			startCommit := time.Now()
			if err := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			fmt.Println("提交事务耗时：", time.Since(startCommit))

			// 统计成功的分红预算
			successfullyCount := len(dividendsEstimatesSaved)

			// 错误原因收集，返回第一个可能的原因
			failedReason := make([]string, 0)
			for _, v := range estimateFailedDividendsOrders {
				failedReason = append(failedReason, v)
			}
			var failedReasonStr string
			if len(failedReason) > 0 {
				failedReasonStr = failedReason[0]
			} else {
				failedReasonStr = "无"
			}

			fmt.Println("函数执行完毕：", time.Since(start))

			return map[string]interface{}{
				"report": fmt.Sprintf("已完成%d单订单分红预算，生成%d单分红预算，%d笔订单分红预算失败，失败原因：%s", len(estimateSuccessfullyDividendsOrders), successfullyCount, len(estimateFailedDividendsOrders), failedReasonStr),
			}, nil
		}
	}
}

// ConfirmMoneyIncentivesEstimate 确定金额激励分红预算
func (dividendsEstimateService *DividendsEstimateService) ConfirmMoneyIncentivesEstimate(confirmMoneyIncentivesEstimateCommand *command.ConfirmMoneyIncentivesEstimateCommand) (interface{}, error) {
	if err := confirmMoneyIncentivesEstimateCommand.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 confirmMoneyIncentivesEstimateService service.ConfirmMoneyIncentivesEstimateService
	if value, err := factory.CreateConfirmMoneyIncentivesEstimateService(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		confirmMoneyIncentivesEstimateService = value
		_ = confirmMoneyIncentivesEstimateService.Subscribe(&subscriber.DividendsEstimateSubscriber{
			TransactionContext: transactionContext.(*pgTransaction.TransactionContext),
		})
	}

	// 共创合约仓储初始化
	var cooperationContractRepository domain.CooperationContractRepository
	if value, err := factory.CreateCooperationContractRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationContractRepository = value
	}

	// 分红预算单DAO初始化
	var dividendsEstimateDao *dao.DividendsEstimateDao
	if value, err := factory.CreateDividendsEstimateDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		dividendsEstimateDao = value
	}

	// 公司REST服务初始化
	var companyService service.CompanyService
	if value, err := factory.CreateCompanyService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		companyService = value
	}

	// 获取公司信息
	var company *domain.Company
	if data, err := companyService.CompanyFrom(confirmMoneyIncentivesEstimateCommand.CompanyId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		company = data
	}

	// 组织机构REST服务初始化
	var organizationService service.OrgService
	if value, err := factory.CreateOrganizationService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organizationService = value
	}

	// 获取组织机构信息
	var organization *domain.Org
	if data, err := organizationService.OrgFrom(confirmMoneyIncentivesEstimateCommand.CompanyId, confirmMoneyIncentivesEstimateCommand.OrgId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organization = data
	}

	// 分红预算仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}

	cooperationContractId, err := strconv.ParseInt(confirmMoneyIncentivesEstimateCommand.CooperationContractId, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "合约编号类型错误："+err.Error())
	}

	undertakerUIDs, err := utils.SliceAtoi(confirmMoneyIncentivesEstimateCommand.UndertakerUids)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "承接人UID类型错误："+err.Error())
	}

	// 获取共创合约
	cooperationContract, err := cooperationContractRepository.FindOne(map[string]interface{}{
		"cooperationContractId": cooperationContractId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationContract == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(cooperationContractId, 10)))
	}

	var dividendsEstimates []*domain.DividendsEstimate

	// 统计当前分红预算单数
	count, err := dividendsEstimateDao.CountDividendsEstimate(map[string]interface{}{
		"companyId": confirmMoneyIncentivesEstimateCommand.CompanyId,
	})

	// 分红预算单统计
	var countDividendsEstimate int64

	// 共创合约预算
	if dividendsEstimateDetails, err2 := confirmMoneyIncentivesEstimateService.Confirm(cooperationContract, confirmMoneyIncentivesEstimateCommand.DividendsIncentivesStage, undertakerUIDs); err2 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err2.Error())
	} else {
		for _, dividendsEstimateDetail := range dividendsEstimateDetails {
			//  生成分红预算单号
			dividendsEstimateOrderNumber, err := dividendsEstimateDetail.GenerateSpecificDividendsEstimateNumber(int64(count), countDividendsEstimate)
			if err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}

			// 统计生成的预算单数目
			countDividendsEstimate = countDividendsEstimate + 1

			// 分红金额精度处理
			dividendsAmount, _ := decimal.NewFromFloatWithExponent(dividendsEstimateDetail.DividendsAmount, -2).Float64()

			dividendsEstimate := &domain.DividendsEstimate{
				DividendsEstimateId:             0,
				DividendsAccountStatus:          domain.TO_BE_ACCOUNT,
				DividendsAmount:                 dividendsAmount,
				DividendsEstimateOrderNumber:    dividendsEstimateOrderNumber,
				DividendsEstimateTime:           time.Now(),
				DividendsParticipateType:        dividendsEstimateDetail.DividendsParticipateType,
				DividendsType:                   domain.MONEY_INCENTIVES,
				DividendsTypeName:               "金额激励",
				OrderOrReturnedOrderNum:         "",
				CooperationContractNumber:       cooperationContract.CooperationContractNumber,
				DividendsUser:                   dividendsEstimateDetail.DividendsUser,
				DividendsPercentage:             dividendsEstimateDetail.DividendsPercentage,
				DividendsStage:                  dividendsEstimateDetail.DividendsStage,
				Org:                             organization,
				Company:                         company,
				Operator:                        nil,
				OperateTime:                     time.Time{},
				IsCanceled:                      false,
				CreatedAt:                       time.Now(),
				DeletedAt:                       time.Time{},
				UpdatedAt:                       time.Time{},
				PaymentStatus:                   int32(1),
				CooperationContractUndertakerId: dividendsEstimateDetail.CooperationContractUndertakerId,
			}

			dividendsEstimates = append(dividendsEstimates, dividendsEstimate)
		}
		dividendsEstimatesSaved, err := dividendsEstimateRepository.SaveMany(dividendsEstimates)
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if confirmMoneyIncentivesEstimateCommand.Action == 1 { // 只预算，不入库
			return dividendsEstimates, nil
		} else if confirmMoneyIncentivesEstimateCommand.Action == 2 { // 确定预算
			if err := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			return dividendsEstimatesSaved, nil
		}
		return dividendsEstimatesSaved, nil
	}
}

// GetDividendsEstimate 返回分红预算单详情
func (dividendsEstimateService *DividendsEstimateService) GetDividendsEstimate(getDividendsEstimateQuery *query.GetDividendsEstimateQuery) (interface{}, error) {
	if err := getDividendsEstimateQuery.ValidateQuery(); 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 dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}
	dividendsEstimate, err := dividendsEstimateRepository.FindOne(map[string]interface{}{"dividendsEstimateId": getDividendsEstimateQuery.DividendsEstimateId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if dividendsEstimate == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(getDividendsEstimateQuery.DividendsEstimateId)))
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return dividendsEstimate, nil
	}
}

// ListDividendsEstimate 返回分红预算单列表
func (dividendsEstimateService *DividendsEstimateService) ListDividendsEstimate(listDividendsEstimateQuery *query.ListDividendsEstimateQuery) (interface{}, error) {
	if err := listDividendsEstimateQuery.ValidateQuery(); 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 dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}
	if count, dividendsEstimates, err := dividendsEstimateRepository.Find(tool_funs.SimpleStructToMap(listDividendsEstimateQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"grid": map[string]interface{}{
				"total": count,
				"list":  dividendsEstimates,
			},
		}, nil
	}
}

// RemoveDividendsEstimate 移除分红预算单（预留）
func (dividendsEstimateService *DividendsEstimateService) RemoveDividendsEstimate(removeDividendsEstimateCommand *command.RemoveDividendsEstimateCommand) (interface{}, error) {
	if err := removeDividendsEstimateCommand.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 dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}
	dividendsEstimate, err := dividendsEstimateRepository.FindOne(map[string]interface{}{"dividendsEstimateId": removeDividendsEstimateCommand.DividendsEstimateId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if dividendsEstimate == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(removeDividendsEstimateCommand.DividendsEstimateId, 10)))
	}
	if dividendsEstimate, err := dividendsEstimateRepository.Remove(dividendsEstimate); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return dividendsEstimate, nil
	}
}

// SearchDividendsEstimate 查询分红预算单
func (dividendsEstimateService *DividendsEstimateService) SearchDividendsEstimate(searchDividendsEstimateQuery *query.SearchDividendsEstimateQuery) (interface{}, error) {
	if err := searchDividendsEstimateQuery.ValidateQuery(); 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 dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}
	if count, dividendsEstimates, err := dividendsEstimateRepository.Find(tool_funs.SimpleStructToMap(searchDividendsEstimateQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"grid": map[string]interface{}{
				"total": count,
				"list":  dividendsEstimates,
			},
		}, nil
	}
}

// SearchDividendsIncentivesEstimate 查询业绩激励分红预算
func (dividendsEstimateService *DividendsEstimateService) SearchDividendsIncentivesEstimate(searchDividendsIncentivesEstimateQuery *query.SearchDividendsIncentivesEstimateQuery) (interface{}, error) {
	if err := searchDividendsIncentivesEstimateQuery.ValidateQuery(); 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 dividendsOrderRepository domain.DividendsOrderRepository
	if value, err := factory.CreateDividendsOrderRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsOrderRepository = value
	}
	// 分红退货单仓储初始化
	var dividendsReturnedOrderRepository domain.DividendsReturnedOrderRepository
	if value, err := factory.CreateDividendsReturnedOrderRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsReturnedOrderRepository = value
	}

	// 订单产品仓储初始化
	var orderGoodRepository domain.OrderGoodRepository
	if value, err := factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		orderGoodRepository = value
	}

	// 获取订单产品
	searchDividendsIncentivesEstimateQuery.OrderGoodDividendsStatus = int32(1) // 查询待分红的产品
	if count, orderGoods, err := orderGoodRepository.Find(tool_funs.SimpleStructToMap(searchDividendsIncentivesEstimateQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		var dividendsIncentivesEstimateDtos []*dto.DividendsIncentivesEstimateDto
		for _, orderGood := range orderGoods {
			if orderGood.DividendsOrderNumber != "" { // 查询分红订单
				dividendsIncentivesEstimateDto := &dto.DividendsIncentivesEstimateDto{}
				dividendsOrder, err := dividendsOrderRepository.FindOne(map[string]interface{}{
					"dividendsOrderNumber": orderGood.DividendsOrderNumber,
					"companyId":            searchDividendsIncentivesEstimateQuery.CompanyId,
					"orgId":                searchDividendsIncentivesEstimateQuery.OrgId,
				})
				if err != nil {
					log.Logger.Error(err.Error())
					continue
					//return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				if dividendsOrder == nil {
					log.Logger.Info(fmt.Sprintf("分红订单%s不存在", orderGood.DividendsOrderNumber))
					continue
					//return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", orderGood.DividendsOrderNumber))
				}
				if err := dividendsIncentivesEstimateDto.LoadDto(orderGood, dividendsOrder.DividendsOrderNumber, dividendsOrder.DividendsOriginalOrderNum, dividendsOrder.CustomerName, dividendsOrder.Region.RegionName, dividendsOrder.OrderTime); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				dividendsIncentivesEstimateDtos = append(dividendsIncentivesEstimateDtos, dividendsIncentivesEstimateDto)
			} else if orderGood.DividendsReturnedOrderNumber != "" { // 查询分红退货单
				dividendsIncentivesEstimateDto := &dto.DividendsIncentivesEstimateDto{}
				dividendsReturnedOrder, err := dividendsReturnedOrderRepository.FindOne(map[string]interface{}{
					"dividendsReturnedOrderNumber": orderGood.DividendsReturnedOrderNumber,
					"companyId":                    searchDividendsIncentivesEstimateQuery.CompanyId,
					"orgId":                        searchDividendsIncentivesEstimateQuery.OrgId,
				})
				if err != nil {
					log.Logger.Error(err.Error())
					continue
					//return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				if dividendsReturnedOrder == nil {
					log.Logger.Info(fmt.Sprintf("分红退货单%s不存在", orderGood.DividendsReturnedOrderNumber))
					continue
					//return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", orderGood.DividendsReturnedOrderNumber))
				}
				if err := dividendsIncentivesEstimateDto.LoadDto(orderGood, dividendsReturnedOrder.DividendsReturnedOrderNumber, dividendsReturnedOrder.OriginalOrderNum, dividendsReturnedOrder.DividendsReturnedCustomerName, dividendsReturnedOrder.Region.RegionName, dividendsReturnedOrder.OrderTime); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				dividendsIncentivesEstimateDtos = append(dividendsIncentivesEstimateDtos, dividendsIncentivesEstimateDto)
			}
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"total": count,
			"list":  dividendsIncentivesEstimateDtos,
		}, nil
	}
}

// SearchMoneyIncentivesEstimate 查询金额激励分红预算
func (dividendsEstimateService *DividendsEstimateService) SearchMoneyIncentivesEstimate(searchMoneyIncentivesEstimateQuery *query.SearchMoneyIncentivesEstimateQuery) (interface{}, error) {
	if err := searchMoneyIncentivesEstimateQuery.ValidateQuery(); 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 cooperationContractRepository domain.CooperationContractRepository
	if value, err := factory.CreateCooperationContractRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationContractRepository = value
	}

	// 分红预算仓储初始化
	var dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}

	// 查找共创合约
	searchMoneyIncentivesEstimateQuery.IncentivesType = 2
	searchMoneyIncentivesEstimateQuery.Status = 1
	searchMoneyIncentivesEstimateQuery.OffsetLimit = false
	if count, cooperationContracts, err := cooperationContractRepository.Find(tool_funs.SimpleStructToMap(searchMoneyIncentivesEstimateQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		var moneyIncentivesEstimateDtos []*dto.MoneyIncentivesEstimateDto
		for _, cooperationContract := range cooperationContracts {
			// 阶段承接人map
			stageUndertakerMap := make(map[int32][]*domain.Undertaker)

			// 阶段承接人列表
			stageAndUndertaker := make([]*dto.StageAndUndertaker, 0)

			// 初始化阶段承接人map

			for _, rule := range cooperationContract.MoneyIncentivesRules {
				stageUndertakerMap[rule.MoneyIncentivesStage] = make([]*domain.Undertaker, 0)
			}

			log.Logger.Info("阶段承接人map初始化", map[string]interface{}{
				"stageUndertakerMap": stageUndertakerMap,
			})

			// 获取承接人
			for _, undertaker := range cooperationContract.Undertakers {
				// 将承接人填入不同分红阶段
				for i, _ := range stageUndertakerMap {
					stageUndertakerMap[i] = append(stageUndertakerMap[i], undertaker)
				}
				//	 查询承接人分红预算单
				if countDividendsEstimates, dividendsEstimates, err := dividendsEstimateRepository.Find(map[string]interface{}{
					"cooperationContractNumber": cooperationContract.CooperationContractNumber,
					"companyId":                 cooperationContract.Company.CompanyId,
					"orgId":                     cooperationContract.Org.OrgId,
					"dividendsUserId":           undertaker.UserId,
					"offsetLimit":               false,
					"dividendsParticipateType":  int32(1),
				}); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				} else {
					log.Logger.Info("获取承接人相关的金额激励预算信息", map[string]interface{}{
						"dividendsEstimates": dividendsEstimates,
					})
					if countDividendsEstimates > 0 { // 已有分红预算
						for _, dividendsEstimate := range dividendsEstimates {
							if !dividendsEstimate.IsCanceled { // 分红预算单状态为非取消状态
								for i, undertakerAppended := range stageUndertakerMap[dividendsEstimate.DividendsStage] {
									if undertakerAppended.UndertakerId == undertaker.UndertakerId {
										// 将删除点前后的元素连接起来
										stageUndertakerMap[dividendsEstimate.DividendsStage] = append(stageUndertakerMap[dividendsEstimate.DividendsStage][:i], stageUndertakerMap[dividendsEstimate.DividendsStage][i+1:]...)
									}
								}
							}
						}
					}
				}
			}

			// 校验当前时间和激励阶段是否匹配
			currentTime := time.Now()
			for _, rule := range cooperationContract.MoneyIncentivesRules {
				if currentTime.Before(rule.MoneyIncentivesTime) {
					delete(stageUndertakerMap, rule.MoneyIncentivesStage)
				}
			}

			// 去除没有承接人的阶段
			for k, v := range stageUndertakerMap {
				if len(v) == 0 {
					delete(stageUndertakerMap, k)
				}
			}

			log.Logger.Info("阶段承接人map", map[string]interface{}{
				"stageUndertakerMap": stageUndertakerMap,
			})

			for k, v := range stageUndertakerMap {
				stageAndUndertaker = append(stageAndUndertaker, &dto.StageAndUndertaker{
					Stage:       k,
					Undertakers: v,
				})
			}

			moneyIncentivesEstimateDto := &dto.MoneyIncentivesEstimateDto{}

			// 判断当前合约的承接人是否全部分红
			allEstimate := true
			for i, _ := range stageUndertakerMap {
				if len(stageUndertakerMap[i]) > 0 {
					allEstimate = false
					break
				}
			}

			if !allEstimate {
				if err := moneyIncentivesEstimateDto.LoadDto(cooperationContract, stageAndUndertaker); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
				moneyIncentivesEstimateDtos = append(moneyIncentivesEstimateDtos, moneyIncentivesEstimateDto)
			}
		}

		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"grid": map[string]interface{}{
				"total": count,
				"list":  moneyIncentivesEstimateDtos,
			},
		}, nil
	}
}

// UpdateDividendsEstimate 更新分红预算单（预留）
func (dividendsEstimateService *DividendsEstimateService) UpdateDividendsEstimate(updateDividendsEstimateCommand *command.UpdateDividendsEstimateCommand) (interface{}, error) {
	if err := updateDividendsEstimateCommand.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 dividendsEstimateRepository domain.DividendsEstimateRepository
	if value, err := factory.CreateDividendsEstimateRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		dividendsEstimateRepository = value
	}
	dividendsEstimate, err := dividendsEstimateRepository.FindOne(map[string]interface{}{"dividendsEstimateId": updateDividendsEstimateCommand.DividendsEstimateId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if dividendsEstimate == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(updateDividendsEstimateCommand.DividendsEstimateId, 10)))
	}
	if err := dividendsEstimate.Update(tool_funs.SimpleStructToMap(updateDividendsEstimateCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if dividendsEstimate, err := dividendsEstimateRepository.Save(dividendsEstimate); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return dividendsEstimate, nil
	}
}

func NewDividendsEstimateService(options map[string]interface{}) *DividendsEstimateService {
	newDividendsEstimateService := &DividendsEstimateService{}
	return newDividendsEstimateService
}