package service

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"github.com/shopspring/decimal"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/dividendsOrder/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/dividendsOrder/query"
	"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"
	"reflect"
	"regexp"
	"strconv"
	"time"
)

// DividendsOrderService 分红订单实体对象
type DividendsOrderService struct {
}

// CreateDividendsOrder 新增分红订单实体对象
func (dividendsOrderService *DividendsOrderService) CreateDividendsOrder(createDividendsOrderCommand *command.CreateDividendsOrderCommand) (interface{}, error) {
	if err := createDividendsOrderCommand.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(createDividendsOrderCommand.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(createDividendsOrderCommand.CompanyId, createDividendsOrderCommand.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(createDividendsOrderCommand.CompanyId, createDividendsOrderCommand.OrgId, createDividendsOrderCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		operator = data
	}

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

	// 生成分红订单号
	dividendsOrderNumber, err := dividendsOrderDao.GenerateDividendsOrderNumber(map[string]interface{}{
		"companyId": createDividendsOrderCommand.CompanyId,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	// 校验分红订单编号是否唯一
	numberAvailable, err := dividendsOrderDao.CheckDividendsOrderNumberAvailable(map[string]interface{}{
		"companyId":            createDividendsOrderCommand.CompanyId,
		"dividendsOrderNumber": dividendsOrderNumber,
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if !numberAvailable {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "新增分红订单异常")
	}

	// 合约仓储初始化
	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
	}

	// 查找合约
	cooperationContractsMap := make(map[string]*domain.CooperationContract)
	if count, cooperationContracts, err := cooperationContractRepository.Find(map[string]interface{}{
		"offsetLimit": false,
		"companyId":   createDividendsOrderCommand.CompanyId,
		"orgId":       createDividendsOrderCommand.OrgId,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			for _, cooperationContract := range cooperationContracts {
				cooperationContractsMap[cooperationContract.CooperationContractNumber] = cooperationContract
			}
		}
	}

	// 订单时间转换
	orderTimeInt, err := strconv.ParseInt(createDividendsOrderCommand.OrderTime, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "订单时间错误")
	}
	orderTime := utils.TransformTimestampToTime(orderTimeInt)

	// 新增订单产品
	var orderGoods []*domain.OrderGood
	var dividendsOrderAmount float64
	for _, orderGood := range createDividendsOrderCommand.OrderGoods {
		// 计算订单产品金额
		orderGoodAmount, _ := decimal.NewFromFloat(orderGood.OrderGoodPrice).Mul(decimal.NewFromFloat(orderGood.OrderGoodQuantity)).Sub(decimal.NewFromFloat(orderGood.OrderGoodExpense)).Float64()

		// 校验合约
		ruleMatchedFlag := false
		if orderGood.CooperationContractNumber != "" {
			// 校验共创合约激励类型是否正确
			if cooperationContractsMap[orderGood.CooperationContractNumber] != nil && cooperationContractsMap[orderGood.CooperationContractNumber].IncentivesType != 1 {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "分红订单产品不能关联金额激励规则")
			}
			// 校验产品关联合约的激励规则是否匹配订单时间
			if cooperationContractsMap[orderGood.CooperationContractNumber] != nil {
				for _, incentivesRule := range cooperationContractsMap[orderGood.CooperationContractNumber].DividendsIncentivesRules {
					if !((orderTime.After(incentivesRule.DividendsIncentivesStageStart) || orderTime.Equal(incentivesRule.DividendsIncentivesStageStart)) &&
						(orderTime.Before(incentivesRule.DividendsIncentivesStageEnd) || orderTime.Equal(incentivesRule.DividendsIncentivesStageEnd))) {
						ruleMatchedFlag = true
						break
					}
				}
			}
			if !ruleMatchedFlag {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "订单时间无法匹配分红激励规则，请重新选择")
			}
		}

		orderGoods = append(orderGoods, &domain.OrderGood{
			OrderGoodId:                  0,
			OrderGoodAmount:              orderGoodAmount,
			OrderGoodName:                orderGood.OrderGoodName,
			OrderGoodPrice:               orderGood.OrderGoodPrice,
			OrderGoodQuantity:            orderGood.OrderGoodQuantity,
			DividendsOrderNumber:         dividendsOrderNumber,
			DividendsReturnedOrderNumber: "",
			CooperationContractNumber:    orderGood.CooperationContractNumber,
			OrderGoodExpense:             orderGood.OrderGoodExpense,
			OrgId:                        createDividendsOrderCommand.OrgId,
			OrderGoodDividendsStatus:     1,
			CompanyId:                    createDividendsOrderCommand.CompanyId,
			CreatedAt:                    time.Time{},
			DeletedAt:                    time.Time{},
			UpdatedAt:                    time.Time{},
		})
		// 计算分红订单金额
		dividendsOrderAmount, _ = decimal.NewFromFloat(dividendsOrderAmount).Add(decimal.NewFromFloat(orderGood.OrderGoodPrice).Mul(decimal.NewFromFloat(orderGood.OrderGoodQuantity)).Sub(decimal.NewFromFloat(orderGood.OrderGoodExpense))).Float64()
	}

	// 新增分红订单
	newDividendsOrder := &domain.DividendsOrder{
		DividendsOrderNumber:      dividendsOrderNumber,
		DividendsOriginalOrderNum: createDividendsOrderCommand.DividendsOriginalOrderNum,
		DividendsOrderAmount:      dividendsOrderAmount,
		OrderTime:                 orderTime,
		DividendTime:              time.Time{},
		DividendStatus:            domain.TO_BE_DIVIDEND,
		Region: &domain.RegionInfo{
			RegionNumber: "",
			RegionName:   createDividendsOrderCommand.RegionName,
		},
		CustomerName: createDividendsOrderCommand.CustomerName,
		Goods:        orderGoods,
		Org:          organization,
		Company:      company,
		CreatedAt:    time.Now(),
		DeletedAt:    time.Time{},
		UpdatedAt:    time.Time{},
		OperateTime:  time.Now(),
		Operator:     operator,
		Remarks:      createDividendsOrderCommand.Remarks,
	}

	// 分红订单仓储初始化
	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
	}
	if dividendsOrder, err := dividendsOrderRepository.Save(newDividendsOrder); 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 dividendsOrder, nil
	}
}

// ImportDividendsOrder 导入分红订单实体对象
func (dividendsOrderService *DividendsOrderService) ImportDividendsOrder(importDividendsOrderCommand *command.ImportDividendsOrderCommand) (interface{}, error) {
	if err := importDividendsOrderCommand.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(importDividendsOrderCommand.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(importDividendsOrderCommand.CompanyId, importDividendsOrderCommand.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(importDividendsOrderCommand.CompanyId, importDividendsOrderCommand.OrgId, importDividendsOrderCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		operator = data
	}

	// 合约仓储初始化
	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
	}

	// 查找合约
	cooperationContractsMap := make(map[string]*domain.CooperationContract)
	countContracts, cooperationContracts, err := cooperationContractRepository.Find(map[string]interface{}{
		"offsetLimit": false,
		"companyId":   importDividendsOrderCommand.CompanyId,
		"orgId":       importDividendsOrderCommand.OrgId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if countContracts > 0 {
			for _, cooperationContract := range cooperationContracts {
				cooperationContractsMap[cooperationContract.CooperationContractNumber] = cooperationContract
			}
		}
	}

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

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

	// 返回信息表头定义
	var tableHeader = map[string]interface{}{
		"failReason":                "失败原因",
		"originalOrderNum":          "来源单号",
		"dividendsCustomerName":     "客户名称",
		"orderGoodName":             "产品名称",
		"orderTime":                 "订单日期",
		"regionName":                "订单区域",
		"orderGoodQuantity":         "产品数量",
		"orderGoodPrice":            "产品价格",
		"expense":                   "费用",
		"cooperationContractNumber": "项目合约编号",
	}

	// 空文件校验
	if len(importDividendsOrderCommand.DividendsOrderData) == 0 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "导入的Excel文件为空文件，请上传正确的文件")
	}

	// 必填项校验
	nullCellError := make([]*domain.FailInfo, 0)

	// 数据行计数
	rowCnt := 0

	// 空行标志位
	nullFlag := false

	for i, dividendsOrder := range importDividendsOrderCommand.DividendsOrderData {
		rowCnt++
		nullCell := make([]interface{}, 0)
		t := reflect.TypeOf(dividendsOrder)
		v := reflect.ValueOf(dividendsOrder)
		for k := 0; k < t.NumField(); k++ {
			//fmt.Println("name:", fmt.Sprintf("%+v", t.Field(k).Name), ", value:", fmt.Sprintf("%v", v.Field(k).Interface()), ", yaml:", t.Field(k).Tag.Get("yaml"))
			if k != 7 && k != 8 {
				if v.Field(k).Interface() == "" {
					col := strconv.Itoa(k + 1)
					nullCell = append(nullCell, col)
					nullFlag = true
				}
			}
		}
		if nullFlag {
			myRow := &domain.FailInfo{
				FailReason: "必填项为空",
			}
			myRow.ImportDividendsOrderData = &importDividendsOrderCommand.DividendsOrderData[i]
			nullCellError = append(nullCellError, myRow)
			nullFlag = false
		}
	}

	// 必填项错误返回
	if len(nullCellError) > 0 {
		return map[string]interface{}{
			"successCount": 0,
			"fail": map[string]interface{}{
				"header": tableHeader,
				"body":   nullCellError,
			},
		}, nil
	}

	// 单元格类型校验
	typeError := make([]interface{}, 0)
	for i, dividendsOrder := range importDividendsOrderCommand.DividendsOrderData { // 行
		var myRow []*domain.FailInfo
		t := reflect.TypeOf(dividendsOrder)
		v := reflect.ValueOf(dividendsOrder)
		for k := 0; k < t.NumField(); k++ { // 列
			r := strconv.Itoa(i + 1)
			switch k {
			case 3: // 订单日期校验
				{
					regexpStr := `(\d{4})/(\d{2})/(\d{2})`
					ok := regexp.MustCompile(regexpStr).MatchString(fmt.Sprintf("%v", v.Field(k).Interface()))
					if !ok {
						tmpRow := &domain.FailInfo{
							FailReason: "订单日期格式错误，请输入正确的订单日期",
						}
						tmpRow.ImportDividendsOrderData = &dividendsOrder
						myRow = append(myRow, tmpRow)
					}
				}
			case 5: // 产品数量校验
				{
					//参数类型转换
					orderGoodQuantity, err := strconv.ParseInt(fmt.Sprintf("%v", v.Field(k).Interface()), 10, 64)
					if err != nil {
						tmpRow := &domain.FailInfo{
							FailReason: "行产品数量格式错误，产品数量必须整数",
						}
						tmpRow.ImportDividendsOrderData = &dividendsOrder
						myRow = append(myRow, tmpRow)
					}
					//	 正负判断
					if orderGoodQuantity < 0 {
						tmpRow := &domain.FailInfo{
							FailReason: "产品数量必须大于0，请重新填写",
						}
						tmpRow.ImportDividendsOrderData = &dividendsOrder
						myRow = append(myRow, tmpRow)
					}
				}
			case 6: // 产品价格校验
				{
					// 参数类型转换
					univalent, typeErr := strconv.ParseFloat(fmt.Sprintf("%v", v.Field(k).Interface()), 64)
					if typeErr != nil {
						tmpRow := &domain.FailInfo{
							FailReason: "产品价格格式错误，产品价格必须为数字类型",
						}
						tmpRow.ImportDividendsOrderData = &dividendsOrder
						myRow = append(myRow, tmpRow)
					}

					// 长度校验
					if univalent >= 1e16 {
						tmpRow := &domain.FailInfo{
							FailReason: "第" + r + "行产品价格超过最大限制，产品价格小数点前面不能超过十六位数字，并保留两位小数",
						}
						tmpRow.ImportDividendsOrderData = &dividendsOrder
						// 错误行数据
						myRow = append(myRow, tmpRow)
					}
				}
			case 7: // 费用校验
				{
					if fmt.Sprintf("%v", v.Field(k).Interface()) != "" {
						// 参数类型转换
						univalent, typeErr := strconv.ParseFloat(fmt.Sprintf("%v", v.Field(k).Interface()), 64)
						if typeErr != nil {
							tmpRow := &domain.FailInfo{
								FailReason: "第" + r + "行费用格式错误，费用必须为数字类型",
							}
							tmpRow.ImportDividendsOrderData = &dividendsOrder
							myRow = append(myRow, tmpRow)
							log.Logger.Info("费用类型错误", map[string]interface{}{
								"tmpRow": tmpRow,
							})
						}
						// 长度校验
						if univalent >= 1e16 {
							tmpRow := &domain.FailInfo{
								FailReason: "第" + r + "行费用超过最大限制，费用小数点前面不能超过十六位数字，并保留两位小数",
							}
							tmpRow.ImportDividendsOrderData = &dividendsOrder
							myRow = append(myRow, tmpRow)
						}
					}
				}
			}
		}
		if myRow != nil {
			typeError = append(typeError, myRow)
		}
	}

	// 类型错误行返回
	if len(typeError) > 0 {
		return map[string]interface{}{
			"successCount": 0,
			"fail": map[string]interface{}{
				"header": tableHeader,
				"body":   typeError,
			},
		}, nil
	}

	// 聚合订单并进行类型校验
	aggregateErrorList := make([]interface{}, 0)

	var dividendsOrderCommands = make(map[string]*command.CreateDividendsOrderCommand)
	for i, dividendsOrder := range importDividendsOrderCommand.DividendsOrderData {
		hashValue := md5.Sum([]byte(dividendsOrder.OriginalOrderNum))
		hashString := hex.EncodeToString(hashValue[:])
		if _, ok := dividendsOrderCommands[hashString]; !ok {
			// 订单日期时间格式转换
			timeValue, err := time.ParseInLocation("2006/01/02", dividendsOrder.OrderTime, time.Local)
			if err != nil {
				tmpRow := &domain.FailInfo{
					FailReason: "无效的订单日期",
				}
				tmpRow.ImportDividendsOrderData = &dividendsOrder
				aggregateErrorList = append(aggregateErrorList, tmpRow)
				break
			}

			// 产品相关：产品名称，产品数量、产品价格、费用
			quantity, err := strconv.ParseFloat(dividendsOrder.OrderGoodQuantity, 64)
			if err != nil {
				return nil, application.ThrowError(application.ARG_ERROR, err.Error())
			}
			price, err := strconv.ParseFloat(dividendsOrder.OrderGoodPrice, 64)
			if err != nil {
				return nil, application.ThrowError(application.ARG_ERROR, err.Error())
			}
			var expense float64
			if dividendsOrder.Expense != "" {
				if expenseParse, err := strconv.ParseFloat(dividendsOrder.Expense, 64); err != nil {
					return nil, application.ThrowError(application.ARG_ERROR, err.Error())
				} else {
					expense = expenseParse
				}
			}

			//	初始化新建分红订单命令集
			dividendsOrderCommands[hashString] = &command.CreateDividendsOrderCommand{
				CustomerName:              dividendsOrder.DividendsCustomerName,
				DividendsOriginalOrderNum: dividendsOrder.OriginalOrderNum,
				OrderTime:                 strconv.FormatInt(timeValue.Local().UnixNano()/1e6, 10),
				Remarks:                   "",
				RegionName:                dividendsOrder.RegionName,
				OperatorUid:               strconv.FormatInt(importDividendsOrderCommand.UserId, 10),
				OrderGoods: []command.OrderGoods{
					{
						OrderGoodId:               "0",
						OrderGoodAmount:           0,
						OrderGoodName:             dividendsOrder.OrderGoodName,
						OrderGoodPrice:            price,
						OrderGoodQuantity:         quantity,
						DividendsOrderNumber:      "",
						CooperationContractNumber: dividendsOrder.CooperationContractNumber,
						OrderGoodExpense:          expense,
					},
				},
				CompanyId:   importDividendsOrderCommand.CompanyId,
				OrgId:       importDividendsOrderCommand.OrgId,
				UserId:      importDividendsOrderCommand.UserId,
				UserBaseId:  importDividendsOrderCommand.UserBaseId,
				LineNumbers: []int{i}, // 记录行号
			}
		} else { // 聚合同一笔订单产品
			// 产品相关：产品名称，产品数量、产品价格、费用
			quantity, err := strconv.ParseFloat(dividendsOrder.OrderGoodQuantity, 64)
			if err != nil {
				return nil, application.ThrowError(application.ARG_ERROR, err.Error())
			}
			price, err := strconv.ParseFloat(dividendsOrder.OrderGoodPrice, 64)
			if err != nil {
				return nil, application.ThrowError(application.ARG_ERROR, err.Error())
			}
			var expense float64
			if dividendsOrder.Expense != "" {
				if expenseParse, err := strconv.ParseFloat(dividendsOrder.Expense, 64); err != nil {
					return nil, application.ThrowError(application.ARG_ERROR, err.Error())
				} else {
					expense = expenseParse
				}
			}

			dividendsOrderCommands[hashString].OrderGoods = append(dividendsOrderCommands[hashString].OrderGoods, command.OrderGoods{
				OrderGoodId:               "0",
				OrderGoodAmount:           0,
				OrderGoodName:             dividendsOrder.OrderGoodName,
				OrderGoodPrice:            price,
				OrderGoodQuantity:         quantity,
				DividendsOrderNumber:      "",
				CooperationContractNumber: dividendsOrder.CooperationContractNumber,
				OrderGoodExpense:          expense,
			})

			//	记录聚合行号
			dividendsOrderCommands[hashString].LineNumbers = append(dividendsOrderCommands[hashString].LineNumbers, i)
		}
	}

	// 聚合订单错误返回
	if len(aggregateErrorList) > 0 {
		return map[string]interface{}{
			"successCount": 0,
			"fail": map[string]interface{}{
				"header": tableHeader,
				"body":   aggregateErrorList,
			},
		}, nil
	}

	// 批量创建分红订单命令集
	var createDividendsOrderCommands []*command.CreateDividendsOrderCommand
	for _, dividendsOrderCommand := range dividendsOrderCommands {
		createDividendsOrderCommands = append(createDividendsOrderCommands, dividendsOrderCommand)
	}

	// 新增失败记录
	failureDataList := make([]interface{}, 0)

	// 新增成功记录计数
	var successDataCount int64

	// 错误数据返回
	var errorDataList []*domain.ImportInfo

	// 循环校验命令
	for _, cmd := range createDividendsOrderCommands {
		if err = cmd.ValidateCommand(); err != nil {
			// 返回信息
			row := &domain.ImportInfo{
				Error:       application.ThrowError(application.BUSINESS_ERROR, err.Error()), // 错误信息
				LineNumbers: cmd.LineNumbers,                                                 // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}
	}

	// 循环校验命令失败返回
	if len(errorDataList) > 0 {
		successDataCount = 0
		// 错误记录处理
		for _, errorData := range errorDataList {
			if len(errorData.GoodLine) == 0 { // 订单错误
				for _, line := range errorData.LineNumbers {
					tmpRow := &domain.FailInfo{
						FailReason: "数据校验错误：" + errorData.Error.Error(),
					}
					tmpRow.ImportDividendsOrderData = &importDividendsOrderCommand.DividendsOrderData[line]
					failureDataList = append(failureDataList, tmpRow)
				}
			} else if len(errorData.GoodLine) > 0 { // 订单产品错误
				for line := range errorData.GoodLine {
					tmpRow := &domain.FailInfo{
						FailReason: "订单产品信息错误：" + errorData.Error.Error(),
					}
					tmpRow.ImportDividendsOrderData = &importDividendsOrderCommand.DividendsOrderData[line]
					failureDataList = append(failureDataList, tmpRow)
				}
			}
		}
		return map[string]interface{}{
			"successCount": successDataCount,
			"fail": map[string]interface{}{
				"header": tableHeader,
				"body":   failureDataList,
			},
		}, nil
	}

	// 创建分红订单领域模型
	var creatDividendsOrder []*domain.DividendsOrder

	// 统计当前分红订单数
	count, err := dividendsOrderDao.CountDividendsOrder(map[string]interface{}{})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	// 批量创建分红订单
	for i, dividendsOrder := range createDividendsOrderCommands {
		// 生成分红订单号
		dividendsOrderNumber, err := dividendsOrder.GenerateSpecificDividendsOrderNumber(int64(count), time.Time{}, int64(i))
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}

		// 订单时间转换
		orderTimeInt, err := strconv.ParseInt(dividendsOrder.OrderTime, 10, 64)
		if err != nil {
			row := &domain.ImportInfo{
				Error:       application.ThrowError(application.INTERNAL_SERVER_ERROR, fmt.Sprintf("订单日期转换错误：%s", err)),
				LineNumbers: dividendsOrder.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}
		orderTime := utils.TransformTimestampToTime(orderTimeInt)

		// 新增订单产品
		var orderGoods []*domain.OrderGood
		var dividendsOrderAmount float64
		orderGoodErrMap := make(map[int]interface{}, 0)
		for i, orderGood := range dividendsOrder.OrderGoods {
			// 校验共创合约是否合法
			contractNumberExist := false
			for _, cooperationContract := range cooperationContracts {
				if orderGood.CooperationContractNumber == cooperationContract.CooperationContractNumber {
					contractNumberExist = true
					break
				}
			}
			if !contractNumberExist {
				orderGoodErrMap[dividendsOrder.OrderGoods[i].LineNumber] = application.ThrowError(application.INTERNAL_SERVER_ERROR, fmt.Sprintf("共创合约编号不存在：%s", err))
			}

			// 计算产品金额
			orderGoodAmount, _ := decimal.NewFromFloat(orderGood.OrderGoodPrice).Mul(decimal.NewFromFloat(orderGood.OrderGoodQuantity)).Sub(decimal.NewFromFloat(orderGood.OrderGoodExpense)).Float64()

			// 校验共创合约激励类型是否正确
			ruleMatchedFlag := false
			if orderGood.CooperationContractNumber != "" {
				if cooperationContractsMap[orderGood.CooperationContractNumber] != nil && cooperationContractsMap[orderGood.CooperationContractNumber].IncentivesType != 1 {
					orderGoodErrMap[dividendsOrder.OrderGoods[i].LineNumber] = application.ThrowError(application.INTERNAL_SERVER_ERROR, "退货单产品不能关联金额激励规则")
				}
				// 校验产品关联合约的激励规则是否匹配订单时间
				if cooperationContractsMap[orderGood.CooperationContractNumber] != nil {
					for _, incentivesRule := range cooperationContractsMap[orderGood.CooperationContractNumber].DividendsIncentivesRules {
						if !((orderTime.After(incentivesRule.DividendsIncentivesStageStart) || orderTime.Equal(incentivesRule.DividendsIncentivesStageStart)) &&
							(orderTime.Before(incentivesRule.DividendsIncentivesStageEnd) || orderTime.Equal(incentivesRule.DividendsIncentivesStageEnd))) {
							ruleMatchedFlag = true
							break
						}
					}
				}
				if !ruleMatchedFlag {
					orderGoodErrMap[dividendsOrder.OrderGoods[i].LineNumber] = application.ThrowError(application.INTERNAL_SERVER_ERROR, "订单时间无法匹配分红激励规则，请重新选择")
				}
			}

			orderGoods = append(orderGoods, &domain.OrderGood{
				OrderGoodId:                  0,
				OrderGoodAmount:              orderGoodAmount,
				OrderGoodName:                orderGood.OrderGoodName,
				OrderGoodPrice:               orderGood.OrderGoodPrice,
				OrderGoodQuantity:            orderGood.OrderGoodQuantity,
				DividendsOrderNumber:         dividendsOrderNumber,
				DividendsReturnedOrderNumber: "",
				CooperationContractNumber:    orderGood.CooperationContractNumber,
				OrderGoodExpense:             orderGood.OrderGoodExpense,
				OrgId:                        importDividendsOrderCommand.OrgId,
				CompanyId:                    importDividendsOrderCommand.CompanyId,
				CreatedAt:                    time.Now(),
				DeletedAt:                    time.Time{},
				UpdatedAt:                    time.Time{},
			})

			// 计算分红订单金额
			dividendsOrderAmount, _ = decimal.NewFromFloat(dividendsOrderAmount).Add(decimal.NewFromFloat(orderGood.OrderGoodPrice).Mul(decimal.NewFromFloat(orderGood.OrderGoodQuantity).Sub(decimal.NewFromFloat(orderGood.OrderGoodExpense)))).Float64()
		}
		if len(orderGoodErrMap) > 0 {
			row := &domain.ImportInfo{
				Error:       application.ThrowError(application.BUSINESS_ERROR, "共创合约不存在"),
				LineNumbers: dividendsOrder.LineNumbers, // 错误影响的行
				GoodLine:    orderGoodErrMap,            // 错误产品行号记录
			}
			errorDataList = append(errorDataList, row)
			continue
		}

		// 新增分红订单
		newDividendsOrder := &domain.DividendsOrder{
			DividendsOrderId:          0,
			DividendsOrderNumber:      dividendsOrderNumber,
			DividendsOriginalOrderNum: dividendsOrder.DividendsOriginalOrderNum,
			DividendsOrderAmount:      dividendsOrderAmount,
			OrderTime:                 orderTime,
			DividendTime:              time.Time{},
			DividendStatus:            domain.TO_BE_DIVIDEND,
			Region: &domain.RegionInfo{
				RegionNumber: "",
				RegionName:   dividendsOrder.RegionName,
			},
			CustomerName: dividendsOrder.CustomerName,
			Goods:        orderGoods,
			Org:          organization,
			Company:      company,
			CreatedAt:    time.Now(),
			DeletedAt:    time.Time{},
			UpdatedAt:    time.Time{},
			OperateTime:  time.Now(),
			Operator:     operator,
		}

		creatDividendsOrder = append(creatDividendsOrder, newDividendsOrder)
	}

	// 错误报告处理
	if len(errorDataList) <= 0 { // 成功返回
		if _, err2 := dividendsOrderRepository.SaveMany(creatDividendsOrder); err2 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err2.Error())
		}
		if err3 := transactionContext.CommitTransaction(); err3 != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err3.Error())
		}
		successDataCount = int64(rowCnt - len(failureDataList))
		if successDataCount == int64(rowCnt) {
			return map[string]interface{}{
				"successCount": successDataCount,
				"fail":         map[string]interface{}{},
			}, nil
		}
	} else { // 失败返回
		successDataCount = 0
		// 错误记录处理
		for _, errorData := range errorDataList {
			if len(errorData.GoodLine) == 0 { // 订单错误
				for _, line := range errorData.LineNumbers {
					tmpRow := &domain.FailInfo{
						FailReason: "订单数据新增错误：" + errorData.Error.Error(),
					}
					tmpRow.ImportDividendsOrderData = &importDividendsOrderCommand.DividendsOrderData[line]
					failureDataList = append(failureDataList, tmpRow)
				}
			} else if len(errorData.GoodLine) > 0 { // 订单产品错误
				for line := range errorData.GoodLine {
					tmpRow := &domain.FailInfo{
						FailReason: "订单数据新增错误：" + errorData.Error.Error(),
					}
					tmpRow.ImportDividendsOrderData = &importDividendsOrderCommand.DividendsOrderData[line]
					failureDataList = append(failureDataList, tmpRow)
				}
			}
		}
		return map[string]interface{}{
			"successCount": successDataCount,
			"fail": map[string]interface{}{
				"header": tableHeader,
				"body":   failureDataList,
			},
		}, nil
	}
	return nil, nil
}

// GetDividendsOrder 返回分红订单实体对象
func (dividendsOrderService *DividendsOrderService) GetDividendsOrder(getDividendsOrderQuery *query.GetDividendsOrderQuery) (interface{}, error) {
	if err := getDividendsOrderQuery.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
	}
	dividendsOrder, err := dividendsOrderRepository.FindOne(tool_funs.SimpleStructToMap(getDividendsOrderQuery))
	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", strconv.FormatInt(getDividendsOrderQuery.DividendsOrderId, 10)))
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return dividendsOrder, nil
	}
}

// ListDividendsOrders 返回分红订单实体对象列表
func (dividendsOrderService *DividendsOrderService) ListDividendsOrders(listDividendsOrdersQuery *query.ListDividendsOrdersQuery) (interface{}, error) {
	if err := listDividendsOrdersQuery.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
	}
	if count, dividendsOrders, err := dividendsOrderRepository.Find(tool_funs.SimpleStructToMap(listDividendsOrdersQuery)); 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": dividendsOrders,
			},
		}, nil
	}
}

// RemoveDividendsOrder 移除分红订单实体对象
func (dividendsOrderService *DividendsOrderService) RemoveDividendsOrder(removeDividendsOrderCommand *command.RemoveDividendsOrderCommand) (interface{}, error) {
	if err := removeDividendsOrderCommand.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 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
	}
	dividendsOrder, err := dividendsOrderRepository.FindOne(map[string]interface{}{"dividendsOrderId": removeDividendsOrderCommand.DividendsOrderId})
	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", strconv.FormatInt(removeDividendsOrderCommand.DividendsOrderId, 10)))
	}
	if dividendsOrderRemoved, err := dividendsOrderRepository.Remove(dividendsOrder); 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 dividendsOrderRemoved, nil
	}
}

// BatchRemoveDividendsOrder 批量移除分红订单实体对象
func (dividendsOrderService *DividendsOrderService) BatchRemoveDividendsOrder(batchRemoveDividendsOrderCommand *command.BatchRemoveDividendsOrderCommand) (interface{}, error) {
	if err := batchRemoveDividendsOrderCommand.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 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
	}

	dividendsOrderIds, err := utils.SliceAtoi(batchRemoveDividendsOrderCommand.DividendsOrderIds)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "分红订单ID类型错误")
	}
	if count, dividendsOrders, err := dividendsOrderRepository.Find(map[string]interface{}{
		"dividendsOrderIds": dividendsOrderIds,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			dividendsOrdersRemoved, err := dividendsOrderRepository.BatchRemove(dividendsOrders)
			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())
			}
			return dividendsOrdersRemoved, nil
		} else {
			return map[string]interface{}{}, nil
		}
	}
}

// SearchDividendsOrder 查询分红订单方法
func (dividendsOrderService *DividendsOrderService) SearchDividendsOrder(searchDividendsOrderQuery *query.SearchDividendsOrderQuery) (interface{}, error) {
	if err := searchDividendsOrderQuery.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
	}
	if count, dividendsOrders, err := dividendsOrderRepository.Find(tool_funs.SimpleStructToMap(searchDividendsOrderQuery)); 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":  dividendsOrders,
			},
		}, nil
	}
}

// SearchDividendsOrderNumber 查询分红订单号
func (dividendsOrderService *DividendsOrderService) SearchDividendsOrderNumber(searchDividendsOrderNumberQuery *query.SearchDividendsOrderNumberQuery) (interface{}, error) {
	if err := searchDividendsOrderNumberQuery.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
	}
	if _, dividendsOrders, err := dividendsOrderRepository.Find(tool_funs.SimpleStructToMap(searchDividendsOrderNumberQuery)); 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())
		}
		var dividendsOrderNumbers []string
		for _, dividendsOrder := range dividendsOrders {
			dividendsOrderNumbers = append(dividendsOrderNumbers, dividendsOrder.DividendsOrderNumber)
		}
		return map[string]interface{}{
			"dividendsOrderNumber": dividendsOrderNumbers,
		}, nil
	}
}

// UpdateDividendsOrder 更新分红订单实体对象
func (dividendsOrderService *DividendsOrderService) UpdateDividendsOrder(updateDividendsOrderCommand *command.UpdateDividendsOrderCommand) (interface{}, error) {
	if err := updateDividendsOrderCommand.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 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
	}

	// 订单时间转换
	orderTimeInt, err := strconv.ParseInt(updateDividendsOrderCommand.OrderTime, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "订单时间错误")
	}
	orderTime := utils.TransformTimestampToTime(orderTimeInt)

	// 分红订单ID类型转换
	dividendsOrderId, err := strconv.ParseInt(updateDividendsOrderCommand.DividendsOrderId, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 获取分红订单
	dividendsOrder, err := dividendsOrderRepository.FindOne(map[string]interface{}{"dividendsOrderId": dividendsOrderId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "分红订单不存在")
	}
	if dividendsOrder == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateDividendsOrderCommand.DividendsOrderId)))
	}

	// 合约仓储初始化
	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
	}

	// 查找合约
	cooperationContractsMap := make(map[string]*domain.CooperationContract)
	if count, cooperationContracts, err := cooperationContractRepository.Find(map[string]interface{}{
		"offsetLimit": false,
		"companyId":   updateDividendsOrderCommand.CompanyId,
		"orgId":       updateDividendsOrderCommand.OrgId,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			for _, cooperationContract := range cooperationContracts {
				cooperationContractsMap[cooperationContract.CooperationContractNumber] = cooperationContract
			}
		}
	}

	// 获取订单产品
	var orderGoods []*domain.OrderGood
	var dividendsOrderAmount float64
	for _, orderGood := range updateDividendsOrderCommand.OrderGoods {
		// 计算订单产品金额
		orderGoodAmount, _ := decimal.NewFromFloat(orderGood.OrderGoodPrice).Mul(decimal.NewFromFloat(orderGood.OrderGoodQuantity)).Sub(decimal.NewFromFloat(orderGood.OrderGoodExpense)).Float64()

		// 产品ID类型转换
		orderGoodId, err3 := strconv.ParseInt(orderGood.OrderGoodId, 10, 64)
		if err3 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err3.Error())
		}

		ruleMatchedFlag := false
		if orderGood.CooperationContractNumber != "" {
			// 校验共创合约激励类型是否正确
			if cooperationContractsMap[orderGood.CooperationContractNumber] != nil && cooperationContractsMap[orderGood.CooperationContractNumber].IncentivesType != 1 {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "分红订单产品不能关联金额激励规则")
			}
			// 校验产品关联合约的激励规则是否匹配订单时间
			if cooperationContractsMap[orderGood.CooperationContractNumber] != nil {
				for _, incentivesRule := range cooperationContractsMap[orderGood.CooperationContractNumber].DividendsIncentivesRules {
					if !((orderTime.After(incentivesRule.DividendsIncentivesStageStart) || orderTime.Equal(incentivesRule.DividendsIncentivesStageStart)) &&
						(orderTime.Before(incentivesRule.DividendsIncentivesStageEnd) || orderTime.Equal(incentivesRule.DividendsIncentivesStageEnd))) {
						ruleMatchedFlag = true
						break
					}
				}
			}
			if !ruleMatchedFlag {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "订单时间无法匹配分红激励规则，请重新选择")
			}
		}

		orderGoods = append(orderGoods, &domain.OrderGood{
			OrderGoodId:                  orderGoodId,
			OrderGoodAmount:              orderGoodAmount,
			OrderGoodName:                orderGood.OrderGoodName,
			OrderGoodPrice:               orderGood.OrderGoodPrice,
			OrderGoodQuantity:            orderGood.OrderGoodQuantity,
			DividendsOrderNumber:         dividendsOrder.DividendsOrderNumber,
			DividendsReturnedOrderNumber: "",
			CooperationContractNumber:    orderGood.CooperationContractNumber,
			OrderGoodExpense:             orderGood.OrderGoodExpense,
			OrderGoodDividendsStatus:     0,
			OrgId:                        updateDividendsOrderCommand.OrgId,
			CompanyId:                    updateDividendsOrderCommand.CompanyId,
			CreatedAt:                    time.Time{},
			UpdatedAt:                    time.Now(),
		})
		// 计算分红订单金额
		dividendsOrderAmount, _ = decimal.NewFromFloat(dividendsOrderAmount).Add(decimal.NewFromFloat(orderGood.OrderGoodPrice).Mul(decimal.NewFromFloat(orderGood.OrderGoodQuantity)).Sub(decimal.NewFromFloat(orderGood.OrderGoodExpense))).Float64()
	}

	if err := dividendsOrder.Update(tool_funs.SimpleStructToMap(updateDividendsOrderCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}

	dividendsOrder.OrderTime = orderTime
	dividendsOrder.DividendsOrderAmount = dividendsOrderAmount
	dividendsOrder.Goods = orderGoods

	// 保存订单更新
	if dividendsOrderSaved, err := dividendsOrderRepository.Save(dividendsOrder); 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 dividendsOrderSaved, nil
	}
}

func NewDividendsOrderService(options map[string]interface{}) *DividendsOrderService {
	newDividendsOrderService := &DividendsOrderService{}
	return newDividendsOrderService
}