package service

import (
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	"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/cooperationContract/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/cooperationContract/dto"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/cooperationContract/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"
)

// CooperationContractService 共创合约服务
type CooperationContractService struct {
}

// CreateCooperationContract 创建共创合约服务
func (cooperationContractService *CooperationContractService) CreateCooperationContract(createCooperationContractCommand *command.CreateCooperationContractCommand) (interface{}, error) {
	if err := createCooperationContractCommand.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 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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}

	// 共创确认消息推送领域服务初始化
	var informJoinCreationContractService service.InformJoinCreationContractService
	if value, err := factory.CreateInformJoinCreationContractService(map[string]interface{}{
		//"transactionContext": transactionContext,
	}); err != nil {
		return []interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		informJoinCreationContractService = value
		_ = informJoinCreationContractService.Subscribe(&subscriber.MessageServiceSubscriber{
			//TransactionContext: transactionContext.(*pgTransaction.TransactionContext),
		})
	}

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

	// 获取发起人
	var sponsor *domain.User
	sponsorUid, _ := strconv.ParseInt(createCooperationContractCommand.SponsorUid, 10, 64)
	if data, err := userService.OperatorFrom(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId, sponsorUid); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取发起人失败")
	} else {
		sponsor = data
	}

	// 公司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(createCooperationContractCommand.CompanyId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_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(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取组织机构失败")
	} else {
		organization = data
	}

	// 部门REST服务初始化
	var departmentService service.DepartmentService
	if value, err := factory.CreateDepartmentService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		departmentService = value
	}

	// 获取部门
	var department *domain.Department
	departmentId, err := strconv.ParseInt(createCooperationContractCommand.DepartmentId, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取部门失败")
	}
	if data, err := departmentService.DepartmentFrom(createCooperationContractCommand.CompanyId, departmentId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		department = data
	}

	// 共创合约DAO初始化
	var cooperationContractDao *dao.CooperationContractDao
	if value, err := factory.CreateCooperationContractDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		cooperationContractDao = value
	}

	// 生成共创合约编号
	contractNumber, err2 := cooperationContractDao.GenerateContractNumber(map[string]interface{}{
		"companyId": createCooperationContractCommand.CompanyId,
	})
	if err2 != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err2.Error())
	}

	// 校验共创合约编号是否唯一
	numberAvailable, _ := cooperationContractDao.CheckContractNumberAvailable(map[string]interface{}{
		"companyId":                 createCooperationContractCommand.CompanyId,
		"cooperationContractNumber": contractNumber,
	})
	if !numberAvailable {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "新增共创合约异常")
	}

	// 获取共创项目
	cooperationProject, err := cooperationProjectRepository.FindOne(map[string]interface{}{
		"cooperationProjectNumber": createCooperationContractCommand.CooperationProjectNumber,
		"orgId":                    organization.OrgId,
		"companyId":                company.CompanyId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创项目不存在")
	}
	if cooperationProject == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", createCooperationContractCommand.CooperationProjectNumber))
	}

	// 承接人
	var undertakers []*domain.Undertaker
	for _, undertaker := range createCooperationContractCommand.Undertakers {
		// 获取承接人
		var undertakerDomain *domain.Undertaker
		undertakerUid, err := strconv.ParseInt(undertaker.UserId, 10, 64)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "承接人UID错误")
		}
		if data, err := userService.UndertakerFrom(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId, undertakerUid); err != nil {
			log.Logger.Error(err.Error())
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			undertakerDomain = data
		}

		// 校验承接人是否属于承接对象，1员工，2共创用户，4公开
		typeExist := false
		if !utils.IsContain(createCooperationContractCommand.CooperationContractUndertakerTypes, 3) {
			for _, userType := range createCooperationContractCommand.CooperationContractUndertakerTypes {
				if utils.IsContain(createCooperationContractCommand.CooperationContractUndertakerTypes, undertakerDomain.UserType&userType) {
					typeExist = true
				}
			}
			if !typeExist {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "承接人"+undertakerDomain.UserName+"不属于承接对象")
			}
		}

		// 获取推荐人
		var referrerDomain *domain.Referrer
		referrerUid, _ := strconv.ParseInt(undertaker.ReferrerId, 10, 64)
		if referrerUid > 0 {
			if data, err := userService.ReferrerFrom(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId, referrerUid); err != nil {
				log.Logger.Error(err.Error())
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				referrerDomain = data
			}
		}

		// 获取业务员
		var salesmanDomain *domain.Salesman
		salesmanUid, _ := strconv.ParseInt(undertaker.SalesmanId, 10, 64)
		if salesmanUid > 0 {
			if data, err := userService.SalesmanFrom(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId, salesmanUid); err != nil {
				log.Logger.Error(err.Error())
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				salesmanDomain = data
			}
		}

		// 解析附件
		var attachments []*domain.Attachment
		for _, attachment := range undertaker.ContractAttachment {
			attachments = append(attachments, &domain.Attachment{
				FileType: attachment.FileType,
				Name:     attachment.Name,
				Url:      attachment.Url,
				FileSize: attachment.FileSize,
			})
		}

		undertakers = append(undertakers, &domain.Undertaker{
			UndertakerId:              0,
			UserId:                    undertakerDomain.UserId,
			CooperationContractNumber: contractNumber,
			UserBaseId:                undertakerDomain.UserBaseId,
			Org:                       organization,
			Orgs:                      undertakerDomain.Orgs,
			Department:                undertakerDomain.Department,
			Roles:                     undertakerDomain.Roles,
			UserInfo:                  undertakerDomain.UserInfo,
			UserName:                  undertakerDomain.UserName,
			UserPhone:                 undertakerDomain.UserPhone,
			UserType:                  undertakerDomain.UserType,
			Referrer:                  referrerDomain,
			Salesman:                  salesmanDomain,
			Status:                    undertakerDomain.Status,
			Company:                   company,
			ContractAttachment:        attachments,
		})
	}

	// 获取相关人
	var relevantPeople []*domain.Relevant
	for _, relevantPersonUid := range createCooperationContractCommand.RelevantIds {
		var relevantDomain *domain.Relevant
		relevantUid, _ := strconv.ParseInt(relevantPersonUid, 10, 64)
		if data, err := userService.RelevantFrom(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId, relevantUid); err != nil {
			log.Logger.Error(err.Error())
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			relevantDomain = data
		}
		relevantPeople = append(relevantPeople, &domain.Relevant{
			RelevantId:                0,
			CooperationContractNumber: contractNumber,
			UserId:                    relevantDomain.UserId,
			UserBaseId:                relevantDomain.UserBaseId,
			Org:                       organization,
			Orgs:                      relevantDomain.Orgs,
			Department:                relevantDomain.Department,
			Roles:                     relevantDomain.Roles,
			UserInfo:                  relevantDomain.UserInfo,
			UserType:                  relevantDomain.UserType,
			Status:                    relevantDomain.Status,
			Company:                   company,
		})
	}

	// 获取分红激励规则列表
	var dividendsIncentivesRules []*domain.DividendsIncentivesRule
	for _, dividendsIncentivesRule := range createCooperationContractCommand.DividendsIncentivesRules {
		dividendsIncentivesRules = append(dividendsIncentivesRules, &domain.DividendsIncentivesRule{
			DividendsIncentivesRuleId:     0,
			CooperationContractNumber:     contractNumber,
			ReferrerPercentage:            dividendsIncentivesRule.ReferrerPercentage,
			SalesmanPercentage:            dividendsIncentivesRule.SalesmanPercentage,
			DividendsIncentivesPercentage: dividendsIncentivesRule.DividendsIncentivesPercentage,
			DividendsIncentivesStage:      dividendsIncentivesRule.DividendsIncentivesStage,
			DividendsIncentivesStageCN:    utils.NumberToCNNumber(int(dividendsIncentivesRule.DividendsIncentivesStage)),
			DividendsIncentivesStageEnd:   dividendsIncentivesRule.DividendsIncentivesStageEnd,
			DividendsIncentivesStageStart: dividendsIncentivesRule.DividendsIncentivesStageStart,
			Org:                           organization,
			Company:                       company,
			UpdatedAt:                     time.Time{},
			DeletedAt:                     time.Time{},
			CreatedAt:                     time.Now(),
			Remarks:                       dividendsIncentivesRule.Remarks,
		})
	}

	// 获取金额激励规则
	var moneyIncentivesRules []*domain.MoneyIncentivesRule
	for _, moneyIncentivesRule := range createCooperationContractCommand.MoneyIncentivesRules {
		moneyIncentivesRules = append(moneyIncentivesRules, &domain.MoneyIncentivesRule{
			MoneyIncentivesRuleId:     0,
			CooperationContractNumber: contractNumber,
			MoneyIncentivesAmount:     moneyIncentivesRule.MoneyIncentivesAmount,
			MoneyIncentivesStage:      moneyIncentivesRule.MoneyIncentivesStage,
			MoneyIncentivesStageCN:    utils.NumberToCNNumber(int(moneyIncentivesRule.MoneyIncentivesStage)),
			MoneyIncentivesStageEnd:   moneyIncentivesRule.MoneyIncentivesStageEnd,
			MoneyIncentivesStageStart: moneyIncentivesRule.MoneyIncentivesStageStart,
			MoneyIncentivesTime:       moneyIncentivesRule.MoneyIncentivesTime,
			ReferrerPercentage:        moneyIncentivesRule.ReferrerPercentage,
			SalesmanPercentage:        moneyIncentivesRule.SalesmanPercentage,
			Org:                       organization,
			Company:                   company,
			UpdatedAt:                 time.Time{},
			DeletedAt:                 time.Time{},
			CreatedAt:                 time.Now(),
			Remarks:                   moneyIncentivesRule.Remarks,
		})
	}

	// 查找共创模式
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	cooperationMode, err := cooperationModeRepository.FindOne(map[string]interface{}{
		"companyId":             createCooperationContractCommand.CompanyId,
		"orgId":                 createCooperationContractCommand.OrgId,
		"cooperationModeNumber": createCooperationContractCommand.CooperationModeNumber,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创模式不存在")
	}
	if cooperationMode == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", createCooperationContractCommand.CooperationModeNumber))
	} else {
		incentivesType := 0
		if len(dividendsIncentivesRules) > 0 {
			incentivesType = domain.TYPE_DIVIDNEDS_INCENTIVES
		} else if len(moneyIncentivesRules) > 0 {
			incentivesType = domain.TYPE_MONEY_INCENTIVES
		}
		newCooperationContract := &domain.CooperationContract{
			CooperationContractDescription:     createCooperationContractCommand.CooperationContractDescription,
			CooperationContractName:            createCooperationContractCommand.CooperationContractName,
			CooperationContractNumber:          contractNumber,
			CooperationProjectNumber:           createCooperationContractCommand.CooperationProjectNumber,
			CooperationContractUndertakerTypes: createCooperationContractCommand.CooperationContractUndertakerTypes,
			CooperationContractSponsor:         sponsor,
			CooperationMode:                    cooperationMode,
			Status:                             1,
			Org:                                organization,
			Company:                            company,
			Department:                         department,
			Operator:                           operator,
			DividendsIncentivesRules:           dividendsIncentivesRules,
			MoneyIncentivesRules:               moneyIncentivesRules,
			IncentivesType:                     int32(incentivesType),
			Undertakers:                        undertakers,
			RelevantPeople:                     relevantPeople,
			OperateTime:                        time.Now(),
			CreatedAt:                          time.Now(),
			DeletedAt:                          time.Time{},
			UpdatedAt:                          time.Time{},
			CooperationProjectId:               cooperationProject.CooperationProjectId,
		}

		// 共创合约仓储初始化
		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
		}
		// 保存共创合约
		if cooperationContract, err := cooperationContractRepository.Save(newCooperationContract); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {

			if err = cooperationContractService.UpdateCooperationProjectStaticsInfo(transactionContext,
				cooperationContract.Company.CompanyId,
				cooperationContract.Org.OrgId,
				cooperationContract.CooperationProjectNumber); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}

			if err := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			// 消息推送
			var jointDataSlices []service.JoinData
			for _, undertaker := range cooperationContract.Undertakers {
				jointDataSlices = append(jointDataSlices, service.JoinData{
					CreationContractId:     cooperationContract.CooperationContractId,
					CreationContractName:   cooperationContract.CooperationContractName,
					CreationContractNumber: cooperationContract.CooperationContractNumber,
					CreationProjectId:      cooperationProject.CooperationProjectId,
					CreationProjectNumber:  cooperationProject.CooperationProjectNumber,
					CreationProjectName:    cooperationProject.CooperationProjectName,
					UserId:                 undertaker.UserId,
					UserBaseId:             undertaker.UserBaseId,
					OrgId:                  undertaker.Org.OrgId,
					CompanyId:              undertaker.Company.CompanyId,
				})
			}

			if err3 := informJoinCreationContractService.Join(jointDataSlices); err3 != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err3.Error())
			}

			return cooperationContract, nil
		}
	}
}

// GetCooperationContract 返回共创合约服务
func (cooperationContractService *CooperationContractService) GetCooperationContract(getCooperationContractQuery *query.GetCooperationContractQuery) (interface{}, error) {
	if err := getCooperationContractQuery.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
	}
	cooperationContract, err := cooperationContractRepository.FindOne(map[string]interface{}{"cooperationContractId": getCooperationContractQuery.CooperationContractId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创合约不存在")
	}
	if cooperationContract == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(getCooperationContractQuery.CooperationContractId, 10)))
	} else {
		// 共创合约DAO初始化
		var cooperationContractDao *dao.CooperationContractDao
		if value, err := factory.CreateCooperationContractDao(map[string]interface{}{
			"transactionContext": transactionContext,
		}); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		} else {
			cooperationContractDao = value
		}

		// 可以去除勾选的承接人对象列表
		var undertakerTypesUncheckedAvailable []int32

		// 判断承接对象是否存在员工
		gotUser, err := cooperationContractDao.CheckUndertakerTypesUncheckedAvailable(map[string]interface{}{
			"cooperationContractNumber": cooperationContract.CooperationContractNumber,
			"user":                      true,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if !gotUser {
			undertakerTypesUncheckedAvailable = append(undertakerTypesUncheckedAvailable, 1)
		}

		// 判断承接对象是否存在共创用户
		gotPartner, err := cooperationContractDao.CheckUndertakerTypesUncheckedAvailable(map[string]interface{}{
			"cooperationContractNumber": cooperationContract.CooperationContractNumber,
			"partner":                   true,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if !gotPartner {
			undertakerTypesUncheckedAvailable = append(undertakerTypesUncheckedAvailable, 2)
		}

		// 判断承接人是否存在公开用户
		if !gotUser && !gotPartner {
			undertakerTypesUncheckedAvailable = append(undertakerTypesUncheckedAvailable, 3)
		}

		cooperationContractDto := &dto.CooperationContractDto{}
		if err := cooperationContractDto.LoadDto(cooperationContract, undertakerTypesUncheckedAvailable); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return cooperationContractDto, nil
	}
}

// ListCooperationContract 返回共创合约服务列表
func (cooperationContractService *CooperationContractService) ListCooperationContract(listCooperationContractQuery *query.ListCooperationContractQuery) (interface{}, error) {
	if err := listCooperationContractQuery.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
	}
	// 查找合约
	if count, cooperationContracts, err := cooperationContractRepository.Find(tool_funs.SimpleStructToMap(listCooperationContractQuery)); 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":  cooperationContracts,
			},
		}, nil
	}
}

// RemoveCooperationContract 移除共创合约服务
func (cooperationContractService *CooperationContractService) RemoveCooperationContract(removeCooperationContractCommand *command.RemoveCooperationContractCommand) (interface{}, error) {
	if err := removeCooperationContractCommand.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 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
	}
	cooperationContract, err := cooperationContractRepository.FindOne(map[string]interface{}{"cooperationContractId": removeCooperationContractCommand.CooperationContractId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创合约不存在")
	}
	if cooperationContract == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(removeCooperationContractCommand.CooperationContractId, 10)))
	}
	if cooperationContract, err := cooperationContractRepository.Remove(cooperationContract); 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 cooperationContract, nil
	}
}

// BatchRemoveCooperationContract 批量移除共创合约
func (cooperationContractService *CooperationContractService) BatchRemoveCooperationContract(batchRemoveCooperationContractCommand *command.BatchRemoveCooperationContractCommand) (interface{}, error) {
	if err := batchRemoveCooperationContractCommand.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 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
	}
	cooperationContractIds, _ := utils.SliceAtoi(batchRemoveCooperationContractCommand.CooperationContractIds)
	if count, cooperationContracts, err := cooperationContractRepository.Find(map[string]interface{}{
		"cooperationContractIds": cooperationContractIds,
		"offsetLimit":            false,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			cooperationContractsRemoved, err := cooperationContractRepository.BatchRemove(cooperationContracts)
			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 cooperationContractsRemoved, nil
		} else {
			return map[string]interface{}{}, nil
		}
	}
}

// OperateCooperationContract 暂停或恢复共创合约
func (cooperationContractService *CooperationContractService) OperateCooperationContract(operateCooperationContractCommand *command.OperateCooperationContractCommand) (interface{}, error) {
	if err := operateCooperationContractCommand.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 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(operateCooperationContractCommand.CompanyId, operateCooperationContractCommand.OrgId, operateCooperationContractCommand.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
	}

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

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

	// 更新共创合约
	if err := cooperationContract.Update(map[string]interface{}{
		"action": operateCooperationContractCommand.Action,
	}); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if cooperationContractUpdated, err := cooperationContractRepository.UpdateOne(cooperationContract); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		// 新增共创合约变更记录
		var operationType int32
		if operateCooperationContractCommand.Action == 2 {
			operationType = domain.PAUSE
		} else if operateCooperationContractCommand.Action == 1 {
			operationType = domain.RECOVER
		}
		newCooperationContractChangeLog := &domain.CooperationContractChangeLog{
			IncentivesRule:            "",
			IncentivesRuleDetail:      "",
			OperationType:             operationType,
			Undertakers:               "",
			CooperationContractNumber: cooperationContractUpdated.CooperationContractNumber,
			Company:                   cooperationContractUpdated.Company,
			Org:                       cooperationContract.Org,
			Operator:                  operator,
			CreatedAt:                 time.Now(),
		}

		// 保存共创合约变更记录
		if _, err20 := cooperationContractChangeLogRepository.Save(newCooperationContractChangeLog); err20 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err20.Error())
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return cooperationContractUpdated, nil
	}
}

// BatchOperateCooperationContract 批量暂停或恢复共创合约
func (cooperationContractService *CooperationContractService) BatchOperateCooperationContract(batchOperateCooperationContractCommand *command.BatchOperateCooperationContractCommand) (interface{}, error) {
	if err := batchOperateCooperationContractCommand.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 cooperationContractRepository domain.CooperationContractRepository
	if value, err := factory.CreateCooperationContractRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationContractRepository = value
	}

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

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

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

	cooperationContractIds, err := utils.SliceAtoi(batchOperateCooperationContractCommand.CooperationContractIds)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "转换共创合约ID列表错误")
	}
	if count, cooperationContracts, err := cooperationContractRepository.Find(map[string]interface{}{
		"cooperationContractIds": cooperationContractIds,
		"offsetLimit":            false,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			for i, _ := range cooperationContracts {
				cooperationContracts[i].Status = batchOperateCooperationContractCommand.Action
			}
			cooperationContractsOperated, err := cooperationContractRepository.UpdateMany(cooperationContracts)
			if err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			for _, cooperationContractOperated := range cooperationContracts {
				// 新增共创合约变更记录
				var operationType int32
				if batchOperateCooperationContractCommand.Action == 2 {
					operationType = domain.PAUSE
				} else if batchOperateCooperationContractCommand.Action == 1 {
					operationType = domain.RECOVER
				}
				newCooperationContractChangeLog := &domain.CooperationContractChangeLog{
					IncentivesRule:            "",
					IncentivesRuleDetail:      "",
					OperationType:             operationType,
					Undertakers:               "",
					CooperationContractNumber: cooperationContractOperated.CooperationContractNumber,
					Company:                   cooperationContractOperated.Company,
					Org:                       cooperationContractOperated.Org,
					Operator:                  operator,
					CreatedAt:                 time.Now(),
					OperatorTime:              time.Now(),
				}

				// 保存共创合约变更记录
				if _, err20 := cooperationContractChangeLogRepository.Save(newCooperationContractChangeLog); err20 != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err20.Error())
				}
			}

			if err := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
			}
			return cooperationContractsOperated, nil
		} else {
			return map[string]interface{}{}, nil
		}
	}
}

// SearchCooperationContract 查询共创合约
func (cooperationContractService *CooperationContractService) SearchCooperationContract(searchCooperationContractQuery *query.SearchCooperationContractQuery) (interface{}, error) {
	if err := searchCooperationContractQuery.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
	}
	if count, cooperationContracts, err := cooperationContractRepository.Find(tool_funs.SimpleStructToMap(searchCooperationContractQuery)); 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":  cooperationContracts,
			},
		}, nil
	}
}

// SearchCooperationContractByUndertaker 根据承接人返回共创项目合约
func (cooperationContractService *CooperationContractService) SearchCooperationContractByUndertaker(searchCooperationContractByUndertakerQuery *query.SearchCooperationContractByUndertakerQuery) (interface{}, error) {
	if err := searchCooperationContractByUndertakerQuery.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()
	}()

	// 共创合约DAO初始化
	var cooperationContractDao *dao.CooperationContractDao
	if value, err := factory.CreateCooperationContractDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		cooperationContractDao = value
	}

	// 查询共创项目合约
	if count, cooperationContractByUndertakers, err := cooperationContractDao.SearchCooperationContractByUndertaker(tool_funs.SimpleStructToMap(searchCooperationContractByUndertakerQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationContractByUndertakerDtos := make([]*dto.CooperationContractByUndertakerDto, 0)
		for _, cooperationContractByUndertaker := range cooperationContractByUndertakers {
			cooperationContractByUndertakerDto := &dto.CooperationContractByUndertakerDto{}
			if err := cooperationContractByUndertakerDto.LoadDto(cooperationContractByUndertaker); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
			cooperationContractByUndertakerDtos = append(cooperationContractByUndertakerDtos, cooperationContractByUndertakerDto)
		}
		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":  cooperationContractByUndertakerDtos,
			},
		}, nil
	}
}

// UpdateCooperationContract 更新共创合约服务
func (cooperationContractService *CooperationContractService) UpdateCooperationContract(updateCooperationContractCommand *command.UpdateCooperationContractCommand) (interface{}, error) {
	if err := updateCooperationContractCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err1 := factory.CreateTransactionContext(nil)
	if err1 != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err1.Error())
	}
	if err2 := transactionContext.StartTransaction(); err2 != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err2.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

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

	// 共创项目仓储初始化
	var cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}

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

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

	// 共创确认消息推送领域服务初始化
	var informJoinCreationContractService service.InformJoinCreationContractService
	if value, err := factory.CreateInformJoinCreationContractService(map[string]interface{}{
		//"transactionContext": transactionContext,
	}); err != nil {
		return []interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		informJoinCreationContractService = value
		_ = informJoinCreationContractService.Subscribe(&subscriber.MessageServiceSubscriber{
			//TransactionContext: transactionContext.(*pgTransaction.TransactionContext),
		})
	}

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

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

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

	// 获取待更新的共创合约
	cooperationContractFound, err8 := cooperationContractRepository.FindOne(map[string]interface{}{
		"cooperationContractId": updateCooperationContractCommand.CooperationContractId,
	})
	if err8 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创合约不存在")
	}
	if cooperationContractFound == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateCooperationContractCommand.CooperationContractId)))
	}

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

	// 获取发起人
	var sponsor *domain.User
	sponsorUid, err := strconv.ParseInt(updateCooperationContractCommand.SponsorUid, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "发起人UID类型错误")
	}
	if data, err11 := userService.OperatorFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, sponsorUid); err11 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取发起人失败")
	} else {
		sponsor = data
	}

	// 获取共创项目
	cooperationProject, err := cooperationProjectRepository.FindOne(map[string]interface{}{
		"cooperationProjectNumber": cooperationContractFound.CooperationProjectNumber,
		"orgId":                    organization.OrgId,
		"companyId":                company.CompanyId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创项目不存在")
	}
	if cooperationProject == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", cooperationContractFound.CooperationProjectNumber))
	}

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

	// 获取待更新的共创合约
	cooperationContract, err9 := cooperationContractRepository.FindOne(map[string]interface{}{
		"cooperationContractId": updateCooperationContractCommand.CooperationContractId,
	})
	if err9 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创合约不存在")
	}
	if cooperationContract == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateCooperationContractCommand.CooperationContractId)))
	}

	// 更新合约基础信息
	if err10 := cooperationContract.Update(tool_funs.SimpleStructToMap(updateCooperationContractCommand)); err10 != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err10.Error())
	}

	// 更新发起人
	cooperationContract.CooperationContractSponsor = sponsor

	// 获取相关人
	var relevantPeople []*domain.Relevant
	for _, relevantPersonUid := range updateCooperationContractCommand.RelevantIds {
		var relevantDomain *domain.Relevant
		relevantUid, err := strconv.ParseInt(relevantPersonUid, 10, 64)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "相关人UID类型错误")
		}
		if data, err12 := userService.RelevantFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, relevantUid); err12 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取相关人失败")
		} else {
			relevantDomain = data
		}
		relevantPeople = append(relevantPeople, &domain.Relevant{
			RelevantId:                relevantDomain.RelevantId,
			CooperationContractNumber: cooperationContract.CooperationContractNumber,
			UserId:                    relevantDomain.UserId,
			UserBaseId:                relevantDomain.UserBaseId,
			Org:                       organization,
			Orgs:                      relevantDomain.Orgs,
			Department:                relevantDomain.Department,
			Roles:                     relevantDomain.Roles,
			UserInfo:                  relevantDomain.UserInfo,
			UserType:                  relevantDomain.UserType,
			Status:                    relevantDomain.Status,
			Company:                   company,
		})
	}

	// 更新合约相关人
	cooperationContract.RelevantPeople = relevantPeople

	// 获取承接人
	var undertakers []*domain.Undertaker
	for _, undertaker := range updateCooperationContractCommand.Undertakers {
		var undertakerDomain *domain.Undertaker
		undertakerUid, err := strconv.ParseInt(undertaker.UserId, 10, 64)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "承接人UID类型错误")
		}
		if data, err13 := userService.UndertakerFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, undertakerUid); err13 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err13.Error())
		} else {
			undertakerDomain = data
		}

		// 校验：判断用户类型是否属于承接对象
		typeExist := false
		if !utils.IsContain(cooperationContract.CooperationContractUndertakerTypes, 3) { // 非公开类型校验
			for _, userType := range cooperationContract.CooperationContractUndertakerTypes {
				if utils.IsContain(cooperationContract.CooperationContractUndertakerTypes, undertakerDomain.UserType&userType) {
					typeExist = true
				}
			}
			if !typeExist {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "承接人"+undertakerDomain.UserName+"不属于承接对象")
			}
		}

		// 获取推荐人
		var referrerDomain *domain.Referrer
		if undertaker.ReferrerId != "" {
			referrerUid, err := strconv.ParseInt(undertaker.ReferrerId, 10, 64)
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "推荐人UID类型错误")
			}
			if referrerUid > 0 {
				if data, err14 := userService.ReferrerFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, referrerUid); err14 != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取推荐人失败")
				} else {
					referrerDomain = data
				}
			}
		}

		// 获取业务员
		var salesmanDomain *domain.Salesman
		if undertaker.SalesmanId != "" {
			salesmanUid, err22 := strconv.ParseInt(undertaker.SalesmanId, 10, 64)
			if err22 != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "业务员UID类型错误")
			}
			if salesmanUid > 0 {
				if data, err15 := userService.SalesmanFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, salesmanUid); err15 != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取业务员失败")
				} else {
					salesmanDomain = data
				}
			}
		}

		// 承接人ID类型转换
		undertakerId, err16 := strconv.ParseInt(undertaker.UndertakerId, 10, 64)
		if err16 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err16.Error())
		}

		var contractAttachments []*domain.Attachment
		for _, attachment := range undertaker.ContractAttachment {
			contractAttachments = append(contractAttachments, &domain.Attachment{
				FileType: attachment.FileType,
				Name:     attachment.Name,
				Url:      attachment.Url,
				FileSize: attachment.FileSize,
			})
		}

		undertakers = append(undertakers, &domain.Undertaker{
			UndertakerId:              undertakerId,
			UserId:                    undertakerDomain.UserId,
			CooperationContractNumber: cooperationContract.CooperationContractNumber,
			CooperationContractId:     cooperationContract.CooperationContractId,
			UserBaseId:                undertakerDomain.UserBaseId,
			Org:                       organization,
			Orgs:                      undertakerDomain.Orgs,
			Department:                undertakerDomain.Department,
			Roles:                     undertakerDomain.Roles,
			UserInfo:                  undertakerDomain.UserInfo,
			UserType:                  undertakerDomain.UserType,
			Referrer:                  referrerDomain,
			Salesman:                  salesmanDomain,
			Status:                    undertakerDomain.Status,
			Company:                   company,
			ContractAttachment:        contractAttachments,
		})
	}

	// 获取待添加的承接人
	var undertakersToAdd []*domain.Undertaker
	for _, undertaker := range undertakers {
		if undertaker.UndertakerId == 0 {
			undertakersToAdd = append(undertakersToAdd, undertaker)
		}
	}

	// 更新承接人
	cooperationContract.Undertakers = undertakers

	// 获取分红规则列表
	var dividendsIncentivesRules []*domain.DividendsIncentivesRule
	for _, dividendsIncentivesRule := range updateCooperationContractCommand.DividendsIncentivesRules {
		dividendsIncentivesRuleId, err17 := strconv.ParseInt(dividendsIncentivesRule.DividendsIncentivesRuleId, 10, 64)
		if err17 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err17.Error())
		}
		dividendsIncentivesRules = append(dividendsIncentivesRules, &domain.DividendsIncentivesRule{
			DividendsIncentivesRuleId:     dividendsIncentivesRuleId,
			CooperationContractNumber:     cooperationContract.CooperationContractNumber,
			ReferrerPercentage:            dividendsIncentivesRule.ReferrerPercentage,
			SalesmanPercentage:            dividendsIncentivesRule.SalesmanPercentage,
			DividendsIncentivesPercentage: dividendsIncentivesRule.DividendsIncentivesPercentage,
			DividendsIncentivesStage:      dividendsIncentivesRule.DividendsIncentivesStage,
			DividendsIncentivesStageCN:    utils.NumberToCNNumber(int(dividendsIncentivesRule.DividendsIncentivesStage)),
			DividendsIncentivesStageEnd:   dividendsIncentivesRule.DividendsIncentivesStageEnd,
			DividendsIncentivesStageStart: dividendsIncentivesRule.DividendsIncentivesStageStart,
			Org:                           organization,
			Company:                       company,
			UpdatedAt:                     time.Time{},
			DeletedAt:                     time.Time{},
			CreatedAt:                     time.Now(),
			Remarks:                       dividendsIncentivesRule.Remarks,
		})
	}

	// 更新分红规则列表
	cooperationContract.DividendsIncentivesRules = dividendsIncentivesRules

	// 获取金额激励规则列表
	var moneyIncentivesRules []*domain.MoneyIncentivesRule
	for _, moneyIncentivesRule := range updateCooperationContractCommand.MoneyIncentivesRules {
		moneyIncentivesRuleId, err18 := strconv.ParseInt(moneyIncentivesRule.MoneyIncentivesRuleId, 10, 64)
		if err18 != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err18.Error())
		}
		moneyIncentivesRules = append(moneyIncentivesRules, &domain.MoneyIncentivesRule{
			MoneyIncentivesRuleId:     moneyIncentivesRuleId,
			CooperationContractNumber: cooperationContract.CooperationContractNumber,
			MoneyIncentivesAmount:     moneyIncentivesRule.MoneyIncentivesAmount,
			MoneyIncentivesStage:      moneyIncentivesRule.MoneyIncentivesStage,
			MoneyIncentivesStageCN:    utils.NumberToCNNumber(int(moneyIncentivesRule.MoneyIncentivesStage)),
			MoneyIncentivesStageEnd:   moneyIncentivesRule.MoneyIncentivesStageEnd,
			MoneyIncentivesStageStart: moneyIncentivesRule.MoneyIncentivesStageStart,
			MoneyIncentivesTime:       moneyIncentivesRule.MoneyIncentivesTime,
			ReferrerPercentage:        moneyIncentivesRule.ReferrerPercentage,
			SalesmanPercentage:        moneyIncentivesRule.SalesmanPercentage,
			Org:                       organization,
			Company:                   company,
			UpdatedAt:                 time.Time{},
			DeletedAt:                 time.Time{},
			CreatedAt:                 time.Now(),
			Remarks:                   moneyIncentivesRule.Remarks,
		})
	}

	// 更新金额激励规则列表
	cooperationContract.MoneyIncentivesRules = moneyIncentivesRules

	// 判断激励规则变更
	incentivesType := 0
	if len(dividendsIncentivesRules) > 0 {
		incentivesType = domain.TYPE_DIVIDNEDS_INCENTIVES
	} else if len(moneyIncentivesRules) > 0 {
		incentivesType = domain.TYPE_MONEY_INCENTIVES
	}
	cooperationContract.IncentivesType = int32(incentivesType)

	// 保存共创合约变更
	if cooperationContractSaved, err19 := cooperationContractRepository.Save(cooperationContract); err19 != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err19.Error())
	} else {
		// 保存共创合约变更记录
		var incentivesRuleChange string
		var incentivesRuleChangeDetail string

		// 规则变更，原【（激励阶段：激励百分点，阶段有效期，推荐人抽点，关联业务员抽点），（激励阶段：激励百分点，阶段有效期，推荐人抽点，关联业务员抽点）】-->更新后【（激励阶段：激励百分点，阶段有效期，推荐人抽点，关联业务员抽点）】
		if cooperationContractFound.IncentivesType != cooperationContract.IncentivesType { // 1.激励规则类型变更
			if cooperationContractFound.IncentivesType == domain.TYPE_DIVIDNEDS_INCENTIVES && cooperationContract.IncentivesType == domain.TYPE_MONEY_INCENTIVES { // 业绩分红变更为金额激励
				// 业绩分红-->金额激励
				incentivesRuleChange = cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContractFound.IncentivesType)) + "-->" + cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContract.IncentivesType))
				//【第一阶段：20，2021-01-01~2021-12-31，，，；第二阶段：20，2021-01-01~2021-12-31，30，10】变更为【第一阶段：20，2021-01-01~2021-12-31，，，；】
				// 原业绩分红激励规则
				var dividendsIncentivesRuleOriginal string
				for _, dividendsIncentivesRule := range cooperationContractFound.DividendsIncentivesRules {
					dividendsIncentivesRuleOriginal = dividendsIncentivesRuleOriginal + dividendsIncentivesRule.DividendsIncentivesStageCN +
						"：" + fmt.Sprint(dividendsIncentivesRule.DividendsIncentivesPercentage) +
						"，" + dividendsIncentivesRule.DividendsIncentivesStageStart.Format("2006-01-02") +
						"~" + dividendsIncentivesRule.DividendsIncentivesStageEnd.Format("2006-01-02") +
						"，" + fmt.Sprint(dividendsIncentivesRule.ReferrerPercentage) +
						"，" + fmt.Sprint(dividendsIncentivesRule.SalesmanPercentage) + ";"
				}
				dividendsIncentivesRuleOriginalTmp := "【" + dividendsIncentivesRuleOriginal + "】"

				// 变更后的金额激励规则
				var moneyIncentivesRuleChanged string
				for _, moneyIncentivesRule := range cooperationContract.MoneyIncentivesRules {
					moneyIncentivesRuleChanged = moneyIncentivesRuleChanged + moneyIncentivesRule.MoneyIncentivesStageCN +
						"：" +
						"，" + moneyIncentivesRule.MoneyIncentivesTime.Format("2006-01-02") +
						"，" + fmt.Sprint(moneyIncentivesRule.ReferrerPercentage) +
						"，" + fmt.Sprint(moneyIncentivesRule.SalesmanPercentage) + ";"
				}
				moneyIncentivesRuleOriginalTmp := "【" + moneyIncentivesRuleChanged + "】"

				// 拼接规则变更
				incentivesRuleChangeDetail = dividendsIncentivesRuleOriginalTmp + " 变更为 " + moneyIncentivesRuleOriginalTmp
			} else if cooperationContractFound.IncentivesType == domain.TYPE_MONEY_INCENTIVES && cooperationContract.IncentivesType == domain.TYPE_DIVIDNEDS_INCENTIVES { // 金额激励变更为业绩分红
				//	金额激励-->业绩分红
				incentivesRuleChange = cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContractFound.IncentivesType)) + "-->" + cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContract.IncentivesType))
				//【第一阶段：20，2021-01-01~2021-12-31，，，；第二阶段：20，2021-01-01~2021-12-31，30，10】变更为【第一阶段：20，2021-01-01~2021-12-31，，，；】
				// 原金额激励规则
				var moneyIncentivesRuleOriginal string
				for _, moneyIncentivesRule := range cooperationContractFound.MoneyIncentivesRules {
					moneyIncentivesRuleOriginal = moneyIncentivesRuleOriginal + moneyIncentivesRule.MoneyIncentivesStageCN +
						"：" +
						"，" + moneyIncentivesRule.MoneyIncentivesTime.Format("2006-01-02") +
						"，" + fmt.Sprint(moneyIncentivesRule.ReferrerPercentage) +
						"，" + fmt.Sprint(moneyIncentivesRule.SalesmanPercentage) + ";"
				}
				moneyIncentivesRuleOriginalTmp := "【" + moneyIncentivesRuleOriginal + "】"

				// 变更后的业绩分红激励规则
				var dividendsIncentivesRuleChanged string
				for _, dividendsIncentivesRule := range cooperationContract.DividendsIncentivesRules {
					dividendsIncentivesRuleChanged = dividendsIncentivesRuleChanged + dividendsIncentivesRule.DividendsIncentivesStageCN +
						"：" + fmt.Sprint(dividendsIncentivesRule.DividendsIncentivesPercentage) +
						"，" + dividendsIncentivesRule.DividendsIncentivesStageStart.Format("2006-01-02") +
						"~" + dividendsIncentivesRule.DividendsIncentivesStageEnd.Format("2006-01-02") +
						"，" + fmt.Sprint(dividendsIncentivesRule.ReferrerPercentage) +
						"，" + fmt.Sprint(dividendsIncentivesRule.SalesmanPercentage) + ";"
				}
				dividendsIncentivesRuleOriginalTmp := "【" + dividendsIncentivesRuleChanged + "】"

				// 拼接规则变更
				incentivesRuleChangeDetail = moneyIncentivesRuleOriginalTmp + " 变更为 " + dividendsIncentivesRuleOriginalTmp
			}
		} else if cooperationContractFound.IncentivesType == cooperationContract.IncentivesType { // 2.激励规则内容变更
			if cooperationContractFound.IncentivesType == domain.TYPE_DIVIDNEDS_INCENTIVES { // 业绩分红规则内容变更
				// 计算原合约哈希值
				// cooperationContractFoundByte := *(*[]byte)(unsafe.Pointer(&cooperationContractFound.DividendsIncentivesRules))
				var cooperationContractFoundBytes []byte
				for _, rule := range cooperationContractFound.DividendsIncentivesRules {
					jsons, errs := json.Marshal(rule)
					if errs != nil {
						fmt.Printf(errs.Error())
					}
					cooperationContractFoundBytes = append(cooperationContractFoundBytes, jsons...)
				}
				cooperationContractFoundHashValue := md5.Sum(cooperationContractFoundBytes)
				cooperationContractFoundHashString := hex.EncodeToString(cooperationContractFoundHashValue[:])

				// 计算更新后的合约哈希值
				// cooperationContractByte := *(*[]byte)(unsafe.Pointer(&cooperationContract.DividendsIncentivesRules))
				var cooperationContractBytes []byte
				for _, rule := range cooperationContract.DividendsIncentivesRules {
					jsons, errs := json.Marshal(rule)
					if errs != nil {
						fmt.Printf(errs.Error())
					}
					cooperationContractBytes = append(cooperationContractBytes, jsons...)
				}
				cooperationContractHashValue := md5.Sum(cooperationContractBytes)
				cooperationContractHashString := hex.EncodeToString(cooperationContractHashValue[:])

				if cooperationContractFoundHashString != cooperationContractHashString {
					//	业绩分红-->业绩分红
					incentivesRuleChange = cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContractFound.IncentivesType)) + "-->" + cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContract.IncentivesType))
					//【第一阶段：20，2021-01-01~2021-12-31，，，；第二阶段：20，2021-01-01~2021-12-31，30，10】变更为【第一阶段：20，2021-01-01~2021-12-31，，，；】
					// 原业绩分红激励规则
					var dividendsIncentivesRuleOriginal string
					for _, dividendsIncentivesRule := range cooperationContractFound.DividendsIncentivesRules {
						dividendsIncentivesRuleOriginal = dividendsIncentivesRuleOriginal + dividendsIncentivesRule.DividendsIncentivesStageCN +
							"：" + fmt.Sprint(dividendsIncentivesRule.DividendsIncentivesPercentage) +
							"，" + dividendsIncentivesRule.DividendsIncentivesStageStart.Format("2006-01-02") +
							"~" + dividendsIncentivesRule.DividendsIncentivesStageEnd.Format("2006-01-02") +
							"，" + fmt.Sprint(dividendsIncentivesRule.ReferrerPercentage) +
							"，" + fmt.Sprint(dividendsIncentivesRule.SalesmanPercentage) + ";"
					}
					dividendsIncentivesRuleOriginalTmp := "【" + dividendsIncentivesRuleOriginal + "】"
					// 变更后的业绩分红激励规则
					var dividendsIncentivesRuleChanged string
					for _, dividendsIncentivesRule := range cooperationContract.DividendsIncentivesRules {
						dividendsIncentivesRuleChanged = dividendsIncentivesRuleChanged + dividendsIncentivesRule.DividendsIncentivesStageCN +
							"：" + fmt.Sprint(dividendsIncentivesRule.DividendsIncentivesPercentage) +
							"，" + dividendsIncentivesRule.DividendsIncentivesStageStart.Format("2006-01-02") +
							"~" + dividendsIncentivesRule.DividendsIncentivesStageEnd.Format("2006-01-02") +
							"，" + fmt.Sprint(dividendsIncentivesRule.ReferrerPercentage) +
							"，" + fmt.Sprint(dividendsIncentivesRule.SalesmanPercentage) + ";"
					}
					dividendsIncentivesRuleChangedTmp := "【" + dividendsIncentivesRuleChanged + "】"
					// 拼接规则变更
					incentivesRuleChangeDetail = dividendsIncentivesRuleOriginalTmp + " 变更为 " + dividendsIncentivesRuleChangedTmp
				}
			} else if cooperationContractFound.IncentivesType == domain.TYPE_MONEY_INCENTIVES { // 金额激励规则内容变更
				// 计算原合约哈希值
				//cooperationContractFoundByte := *(*[]byte)(unsafe.Pointer(&cooperationContractFound.MoneyIncentivesRules))
				var cooperationContractFoundBytes []byte
				for _, rule := range cooperationContractFound.MoneyIncentivesRules {
					jsons, errs := json.Marshal(rule)
					if errs != nil {
						fmt.Printf(errs.Error())
					}
					cooperationContractFoundBytes = append(cooperationContractFoundBytes, jsons...)
				}
				cooperationContractFoundHashValue := md5.Sum(cooperationContractFoundBytes)
				cooperationContractFoundHashString := hex.EncodeToString(cooperationContractFoundHashValue[:])

				// 计算更新后的合约哈希值
				//cooperationContractByte := *(*[]byte)(unsafe.Pointer(&cooperationContract.MoneyIncentivesRules))
				var cooperationContractBytes []byte
				for _, rule := range cooperationContract.MoneyIncentivesRules {
					jsons, errs := json.Marshal(rule)
					if errs != nil {
						fmt.Printf(errs.Error())
					}
					cooperationContractBytes = append(cooperationContractBytes, jsons...)
				}
				cooperationContractHashValue := md5.Sum(cooperationContractBytes)
				cooperationContractHashString := hex.EncodeToString(cooperationContractHashValue[:])

				if cooperationContractFoundHashString != cooperationContractHashString {
					incentivesRuleChange = cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContractFound.IncentivesType)) + "-->" + cooperationContract.ReturnIncentivesName(domain.IncentivesType(cooperationContract.IncentivesType))
					//【第一阶段：20，2021-01-01~2021-12-31，，，；第二阶段：20，2021-01-01~2021-12-31，30，10】变更为【第一阶段：20，2021-01-01~2021-12-31，，，；】
					// 原金额激励规则
					var moneyIncentivesRuleOriginal string
					for _, moneyIncentivesRule := range cooperationContractFound.MoneyIncentivesRules {
						moneyIncentivesRuleOriginal = moneyIncentivesRuleOriginal + moneyIncentivesRule.MoneyIncentivesStageCN +
							"：" + fmt.Sprint(moneyIncentivesRule.MoneyIncentivesAmount) +
							"，" + moneyIncentivesRule.MoneyIncentivesTime.Format("2006-01-02") +
							"，" + fmt.Sprint(moneyIncentivesRule.ReferrerPercentage) +
							"，" + fmt.Sprint(moneyIncentivesRule.SalesmanPercentage) + ";"
					}
					moneyIncentivesRuleOriginalTmp := "【" + moneyIncentivesRuleOriginal + "】"
					// 变更后的激励规则
					var moneyIncentivesRuleChanged string
					for _, moneyIncentivesRule := range cooperationContract.MoneyIncentivesRules {
						moneyIncentivesRuleChanged = moneyIncentivesRuleChanged + moneyIncentivesRule.MoneyIncentivesStageCN +
							"：" + fmt.Sprint(moneyIncentivesRule.MoneyIncentivesAmount) +
							"，" + moneyIncentivesRule.MoneyIncentivesTime.Format("2006-01-02") +
							"，" + fmt.Sprint(moneyIncentivesRule.ReferrerPercentage) +
							"，" + fmt.Sprint(moneyIncentivesRule.SalesmanPercentage) + ";"
					}
					moneyIncentivesRuleChangedTmp := "【" + moneyIncentivesRuleChanged + "】"
					// 拼接规则变更
					incentivesRuleChangeDetail = moneyIncentivesRuleOriginalTmp + " 变更为 " + moneyIncentivesRuleChangedTmp
				}
			}
		}

		/*********************************************** 承接人变更 *****************************************************/
		var undertakerChange string
		// 计算原合约哈希值
		//cooperationContractFoundByte := *(*[]byte)(unsafe.Pointer(&cooperationContractFound.Undertakers))
		var cooperationContractFoundBytes []byte
		for _, undertaker := range cooperationContractFound.Undertakers {
			jsons, errs := json.Marshal(undertaker)
			if errs != nil {
				fmt.Printf(errs.Error())
			}
			cooperationContractFoundBytes = append(cooperationContractFoundBytes, jsons...)
		}
		cooperationContractFoundHashValue := md5.Sum(cooperationContractFoundBytes)
		cooperationContractFoundHashString := hex.EncodeToString(cooperationContractFoundHashValue[:])

		// 计算更新后的合约哈希值
		var cooperationContractBytes []byte
		for _, undertaker := range cooperationContract.Undertakers {
			jsons, errs := json.Marshal(undertaker) //转换成JSON返回的是byte[]
			if errs != nil {
				fmt.Printf(errs.Error())
			}
			cooperationContractBytes = append(cooperationContractBytes, jsons...)
		}
		cooperationContractHashValue := md5.Sum(cooperationContractBytes)
		cooperationContractHashString := hex.EncodeToString(cooperationContractHashValue[:])

		if cooperationContractFoundHashString != cooperationContractHashString { // 【1（张三，李四，王五）2（买买买，，）】变更为【1（张三，，）】
			// 原承接人
			var undertakersOriginal string
			for i, undertaker := range cooperationContractFound.Undertakers {
				if undertaker.Referrer == nil {
					undertaker.Referrer = &domain.Referrer{
						UserId:     0,
						UserBaseId: 0,
						Roles:      nil,
						Orgs:       nil,
						Org:        nil,
						Department: nil,
						Company:    nil,
						UserInfo:   nil,
						UserType:   0,
						UserName:   "",
						UserPhone:  "",
					}
				}
				if undertaker.Salesman == nil {
					undertaker.Salesman = &domain.Salesman{
						UserId:     0,
						UserBaseId: 0,
						Roles:      nil,
						Orgs:       nil,
						Org:        nil,
						Department: nil,
						Company:    nil,
						UserInfo:   nil,
						UserType:   0,
						UserName:   "",
						UserPhone:  "",
					}
				}
				undertakersOriginal = undertakersOriginal + strconv.FormatInt(int64(i+1), 10) + "（" + undertaker.UserInfo.UserName + "，" + undertaker.Referrer.UserName + "，" + undertaker.Salesman.UserName + "）"
			}
			undertakerChangeTmp1 := "【" + undertakersOriginal + "】"

			// 变更承接人
			var undertakersChanged string
			for i, undertaker := range cooperationContract.Undertakers {
				if undertaker.Referrer == nil {
					undertaker.Referrer = &domain.Referrer{
						UserId:     0,
						UserBaseId: 0,
						Roles:      nil,
						Orgs:       nil,
						Org:        nil,
						Department: nil,
						Company:    nil,
						UserInfo:   nil,
						UserType:   0,
						UserName:   "",
						UserPhone:  "",
					}
				}
				if undertaker.Salesman == nil {
					undertaker.Salesman = &domain.Salesman{
						UserId:     0,
						UserBaseId: 0,
						Roles:      nil,
						Orgs:       nil,
						Org:        nil,
						Department: nil,
						Company:    nil,
						UserInfo:   nil,
						UserType:   0,
						UserName:   "",
						UserPhone:  "",
					}
				}
				undertakersChanged = undertakersChanged + strconv.FormatInt(int64(i+1), 10) + "（" + undertaker.UserInfo.UserName + "，" + undertaker.Referrer.UserName + "，" + undertaker.Salesman.UserName + "）"
			}
			undertakerChangeTemp2 := "【" + undertakersChanged + "】"
			// 拼接承接人变更记录
			undertakerChange = undertakerChangeTmp1 + " 变更为 " + undertakerChangeTemp2
		}

		// 新增共创合约变更记录
		newCooperationContractChangeLog := &domain.CooperationContractChangeLog{
			IncentivesRule:            incentivesRuleChange,
			IncentivesRuleDetail:      incentivesRuleChangeDetail,
			OperationType:             domain.EDIT,
			Undertakers:               undertakerChange,
			CooperationContractNumber: cooperationContract.CooperationContractNumber,
			Company:                   company,
			Org:                       organization,
			Operator:                  operator,
			OperatorTime:              time.Now(),
			UpdatedAt:                 time.Time{},
			CreatedAt:                 time.Now(),
		}

		// 保存共创合约变更记录
		if newCooperationContractChangeLog.IncentivesRule != "" || newCooperationContractChangeLog.IncentivesRuleDetail != "" || newCooperationContractChangeLog.Undertakers != "" {
			if _, err20 := cooperationContractChangeLogRepository.Save(newCooperationContractChangeLog); err20 != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err20.Error())
			}
		}

		if err = cooperationContractService.UpdateCooperationProjectStaticsInfo(transactionContext,
			updateCooperationContractCommand.CompanyId,
			updateCooperationContractCommand.OrgId,
			updateCooperationContractCommand.CooperationProjectNumber); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		if err21 := transactionContext.CommitTransaction(); err21 != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err21.Error())
		}

		// 推送消息
		if len(undertakersToAdd) > 0 {
			var jointDataSlices []service.JoinData
			for _, undertakerToAdd := range undertakersToAdd {
				jointDataSlices = append(jointDataSlices, service.JoinData{
					CreationContractId:     cooperationContract.CooperationContractId,
					CreationContractName:   cooperationContract.CooperationContractName,
					CreationContractNumber: cooperationContract.CooperationContractNumber,
					CreationProjectId:      cooperationProject.CooperationProjectId,
					CreationProjectNumber:  cooperationProject.CooperationProjectNumber,
					CreationProjectName:    cooperationProject.CooperationProjectName,
					UserId:                 undertakerToAdd.UserId,
					UserBaseId:             undertakerToAdd.UserBaseId,
					OrgId:                  undertakerToAdd.Org.OrgId,
					CompanyId:              undertakerToAdd.Company.CompanyId,
				})
			}
			if err14 := informJoinCreationContractService.Join(jointDataSlices); err14 != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err14.Error())
			}
		}

		return cooperationContractSaved, nil
	}
}

// 更新共创项目统计数据（申请人数 、 合约数）
func (cooperationContractService *CooperationContractService) UpdateCooperationProjectStaticsInfo(transactionContext application.TransactionContext,
	companyId, orgId int64,
	cooperationProjectNumber string) error {
	cooperationProjectRepository, _ := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	project, err := cooperationProjectRepository.FindOne(map[string]interface{}{
		"companyId":                companyId,
		"orgId":                    orgId,
		"cooperationProjectNumber": cooperationProjectNumber,
	})
	if err != nil {
		return err
	}

	cooperationContractDao, _ := dao.NewCooperationContractDao(transactionContext.(*pg.TransactionContext))
	total, contracts, err := cooperationContractDao.Find(map[string]interface{}{
		"companyId":                companyId,
		"orgId":                    orgId,
		"cooperationProjectNumber": cooperationProjectNumber,
		"offsetLimit":              false,
	})
	if err != nil {
		return err
	}
	project.ContractCount = int32(total)

	// 共创合约数量
	cooperationContractIds := make([]int64, 0)
	for i := range contracts {
		cooperationContractIds = append(cooperationContractIds, contracts[i].CooperationContractId)
	}

	// 承接人数量
	cooperationContractUndertakerRepository, _ := dao.NewCooperationContractUndertakerDao(transactionContext.(*pg.TransactionContext))
	_, underTakers, err := cooperationContractUndertakerRepository.Find(map[string]interface{}{
		"companyId":                companyId,
		"orgId":                    orgId,
		"cooperationProjectNumber": cooperationProjectNumber,
		"cooperationContractIds":   cooperationContractIds,
		"offsetLimit":              false,
	})
	if err != nil {
		return err
	}
	var count = 0
	var mapDupUser = make(map[int64]int64)
	var funcRemoveDuplicate = func(userBaseId int64) {
		if _, ok := mapDupUser[userBaseId]; !ok {
			mapDupUser[userBaseId] = userBaseId
			count += 1 // 默认承接人
		}
	}
	for i := range underTakers {
		item := underTakers[i]
		funcRemoveDuplicate(item.Undertaker.UserBaseId)
		//if item.Undertaker.Referrer != nil && item.Undertaker.Referrer.UserBaseId != 0 {
		//	funcRemoveDuplicate(item.Undertaker.Referrer.UserBaseId)
		//}
		//if item.Undertaker.Salesman != nil && item.Undertaker.Salesman.UserBaseId != 0 {
		//	funcRemoveDuplicate(item.Undertaker.Salesman.UserBaseId)
		//}
	}
	project.ApplicantCount = int32(count)
	if _, err := cooperationProjectRepository.Save(project); err != nil {
		return err
	}
	return nil
}

func NewCooperationContractService(options map[string]interface{}) *CooperationContractService {
	newCooperationContractService := &CooperationContractService{}
	return newCooperationContractService
}