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"
	"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
	}

	// 获取订单产品
	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})
				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{}{"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 {
		// TODO 判断承接人是否已分红

		// 数据传输对象
		var moneyIncentivesEstimateDtos []*dto.MoneyIncentivesEstimateDto
		for _, cooperationContract := range cooperationContracts {
			moneyIncentivesEstimateDto := &dto.MoneyIncentivesEstimateDto{}
			if err := moneyIncentivesEstimateDto.LoadDto(cooperationContract); 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
	}

	// 分红预算仓储初始化
	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.DividendsType == domain.ORDER_DIVIDENDS || dividendsEstimate.DividendsType == domain.RETURN_WRITE_OFF { // 订单分红、退货冲销
		if count, dividendsEstimatesRelative, err2 := dividendsEstimateRepository.Find(map[string]interface{}{"orderOrReturnedOrderNum": dividendsEstimate.OrderOrReturnedOrderNum}); 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}); 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}, cancelDividendsEstimateCommand.UserId); 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
	}

	// 分红预算仓储初始化
	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,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			// 校验分红预算是否可以取消，已有相关分红预算单已结算，无法取消
			for _, dividendsEstimate := range dividendsEstimates {
				// 校验是否能够取消
				if dividendsEstimate.DividendsType == domain.ORDER_DIVIDENDS || dividendsEstimate.DividendsType == domain.RETURN_WRITE_OFF { // 订单分红、退货冲销
					if count, dividendsEstimatesRelative, err2 := dividendsEstimateRepository.Find(map[string]interface{}{"orderOrReturnedOrderNum": dividendsEstimate.OrderOrReturnedOrderNum}); 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}); 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(dividendsEstimateIds, batchCancelEstimateCommand.UserId); 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, 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) {
	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
	}

	// 获取公司信息
	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
	}

	// 组织机构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(confirmDividendsIncentivesEstimateCommand.CompanyId, confirmDividendsIncentivesEstimateCommand.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(confirmDividendsIncentivesEstimateCommand.CompanyId, confirmDividendsIncentivesEstimateCommand.OrgId, confirmDividendsIncentivesEstimateCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		operator = data
	}

	// 分红订单仓储初始化
	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
	}

	// 分红预算仓储初始化
	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 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),
		})
	}

	// 获取订单产品
	if _, orderGoods, err := orderGoodRepository.Find(map[string]interface{}{
		"orderGoodIds": orderGoodIds,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		var dividendsEstimates []*domain.DividendsEstimate
		for _, orderGood := range orderGoods {
			dividendsEstimate := &domain.DividendsEstimate{}
			if orderGood.DividendsOrderNumber != "" { // 查询分红订单
				dividendsOrder, err3 := dividendsOrderRepository.FindOne(map[string]interface{}{"dividendsOrderNumber": orderGood.DividendsOrderNumber})
				if err3 != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "分红订单不存在")
				}
				if dividendsOrder == nil {
					return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", orderGood.DividendsOrderNumber))
				}
				// 分红订单产品预算
				if dividendsEstimateDetails, err := confirmDividendsIncentivesEstimateService.Confirm(orderGoods); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				} else {
					for _, dividendsEstimateDetail := range dividendsEstimateDetails {
						//  生成分红预算单号
						dividendsEstimateOrderNumber, err := dividendsEstimateDao.GenerateDividendsEstimateNumber()
						if err != nil {
							return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
						}
						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:      orderGood.DividendsOrderNumber,
							CooperationContractNumber:    orderGood.CooperationContractNumber,
							DividendsUser:                dividendsEstimateDetail.DividendsUser,
							DividendsStage:               dividendsEstimateDetail.DividendsStage,
							Org:                          organization,
							Company:                      company,
							Operator:                     operator,
							OperateTime:                  time.Time{},
							IsCanceled:                   false,
							CreatedAt:                    time.Now(),
							DeletedAt:                    time.Time{},
							UpdatedAt:                    time.Time{},
						}
						dividendsEstimates = append(dividendsEstimates, dividendsEstimate)
					}
				}
			} else if orderGood.DividendsReturnedOrderNumber != "" { // 查询分红退货单
				dividendsReturnedOrder, err := dividendsReturnedOrderRepository.FindOne(map[string]interface{}{"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 dividendsReturnedEstimateDetails, err := confirmDividendsIncentivesEstimateService.Confirm(orderGoods); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				} else {
					for _, dividendsReturnedEstimateDetail := range dividendsReturnedEstimateDetails {
						//  生成分红预算单号
						dividendsEstimateOrderNumber, err := dividendsEstimateDao.GenerateDividendsEstimateNumber()
						if err != nil {
							return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
						}
						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:      orderGood.DividendsReturnedOrderNumber,
							CooperationContractNumber:    orderGood.CooperationContractNumber,
							DividendsUser:                dividendsReturnedEstimateDetail.DividendsUser,
							DividendsStage:               dividendsReturnedEstimateDetail.DividendsStage,
							Org:                          organization,
							Company:                      company,
							Operator:                     operator,
							OperateTime:                  time.Time{},
							IsCanceled:                   false,
							CreatedAt:                    time.Now(),
							DeletedAt:                    time.Time{},
							UpdatedAt:                    time.Time{},
						}
						dividendsEstimates = append(dividendsEstimates, dividendsEstimate)
					}
				}
			}
		}
		log.Logger.Info("新增的分红预算单", map[string]interface{}{
			"dividendsEstimates": dividendsEstimates,
		})

		// 创建成功的分红预算单
		var dividendsEstimatesSavedSuccessfully []*domain.DividendsEstimate
		// 创建失败的分红预算单
		var dividendsEstimateSaveFailed []*domain.DividendsEstimate
		for _, dividendsEstimate := range dividendsEstimates {
			if dividendsEstimateSaved, err := dividendsEstimateRepository.Save(dividendsEstimate); err != nil {
				dividendsEstimateSaveFailed = append(dividendsEstimateSaveFailed, dividendsEstimate)
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else if dividendsEstimateSaved != nil {
				dividendsEstimatesSavedSuccessfully = append(dividendsEstimatesSavedSuccessfully, dividendsEstimate)
			}
		}

		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		// TODO 分析成功和失败原因

		return dividendsEstimatesSavedSuccessfully, 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, _ := strconv.ParseInt(confirmMoneyIncentivesEstimateCommand.CooperationContractId, 10, 64)
	undertakerUIDs, _ := utils.SliceAtoi(confirmMoneyIncentivesEstimateCommand.UndertakerUids)

	// 获取共创合约
	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

	// 共创合约预算
	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 := dividendsEstimateDao.GenerateDividendsEstimateNumber()
			if err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			dividendsEstimate := &domain.DividendsEstimate{
				DividendsEstimateId:          0,
				DividendsAccountStatus:       domain.TO_BE_ACCOUNT,
				DividendsAmount:              dividendsEstimateDetail.DividendsAmount,
				DividendsEstimateOrderNumber: dividendsEstimateOrderNumber,
				DividendsEstimateTime:        time.Now(),
				DividendsParticipateType:     dividendsEstimateDetail.DividendsParticipateType,
				DividendsType:                domain.MONEY_INCENTIVES,
				DividendsTypeName:            "金额激励",
				OrderOrReturnedOrderNum:      "",
				CooperationContractNumber:    cooperationContract.CooperationContractNumber,
				DividendsUser:                dividendsEstimateDetail.DividendsUser,
				DividendsStage:               dividendsEstimateDetail.DividendsStage,
				Org:                          organization,
				Company:                      company,
				Operator:                     nil,
				OperateTime:                  time.Time{},
				IsCanceled:                   false,
				CreatedAt:                    time.Now(),
				DeletedAt:                    time.Time{},
				UpdatedAt:                    time.Time{},
			}
			dividendsEstimates = append(dividendsEstimates, dividendsEstimate)
		}
		dividendsEstimatesSaved, err := dividendsEstimateRepository.SaveMany(dividendsEstimates)
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if confirmMoneyIncentivesEstimateCommand.Action == 1 { // 只预算，不入库
			return dividendsEstimatesSaved, 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
	}

	// 获取订单产品
	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 {
			dividendsIncentivesEstimateDto := &dto.DividendsIncentivesEstimateDto{}
			if orderGood.DividendsOrderNumber != "" { // 查询分红订单
				dividendsOrder, err := dividendsOrderRepository.FindOne(map[string]interface{}{"dividendsOrderNumber": orderGood.DividendsOrderNumber})
				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{}{"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
	}
}

// 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
	}
	// 查找共创合约
	searchMoneyIncentivesEstimateQuery.IncentivesType = 2
	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 {
			moneyIncentivesEstimateDto := &dto.MoneyIncentivesEstimateDto{}
			if err := moneyIncentivesEstimateDto.LoadDto(cooperationContract); 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
}