package repository

import (
	"fmt"
	"github.com/go-pg/pg/v10"
	"github.com/linmadan/egglib-go/persistent/pg/sqlbuilder"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"github.com/linmadan/egglib-go/utils/snowflake"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/pg/models"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/pg/transform"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/utils"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/log"
	"time"
)

type CooperationContractRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

func (repository *CooperationContractRepository) nextIdentify() (int64, error) {
	IdWorker, err := snowflake.NewIdWorker(1)
	if err != nil {
		return 0, err
	}
	id, err := IdWorker.NextId()
	return id, err
}

func (repository *CooperationContractRepository) Save(cooperationContract *domain.CooperationContract) (*domain.CooperationContract, error) {
	sqlBuildFields := []string{
		"cooperation_contract_id",
		"cooperation_contract_description",
		"cooperation_contract_name",
		"cooperation_contract_number",
		"cooperation_project_number",
		"cooperation_contract_undertaker_types",
		"cooperation_contract_sponsor",
		"cooperation_mode_number",
		"status",
		"org",
		"incentives_type",
		"company",
		"department",
		"operator",
		"operate_time",
		"created_at",
		"deleted_at",
		"updated_at",
	}
	insertFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlBuildFields)
	insertPlaceHoldersSnippet := sqlbuilder.SqlPlaceHoldersSnippet(sqlBuildFields)
	returningFieldsSnippet := sqlbuilder.SqlFieldsSnippet(sqlBuildFields)
	updateFields := sqlbuilder.RemoveSqlFields(sqlBuildFields, "cooperationContract_id")
	updateFieldsSnippet := sqlbuilder.SqlUpdateFieldsSnippet(updateFields)
	tx := repository.transactionContext.PgTx
	if cooperationContract.Identify() == nil {
		cooperationContractId, err := repository.nextIdentify()
		if err != nil {
			return cooperationContract, err
		} else {
			cooperationContract.CooperationContractId = cooperationContractId
		}
		if _, err := tx.QueryOne(
			pg.Scan(
				&cooperationContract.CooperationContractId,
				&cooperationContract.CooperationContractDescription,
				&cooperationContract.CooperationContractName,
				&cooperationContract.CooperationContractNumber,
				&cooperationContract.CooperationProjectNumber,
				pg.Array(&cooperationContract.CooperationContractUndertakerTypes),
				&cooperationContract.CooperationContractSponsor,
				&cooperationContract.CooperationMode.CooperationModeNumber,
				&cooperationContract.Status,
				&cooperationContract.Org,
				&cooperationContract.IncentivesType,
				&cooperationContract.Company,
				&cooperationContract.Department,
				&cooperationContract.Operator,
				&cooperationContract.OperateTime,
				&cooperationContract.CreatedAt,
				&cooperationContract.DeletedAt,
				&cooperationContract.UpdatedAt,
			),
			fmt.Sprintf("INSERT INTO cooperation_contracts (%s) VALUES (%s) RETURNING %s", insertFieldsSnippet, insertPlaceHoldersSnippet, returningFieldsSnippet),
			cooperationContract.CooperationContractId,
			cooperationContract.CooperationContractDescription,
			cooperationContract.CooperationContractName,
			cooperationContract.CooperationContractNumber,
			cooperationContract.CooperationProjectNumber,
			pg.Array(cooperationContract.CooperationContractUndertakerTypes),
			cooperationContract.CooperationContractSponsor,
			cooperationContract.CooperationMode.CooperationModeNumber,
			cooperationContract.Status,
			cooperationContract.Org,
			cooperationContract.IncentivesType,
			cooperationContract.Company,
			cooperationContract.Department,
			cooperationContract.Operator,
			cooperationContract.OperateTime,
			cooperationContract.CreatedAt,
			nil,
			cooperationContract.UpdatedAt,
		); err != nil {
			return cooperationContract, err
		}

		// 新增相关人
		var relevantPeopleModel []*models.CooperationContractRelevant
		for _, relevant := range cooperationContract.RelevantPeople {
			relevantPeopleModel = append(relevantPeopleModel, &models.CooperationContractRelevant{
				CooperationContractNumber: cooperationContract.CooperationContractNumber,
				UserId:                    relevant.UserId,
				UserBaseId:                relevant.UserBaseId,
				Org:                       relevant.Org,
				Orgs:                      relevant.Orgs,
				Department:                relevant.Department,
				Roles:                     relevant.Roles,
				UserInfo:                  relevant.UserInfo,
				UserType:                  relevant.UserType,
				Status:                    relevant.Status,
				Company:                   relevant.Company,
				UpdatedAt:                 time.Time{},
				DeletedAt:                 time.Time{},
				CreatedAt:                 time.Now(),
			})
		}
		log.Logger.Info("新增的相关人", map[string]interface{}{
			"relevantPeopleModel": relevantPeopleModel,
		})
		if len(relevantPeopleModel) > 0 {
			if _, err := tx.Model(&relevantPeopleModel).Insert(); err != nil {
				return nil, err
			}
		}

		// 新增承接人
		var undertakersModel []*models.CooperationContractUndertaker
		for _, undertaker := range cooperationContract.Undertakers {
			undertakersModel = append(undertakersModel, &models.CooperationContractUndertaker{
				CooperationContractNumber: cooperationContract.CooperationContractNumber,
				UserId:                    undertaker.UserId,
				UserBaseId:                undertaker.UserBaseId,
				Org:                       undertaker.Org,
				Orgs:                      undertaker.Orgs,
				Department:                undertaker.Department,
				Roles:                     undertaker.Roles,
				UserInfo:                  undertaker.UserInfo,
				UserType:                  undertaker.UserType,
				Referrer:                  undertaker.Referrer,
				Salesman:                  undertaker.Salesman,
				Status:                    undertaker.Status,
				Company:                   undertaker.Company,
				ContractAttachment:        undertaker.ContractAttachment,
				CreatedAt:                 time.Time{},
				UpdatedAt:                 time.Time{},
				DeletedAt:                 time.Now(),
			})
		}
		if len(undertakersModel) > 0 {
			if _, err := tx.Model(&undertakersModel).Insert(); err != nil {
				return nil, err
			}
		}

		// 新增分红激励规则
		var dividendsIncentivesRulesModel []*models.DividendsIncentivesRule
		for _, rule := range cooperationContract.DividendsIncentivesRules {
			dividendsIncentivesRulesModel = append(dividendsIncentivesRulesModel, &models.DividendsIncentivesRule{
				DividendsIncentivesRuleId:     0,
				CooperationContractNumber:     cooperationContract.CooperationContractNumber,
				ReferrerPercentage:            rule.ReferrerPercentage,
				SalesmanPercentage:            rule.SalesmanPercentage,
				DividendsIncentivesPercentage: rule.DividendsIncentivesPercentage,
				DividendsIncentivesStage:      rule.DividendsIncentivesStage,
				DividendsIncentivesStageStart: rule.DividendsIncentivesStageStart,
				DividendsIncentivesStageEnd:   rule.DividendsIncentivesStageEnd,
				Org:                           rule.Org,
				Company:                       rule.Company,
				UpdatedAt:                     time.Time{},
				DeletedAt:                     time.Time{},
				CreatedAt:                     time.Now(),
				Remarks:                       rule.Remarks,
			})
		}
		if len(dividendsIncentivesRulesModel) > 0 {
			if _, err := tx.Model(&dividendsIncentivesRulesModel).Insert(); err != nil {
				return nil, err
			}
		}

		// 新增金额激励规则
		var moneyIncentivesRulesModel []*models.MoneyIncentivesRule
		for _, rule := range cooperationContract.MoneyIncentivesRules {
			moneyIncentivesRulesModel = append(moneyIncentivesRulesModel, &models.MoneyIncentivesRule{
				MoneyIncentivesRuleId:     0,
				CooperationContractNumber: cooperationContract.CooperationContractNumber,
				MoneyIncentivesAmount:     rule.MoneyIncentivesAmount,
				MoneyIncentivesStage:      rule.MoneyIncentivesStage,
				MoneyIncentivesStageStart: rule.MoneyIncentivesStageStart,
				MoneyIncentivesStageEnd:   rule.MoneyIncentivesStageEnd,
				MoneyIncentivesTime:       rule.MoneyIncentivesTime,
				ReferrerPercentage:        rule.ReferrerPercentage,
				SalesmanPercentage:        rule.SalesmanPercentage,
				Org:                       rule.Org,
				Company:                   rule.Company,
				UpdatedAt:                 time.Time{},
				DeletedAt:                 time.Time{},
				CreatedAt:                 time.Now(),
				Remarks:                   rule.Remarks,
			})
		}
		if len(moneyIncentivesRulesModel) > 0 {
			if _, err := tx.Model(&moneyIncentivesRulesModel).Insert(); err != nil {
				return nil, err
			}
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(
				&cooperationContract.CooperationContractId,
				&cooperationContract.CooperationContractDescription,
				&cooperationContract.CooperationContractName,
				&cooperationContract.CooperationContractNumber,
				&cooperationContract.CooperationProjectNumber,
				pg.Array(&cooperationContract.CooperationContractUndertakerTypes),
				&cooperationContract.CooperationContractSponsor,
				&cooperationContract.CooperationMode.CooperationModeNumber,
				&cooperationContract.Status,
				&cooperationContract.Org,
				&cooperationContract.IncentivesType,
				&cooperationContract.Company,
				&cooperationContract.Department,
				&cooperationContract.Operator,
				&cooperationContract.OperateTime,
				&cooperationContract.CreatedAt,
				&cooperationContract.DeletedAt,
				&cooperationContract.UpdatedAt,
			),
			fmt.Sprintf("UPDATE cooperation_contracts SET %s WHERE cooperation_contract_id=? RETURNING %s", updateFieldsSnippet, returningFieldsSnippet),
			cooperationContract.CooperationContractId,
			cooperationContract.CooperationContractDescription,
			cooperationContract.CooperationContractName,
			cooperationContract.CooperationContractNumber,
			cooperationContract.CooperationProjectNumber,
			pg.Array(cooperationContract.CooperationContractUndertakerTypes),
			cooperationContract.CooperationContractSponsor,
			cooperationContract.CooperationMode.CooperationModeNumber,
			cooperationContract.Status,
			cooperationContract.Org,
			cooperationContract.IncentivesType,
			cooperationContract.Company,
			cooperationContract.Department,
			cooperationContract.Operator,
			cooperationContract.OperateTime,
			cooperationContract.CreatedAt,
			nil,
			cooperationContract.UpdatedAt,
			cooperationContract.Identify(),
		); err != nil {
			return cooperationContract, err
		}

		/******************************* 更新相关人 ****************************/
		// 查找相关人列表
		var cooperationContractRelevantModelsFetched []*models.CooperationContractRelevant
		cooperationContractRelevantQuery := tx.Model(&cooperationContractRelevantModelsFetched)
		if err := cooperationContractRelevantQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}

		// 提取相关人id
		var cooperationContractRelevantIdsFetched []int64
		for _, cooperationContractRelevant := range cooperationContractRelevantModelsFetched {
			cooperationContractRelevantIdsFetched = append(cooperationContractRelevantIdsFetched, cooperationContractRelevant.CooperationContractRelevantId)
		}

		// 待更新相关人
		var cooperationContractRelevantPeopleToUpdate []*domain.Relevant

		// 待添加相关人
		var cooperationContractRelevantPeopleToAdd []*domain.Relevant
		for _, relevant := range cooperationContract.RelevantPeople {
			if relevant.RelevantId != 0 {
				cooperationContractRelevantPeopleToUpdate = append(cooperationContractRelevantPeopleToUpdate, relevant)
			} else {
				cooperationContractRelevantPeopleToAdd = append(cooperationContractRelevantPeopleToAdd, relevant)
			}
		}

		// 将待添加的相关人领域模型转换为数据模型
		var cooperationContractRelevantPeopleToAddModels []*models.CooperationContractRelevant
		for _, relevantDomain := range cooperationContractRelevantPeopleToAdd {
			cooperationContractRelevantPeopleToAddModels = append(cooperationContractRelevantPeopleToAddModels, &models.CooperationContractRelevant{
				CooperationContractRelevantId: 0,
				CooperationContractNumber:     relevantDomain.CooperationContractNumber,
				UserId:                        relevantDomain.UserId,
				UserBaseId:                    relevantDomain.UserBaseId,
				Org:                           relevantDomain.Org,
				Orgs:                          relevantDomain.Orgs,
				Department:                    relevantDomain.Department,
				Roles:                         relevantDomain.Roles,
				UserInfo:                      relevantDomain.UserInfo,
				UserType:                      relevantDomain.UserType,
				Status:                        relevantDomain.Status,
				Company:                       relevantDomain.Company,
				UpdatedAt:                     time.Time{},
				DeletedAt:                     time.Time{},
				CreatedAt:                     time.Now(),
			})
		}

		// 添加相关人
		if len(cooperationContractRelevantPeopleToAddModels) > 0 {
			if _, err := tx.Model(&cooperationContractRelevantPeopleToAddModels).Insert(); err != nil {
				return nil, err
			}
		}

		// 待更新或者删除的ids
		var cooperationContractRelevantPeopleToUpdateOrDeleteIds []int64
		for _, cooperationContractRelevantPersonToUpdate := range cooperationContractRelevantPeopleToUpdate {
			cooperationContractRelevantPeopleToUpdateOrDeleteIds = append(cooperationContractRelevantPeopleToUpdateOrDeleteIds, cooperationContractRelevantPersonToUpdate.RelevantId)
		}

		// 待更新的相关人id
		relevantIdsToUpdate := utils.Intersect(cooperationContractRelevantIdsFetched, cooperationContractRelevantPeopleToUpdateOrDeleteIds)
		var relevantModelsToUpdate []*models.CooperationContractRelevant
		for _, id := range relevantIdsToUpdate {
			for _, relevantModel := range cooperationContractRelevantModelsFetched {
				if relevantModel.CooperationContractRelevantId == id {
					relevantModelsToUpdate = append(relevantModelsToUpdate, relevantModel)
				}
			}
		}
		if len(relevantModelsToUpdate) > 0 {
			if _, err := tx.Model(&relevantModelsToUpdate).WherePK().Update(); err != nil {
				return nil, err
			}
		}

		// 待删除的相关人id
		relevantIdsToDelete := utils.Difference(cooperationContractRelevantIdsFetched, cooperationContractRelevantPeopleToUpdateOrDeleteIds)
		var relevantModelsToDelete []*models.CooperationContractRelevant
		for _, id := range relevantIdsToDelete {
			for _, relevantModel := range cooperationContractRelevantModelsFetched {
				if relevantModel.CooperationContractRelevantId == id {
					relevantModelsToDelete = append(relevantModelsToDelete, relevantModel)
				}
			}
		}
		log.Logger.Info("待删除的相关人", map[string]interface{}{
			"待删除的相关人": relevantModelsToDelete,
		})
		if len(relevantModelsToDelete) > 0 {
			if _, err := tx.Model(&relevantModelsToDelete).Delete(); err != nil {
				return nil, err
			}
		}

		/************************* 更新承接人 ****************************/
		// 获取承接人列表
		var cooperationContractUndertakersModelsFetched []*models.CooperationContractUndertaker
		cooperationContractUndertakerQuery := tx.Model(&cooperationContractUndertakersModelsFetched)
		if err := cooperationContractUndertakerQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}

		// 提取承接人id
		var cooperationContractUndertakersIdsFetched []int64
		for _, cooperationContractUndertaker := range cooperationContractUndertakersModelsFetched {
			cooperationContractUndertakersIdsFetched = append(cooperationContractUndertakersIdsFetched, cooperationContractUndertaker.CooperationContractUndertakerId)
		}

		// 待更新相关人
		var cooperationContractUndertakersToUpdate []*domain.Undertaker
		// 待添加相关人
		var cooperationContractUndertakersToAdd []*domain.Undertaker
		for _, undertaker := range cooperationContract.Undertakers {
			if undertaker.UndertakerId != 0 {
				cooperationContractUndertakersToUpdate = append(cooperationContractUndertakersToUpdate, undertaker)
			} else {
				cooperationContractUndertakersToAdd = append(cooperationContractUndertakersToAdd, undertaker)
			}
		}

		// 将待添加的相关人领域模型转换为数据模型
		var cooperationContractUndertakersToAddModels []*models.CooperationContractUndertaker
		for _, undertakerDomain := range cooperationContractUndertakersToAdd {
			cooperationContractUndertakersToAddModels = append(cooperationContractUndertakersToAddModels, &models.CooperationContractUndertaker{
				CooperationContractNumber: undertakerDomain.CooperationContractNumber,
				UserId:                    undertakerDomain.UserId,
				UserBaseId:                undertakerDomain.UserBaseId,
				Org:                       undertakerDomain.Org,
				Orgs:                      undertakerDomain.Orgs,
				Department:                undertakerDomain.Department,
				Roles:                     undertakerDomain.Roles,
				UserInfo:                  undertakerDomain.UserInfo,
				UserType:                  undertakerDomain.UserType,
				Referrer:                  undertakerDomain.Referrer,
				Salesman:                  undertakerDomain.Salesman,
				Status:                    undertakerDomain.Status,
				Company:                   undertakerDomain.Company,
				ContractAttachment:        undertakerDomain.ContractAttachment,
				UpdatedAt:                 time.Time{},
				DeletedAt:                 time.Time{},
				CreatedAt:                 time.Now(),
			})
		}
		log.Logger.Info("待添加的承接人", map[string]interface{}{
			"待添加的承接人": cooperationContractUndertakersToAddModels,
		})
		// 添加承接人
		if len(cooperationContractUndertakersToAddModels) > 0 {
			if _, err := tx.Model(&cooperationContractUndertakersToAddModels).Insert(); err != nil {
				return nil, err
			}
		}

		// 待更新或者删除的ids
		var cooperationContractUndertakersToUpdateOrDeleteIds []int64
		for _, cooperationContractUndertakerToUpdate := range cooperationContractUndertakersToUpdate {
			cooperationContractUndertakersToUpdateOrDeleteIds = append(cooperationContractUndertakersToUpdateOrDeleteIds, cooperationContractUndertakerToUpdate.UndertakerId)
		}

		// 待更新的承接人id
		undertakerIdsToUpdate := utils.Intersect(cooperationContractUndertakersIdsFetched, cooperationContractUndertakersToUpdateOrDeleteIds)
		var undertakerModelsToUpdate []*models.CooperationContractUndertaker
		for _, id := range undertakerIdsToUpdate {
			for _, undertakerModel := range cooperationContractUndertakersModelsFetched {
				if undertakerModel.CooperationContractUndertakerId == id {
					undertakerModelsToUpdate = append(undertakerModelsToUpdate, undertakerModel)
				}
			}
		}
		log.Logger.Info("待更新的承接人", map[string]interface{}{
			"待更新的承接人": undertakerModelsToUpdate,
		})
		for i, undertakerModelToUpdate := range undertakerModelsToUpdate {
			for j, undertaker := range cooperationContract.Undertakers {
				if undertaker.UndertakerId == undertakerModelToUpdate.CooperationContractUndertakerId {
					undertakerModelsToUpdate[i] = &models.CooperationContractUndertaker{
						CooperationContractUndertakerId: cooperationContract.Undertakers[j].UndertakerId,
						CooperationContractNumber:       cooperationContract.Undertakers[j].CooperationContractNumber,
						UserId:                          cooperationContract.Undertakers[j].UserId,
						UserBaseId:                      cooperationContract.Undertakers[j].UserBaseId,
						Org:                             cooperationContract.Undertakers[j].Org,
						Orgs:                            cooperationContract.Undertakers[j].Orgs,
						Department:                      cooperationContract.Undertakers[j].Department,
						Roles:                           cooperationContract.Undertakers[j].Roles,
						UserInfo:                        cooperationContract.Undertakers[j].UserInfo,
						UserType:                        cooperationContract.Undertakers[j].UserType,
						Referrer:                        cooperationContract.Undertakers[j].Referrer,
						Salesman:                        cooperationContract.Undertakers[j].Salesman,
						Status:                          cooperationContract.Undertakers[j].Status,
						Company:                         cooperationContract.Undertakers[j].Company,
						ContractAttachment:              cooperationContract.Undertakers[j].ContractAttachment,
						CreatedAt:                       undertakerModelsToUpdate[i].CreatedAt,
						UpdatedAt:                       time.Now(),
						DeletedAt:                       undertakerModelsToUpdate[i].DeletedAt,
					}
				}
			}
		}
		if len(undertakerModelsToUpdate) > 0 {
			if _, err := tx.Model(&undertakerModelsToUpdate).WherePK().Update(); err != nil {
				return nil, err
			}
		}

		// 待删除的承接人id
		undertakerIdsToDelete := utils.Difference(cooperationContractUndertakersIdsFetched, cooperationContractUndertakersToUpdateOrDeleteIds)
		var undertakerModelsToDelete []*models.CooperationContractUndertaker
		for _, id := range undertakerIdsToDelete {
			for _, undertakerModel := range cooperationContractUndertakersModelsFetched {
				if undertakerModel.CooperationContractUndertakerId == id {
					undertakerModelsToDelete = append(undertakerModelsToDelete, undertakerModel)
				}
			}
		}
		log.Logger.Info("待删除的承接人", map[string]interface{}{
			"待删除的承接人": undertakerModelsToDelete,
		})
		if len(undertakerModelsToDelete) > 0 {
			if _, err := tx.Model(&undertakerModelsToDelete).Delete(); err != nil {
				return nil, err
			}
		}

		/************************ 更新分红激励规则 **************************/
		// 获取分红激励规则列表
		var dividendsIncentivesRulesFetched []*models.DividendsIncentivesRule
		dividendsIncentivesRuleQuery := tx.Model(&dividendsIncentivesRulesFetched)
		if err := dividendsIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}

		// 提取分红激励规则id
		var dividendsIncentivesRuleIdsFetched []int64
		for _, dividendsIncentivesRule := range dividendsIncentivesRulesFetched {
			dividendsIncentivesRuleIdsFetched = append(dividendsIncentivesRuleIdsFetched, dividendsIncentivesRule.DividendsIncentivesRuleId)
		}

		// 待更新分红激励规则
		var dividendsIncentivesRulesToUpdate []*domain.DividendsIncentivesRule
		// 待添加分红激励规则
		var dividendsIncentivesRulesToAdd []*domain.DividendsIncentivesRule
		for _, dividendsIncentivesRule := range cooperationContract.DividendsIncentivesRules {
			if dividendsIncentivesRule.DividendsIncentivesRuleId != 0 {
				dividendsIncentivesRulesToUpdate = append(dividendsIncentivesRulesToUpdate, dividendsIncentivesRule)
			} else {
				dividendsIncentivesRulesToAdd = append(dividendsIncentivesRulesToAdd, dividendsIncentivesRule)
			}
		}

		// 将待添加的分红激励规则领域模型转换为数据模型
		var dividendsIncentivesRulesToAddModels []*models.DividendsIncentivesRule
		for _, dividendsIncentivesRuleDomain := range dividendsIncentivesRulesToAdd {
			dividendsIncentivesRulesToAddModels = append(dividendsIncentivesRulesToAddModels, &models.DividendsIncentivesRule{
				CooperationContractNumber:     dividendsIncentivesRuleDomain.CooperationContractNumber,
				ReferrerPercentage:            dividendsIncentivesRuleDomain.ReferrerPercentage,
				SalesmanPercentage:            dividendsIncentivesRuleDomain.SalesmanPercentage,
				DividendsIncentivesPercentage: dividendsIncentivesRuleDomain.DividendsIncentivesPercentage,
				DividendsIncentivesStage:      dividendsIncentivesRuleDomain.DividendsIncentivesStage,
				DividendsIncentivesStageEnd:   dividendsIncentivesRuleDomain.DividendsIncentivesStageEnd,
				DividendsIncentivesStageStart: dividendsIncentivesRuleDomain.DividendsIncentivesStageStart,
				Remarks:                       dividendsIncentivesRuleDomain.Remarks,
				Org:                           dividendsIncentivesRuleDomain.Org,
				Company:                       dividendsIncentivesRuleDomain.Company,
				UpdatedAt:                     time.Time{},
				DeletedAt:                     time.Time{},
				CreatedAt:                     time.Now(),
			})
		}
		// 添加分红激励规则
		log.Logger.Info("待添加的分红激励规则", map[string]interface{}{
			"dividendsIncentivesRulesToAddModels": dividendsIncentivesRulesToAddModels,
		})
		if len(dividendsIncentivesRulesToAddModels) > 0 {
			if _, err := tx.Model(&dividendsIncentivesRulesToAddModels).Insert(); err != nil {
				return nil, err
			}
		}

		// 待更新或者删除的ids
		var dividendsIncentivesRulesToUpdateOrDeleteIds []int64
		for _, dividendsIncentivesRuleToUpdate := range dividendsIncentivesRulesToUpdate {
			dividendsIncentivesRulesToUpdateOrDeleteIds = append(dividendsIncentivesRulesToUpdateOrDeleteIds, dividendsIncentivesRuleToUpdate.DividendsIncentivesRuleId)
		}

		// 待更新的分红激励规则id
		dividendsRuleIdsToUpdate := utils.Intersect(dividendsIncentivesRuleIdsFetched, dividendsIncentivesRulesToUpdateOrDeleteIds)
		var dividendsRuleModelsToUpdate []*models.DividendsIncentivesRule
		for _, id := range dividendsRuleIdsToUpdate {
			for _, dividendsIncentivesRuleModel := range dividendsIncentivesRulesFetched {
				if dividendsIncentivesRuleModel.DividendsIncentivesRuleId == id {
					dividendsRuleModelsToUpdate = append(dividendsRuleModelsToUpdate, dividendsIncentivesRuleModel)
				}
			}
		}
		log.Logger.Info("待更新的分红激励规则", map[string]interface{}{
			"dividendsRuleModelsToUpdate": dividendsRuleModelsToUpdate,
		})
		if len(dividendsRuleModelsToUpdate) > 0 {
			if _, err := tx.Model(&dividendsRuleModelsToUpdate).WherePK().Update(); err != nil {
				return nil, err
			}
		}

		// 待删除的分红激励规则id
		dividendsIncentivesRuleIdsToDelete := utils.Difference(dividendsIncentivesRuleIdsFetched, dividendsIncentivesRulesToUpdateOrDeleteIds)
		var dividendsIncentivesRuleModelsToDelete []*models.DividendsIncentivesRule
		for _, id := range dividendsIncentivesRuleIdsToDelete {
			for _, dividendsIncentivesRuleModel := range dividendsIncentivesRulesFetched {
				if dividendsIncentivesRuleModel.DividendsIncentivesRuleId == id {
					dividendsIncentivesRuleModelsToDelete = append(dividendsIncentivesRuleModelsToDelete, dividendsIncentivesRuleModel)
				}
			}
		}
		log.Logger.Info("待删除的分红激励规则", map[string]interface{}{})
		if len(dividendsIncentivesRuleModelsToDelete) > 0 {
			if _, err := tx.Model(&dividendsIncentivesRuleModelsToDelete).WherePK().Delete(); err != nil {
				return nil, err
			}
		}

		/********************** 更新金额激励规则 **************************/
		var moneyIncentivesRulesFetched []*models.MoneyIncentivesRule
		moneyIncentivesRuleQuery := tx.Model(&moneyIncentivesRulesFetched)
		if err := moneyIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}

		// 提取金额激励规则id
		var moneyIncentivesRuleIdsFetched []int64
		for _, moneyIncentivesRule := range moneyIncentivesRulesFetched {
			moneyIncentivesRuleIdsFetched = append(moneyIncentivesRuleIdsFetched, moneyIncentivesRule.MoneyIncentivesRuleId)
		}

		// 待更新金额激励规则
		var moneyIncentivesRulesToUpdate []*domain.MoneyIncentivesRule
		// 待添加金额激励规则
		var moneyIncentivesRulesToAdd []*domain.MoneyIncentivesRule
		for _, moneyIncentivesRule := range cooperationContract.MoneyIncentivesRules {
			if moneyIncentivesRule.MoneyIncentivesRuleId != 0 {
				moneyIncentivesRulesToUpdate = append(moneyIncentivesRulesToUpdate, moneyIncentivesRule)
			} else {
				moneyIncentivesRulesToAdd = append(moneyIncentivesRulesToAdd, moneyIncentivesRule)
			}
		}

		// 将待添加的金额激励规则领域模型转换为数据模型
		var moneyIncentivesRulesToAddModels []*models.MoneyIncentivesRule
		for _, moneyIncentivesRuleDomain := range moneyIncentivesRulesToAdd {
			moneyIncentivesRulesToAddModels = append(moneyIncentivesRulesToAddModels, &models.MoneyIncentivesRule{
				CooperationContractNumber: moneyIncentivesRuleDomain.CooperationContractNumber,
				MoneyIncentivesAmount:     moneyIncentivesRuleDomain.MoneyIncentivesAmount,
				MoneyIncentivesStage:      moneyIncentivesRuleDomain.MoneyIncentivesStage,
				MoneyIncentivesStageEnd:   moneyIncentivesRuleDomain.MoneyIncentivesStageEnd,
				MoneyIncentivesStageStart: moneyIncentivesRuleDomain.MoneyIncentivesStageStart,
				MoneyIncentivesTime:       moneyIncentivesRuleDomain.MoneyIncentivesTime,
				ReferrerPercentage:        moneyIncentivesRuleDomain.ReferrerPercentage,
				SalesmanPercentage:        moneyIncentivesRuleDomain.SalesmanPercentage,
				Remarks:                   moneyIncentivesRuleDomain.Remarks,
				Org:                       moneyIncentivesRuleDomain.Org,
				Company:                   moneyIncentivesRuleDomain.Company,
				UpdatedAt:                 time.Time{},
				DeletedAt:                 time.Time{},
				CreatedAt:                 time.Now(),
			})
		}
		// 添加金额激励规则
		log.Logger.Info("待添加的金额激励规则", map[string]interface{}{
			"moneyIncentivesRulesToAddModels": moneyIncentivesRulesToAddModels,
		})
		if len(moneyIncentivesRulesToAddModels) > 0 {
			if _, err := tx.Model(&moneyIncentivesRulesToAddModels).Insert(); err != nil {
				return nil, err
			}
		}

		// 待更新或者删除的ids
		var moneyIncentivesRulesToUpdateOrDeleteIds []int64
		for _, moneyIncentivesRuleToUpdate := range moneyIncentivesRulesToUpdate {
			moneyIncentivesRulesToUpdateOrDeleteIds = append(moneyIncentivesRulesToUpdateOrDeleteIds, moneyIncentivesRuleToUpdate.MoneyIncentivesRuleId)
		}

		// 待更新的金额激励规则id
		moneyRuleIdsToUpdate := utils.Intersect(moneyIncentivesRuleIdsFetched, moneyIncentivesRulesToUpdateOrDeleteIds)
		var moneyRuleModelsToUpdate []*models.MoneyIncentivesRule
		for _, id := range moneyRuleIdsToUpdate {
			for _, moneyIncentivesRuleModel := range moneyIncentivesRulesFetched {
				if moneyIncentivesRuleModel.MoneyIncentivesRuleId == id {
					moneyRuleModelsToUpdate = append(moneyRuleModelsToUpdate, moneyIncentivesRuleModel)
				}
			}
		}
		log.Logger.Info("待更新的金额激励规则", map[string]interface{}{
			"moneyRuleModelsToUpdate": moneyRuleModelsToUpdate,
		})
		if len(moneyRuleModelsToUpdate) > 0 {
			if _, err := tx.Model(&moneyRuleModelsToUpdate).WherePK().Update(); err != nil {
				return nil, err
			}
		}

		// 待删除的金额激励规则id
		moneyIncentivesRuleIdsToDelete := utils.Difference(moneyIncentivesRuleIdsFetched, moneyIncentivesRulesToUpdateOrDeleteIds)
		var moneyIncentivesRuleModelsToDelete []*models.MoneyIncentivesRule
		for _, id := range moneyIncentivesRuleIdsToDelete {
			for _, moneyIncentivesRuleModel := range moneyIncentivesRulesFetched {
				if moneyIncentivesRuleModel.MoneyIncentivesRuleId == id {
					moneyIncentivesRuleModelsToDelete = append(moneyIncentivesRuleModelsToDelete, moneyIncentivesRuleModel)
				}
			}
		}
		log.Logger.Info("待删除的金额激励规则", map[string]interface{}{
			"moneyIncentivesRuleModelsToDelete": moneyIncentivesRuleModelsToDelete,
		})
		if len(moneyIncentivesRuleModelsToDelete) > 0 {
			if _, err := tx.Model(&moneyIncentivesRuleModelsToDelete).WherePK().Delete(); err != nil {
				return nil, err
			}
		}
	}
	// 返回新增的合约
	cooperationContractSaved, err := repository.FindOne(map[string]interface{}{
		"cooperationContractId": cooperationContract.CooperationContractId,
	})
	if err != nil {
		return nil, err
	}
	return cooperationContractSaved, nil
}

func (repository *CooperationContractRepository) UpdateOne(cooperationContract *domain.CooperationContract) (*domain.CooperationContract, error) {
	tx := repository.transactionContext.PgTx
	cooperationContractModel := new(models.CooperationContract)
	cooperationContractModel = &models.CooperationContract{
		CooperationContractId:              cooperationContract.CooperationContractId,
		CooperationContractDescription:     cooperationContract.CooperationContractDescription,
		CooperationContractName:            cooperationContract.CooperationContractName,
		CooperationContractNumber:          cooperationContract.CooperationContractNumber,
		CooperationProjectNumber:           cooperationContract.CooperationProjectNumber,
		CooperationContractUndertakerTypes: cooperationContract.CooperationContractUndertakerTypes,
		CooperationContractSponsor:         cooperationContract.CooperationContractSponsor,
		CooperationModeNumber:              cooperationContract.CooperationMode.CooperationModeNumber,
		Status:                             cooperationContract.Status,
		Org:                                cooperationContract.Org,
		IncentivesType:                     cooperationContract.IncentivesType,
		Company:                            cooperationContract.Company,
		Department:                         cooperationContract.Department,
		Operator:                           cooperationContract.Operator,
		OperateTime:                        cooperationContract.OperateTime,
		CreatedAt:                          cooperationContract.CreatedAt,
		DeletedAt:                          cooperationContract.DeletedAt,
		UpdatedAt:                          time.Now(),
	}
	if _, err := tx.Model(cooperationContractModel).WherePK().Update(); err != nil {
		return nil, err
	}
	return cooperationContract, nil
}

func (repository *CooperationContractRepository) UpdateMany(cooperationContracts []*domain.CooperationContract) ([]*domain.CooperationContract, error) {
	tx := repository.transactionContext.PgTx
	var cooperationContractModels []*models.CooperationContract
	for _, cooperationContract := range cooperationContracts {
		cooperationContractModels = append(cooperationContractModels, &models.CooperationContract{
			CooperationContractId:              cooperationContract.CooperationContractId,
			CooperationContractDescription:     cooperationContract.CooperationContractDescription,
			CooperationContractName:            cooperationContract.CooperationContractName,
			CooperationContractNumber:          cooperationContract.CooperationContractNumber,
			CooperationProjectNumber:           cooperationContract.CooperationProjectNumber,
			CooperationContractUndertakerTypes: cooperationContract.CooperationContractUndertakerTypes,
			CooperationContractSponsor:         cooperationContract.CooperationContractSponsor,
			CooperationModeNumber:              cooperationContract.CooperationMode.CooperationModeNumber,
			Status:                             cooperationContract.Status,
			Org:                                cooperationContract.Org,
			IncentivesType:                     cooperationContract.IncentivesType,
			Company:                            cooperationContract.Company,
			Department:                         cooperationContract.Department,
			Operator:                           cooperationContract.Operator,
			OperateTime:                        cooperationContract.OperateTime,
			CreatedAt:                          cooperationContract.CreatedAt,
			DeletedAt:                          cooperationContract.DeletedAt,
			UpdatedAt:                          time.Now(),
		})
	}
	if _, err := tx.Model(&cooperationContractModels).WherePK().Update(); err != nil {
		return nil, err
	}
	return cooperationContracts, nil
}

func (repository *CooperationContractRepository) Remove(cooperationContract *domain.CooperationContract) (*domain.CooperationContract, error) {
	tx := repository.transactionContext.PgTx
	cooperationContractModel := new(models.CooperationContract)
	cooperationContractModel.CooperationContractId = cooperationContract.Identify().(int64)
	if _, err := tx.Model(cooperationContractModel).WherePK().Delete(); err != nil {
		return cooperationContract, err
	} else {
		// 获取分红激励规则列表
		var dividendsIncentivesRuleModels []*models.DividendsIncentivesRule
		dividendsIncentivesRuleQuery := tx.Model(&dividendsIncentivesRuleModels)
		if err := dividendsIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		} else {
			if _, err := tx.Model(&dividendsIncentivesRuleModels).WherePK().Delete(); err != nil {
				return nil, err
			}
		}
		// 获取金额激励规则列表
		var moneyIncentivesRuleModels []*models.MoneyIncentivesRule
		moneyIncentivesRuleQuery := tx.Model(&moneyIncentivesRuleModels)
		if err := moneyIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		} else {
			if _, err := tx.Model(&moneyIncentivesRuleModels).WherePK().Delete(); err != nil {
				return nil, err
			}
		}
		// 获取承接人列表
		var cooperationContractUndertakerModels []*models.CooperationContractUndertaker
		cooperationContractUndertakerQuery := tx.Model(&cooperationContractUndertakerModels)
		if err := cooperationContractUndertakerQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		} else {
			if _, err := tx.Model(&cooperationContractUndertakerModels).WherePK().Delete(); err != nil {
				return nil, err
			}
		}
		// 获取相关人列表
		var cooperationContractRelevantModels []*models.CooperationContractRelevant
		cooperationContractRelevantQuery := tx.Model(&cooperationContractRelevantModels)
		if err := cooperationContractRelevantQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
			return nil, err
		} else {
			if _, err := tx.Model(&cooperationContractRelevantModels).WherePK().Delete(); err != nil {
				return nil, err
			}
		}
	}
	return cooperationContract, nil
}

// BatchRemove 批量删除
func (repository *CooperationContractRepository) BatchRemove(cooperationContracts []*domain.CooperationContract) ([]*domain.CooperationContract, error) {
	tx := repository.transactionContext.PgTx
	var cooperationContractModels []*models.CooperationContract
	for _, cooperationContract := range cooperationContracts {
		cooperationContractModels = append(cooperationContractModels, &models.CooperationContract{
			CooperationContractId: cooperationContract.Identify().(int64),
		})
	}
	if _, err := tx.Model(&cooperationContractModels).WherePK().Delete(); err != nil {
		return cooperationContracts, err
	} else {
		for _, cooperationContract := range cooperationContracts {
			// 获取分红激励规则列表
			var dividendsIncentivesRuleModels []*models.DividendsIncentivesRule
			dividendsIncentivesRuleQuery := tx.Model(&dividendsIncentivesRuleModels)
			if err := dividendsIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
				return nil, err
			} else {
				if len(dividendsIncentivesRuleModels) > 0 {
					if _, err := tx.Model(&dividendsIncentivesRuleModels).WherePK().Delete(); err != nil {
						return nil, err
					}
				}
			}
			// 获取金额激励规则列表
			var moneyIncentivesRuleModels []*models.MoneyIncentivesRule
			moneyIncentivesRuleQuery := tx.Model(&moneyIncentivesRuleModels)
			if err := moneyIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
				return nil, err
			} else {
				if len(moneyIncentivesRuleModels) > 0 {
					if _, err := tx.Model(&moneyIncentivesRuleModels).WherePK().Delete(); err != nil {
						return nil, err
					}
				}
			}
			// 获取承接人列表
			var cooperationContractUndertakerModels []*models.CooperationContractUndertaker
			cooperationContractUndertakerQuery := tx.Model(&cooperationContractUndertakerModels)
			if err := cooperationContractUndertakerQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
				return nil, err
			} else {
				if len(cooperationContractUndertakerModels) > 0 {
					if _, err := tx.Model(&cooperationContractUndertakerModels).WherePK().Delete(); err != nil {
						return nil, err
					}
				}
			}
			// 获取相关人列表
			var cooperationContractRelevantModels []*models.CooperationContractRelevant
			cooperationContractRelevantQuery := tx.Model(&cooperationContractRelevantModels)
			if err := cooperationContractRelevantQuery.Where("cooperation_contract_number = ?", cooperationContract.CooperationContractNumber).Select(); err != nil {
				return nil, err
			} else {
				if len(cooperationContractRelevantModels) > 0 {
					if _, err := tx.Model(&cooperationContractRelevantModels).WherePK().Delete(); err != nil {
						return nil, err
					}
				}
			}
		}
	}
	return cooperationContracts, nil
}

func (repository *CooperationContractRepository) FindOne(queryOptions map[string]interface{}) (*domain.CooperationContract, error) {
	tx := repository.transactionContext.PgTx
	cooperationContractModel := new(models.CooperationContract)
	query := sqlbuilder.BuildQuery(tx.Model(cooperationContractModel), queryOptions)
	query.SetWhereByQueryOption("cooperation_contract.cooperation_contract_id = ?", "cooperationContractId")
	query.SetWhereByQueryOption("cooperation_contract.cooperation_contract_number = ?", "cooperationContractNumber")
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if cooperationContractModel.CooperationContractId == 0 {
		return nil, nil
	} else {
		// 获取共创模式
		cooperationModeModels := new(models.CooperationMode)
		cooperationModeQuery := tx.Model(cooperationModeModels)
		if err := cooperationModeQuery.Where("cooperation_mode_number = ?", cooperationContractModel.CooperationModeNumber).First(); err != nil {
			return nil, err
		}
		// 获取分红激励规则列表
		var dividendsIncentivesRuleModels []*models.DividendsIncentivesRule
		dividendsIncentivesRuleQuery := tx.Model(&dividendsIncentivesRuleModels)
		if err := dividendsIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}
		// 获取金额激励规则列表
		var moneyIncentivesRuleModels []*models.MoneyIncentivesRule
		moneyIncentivesRuleQuery := tx.Model(&moneyIncentivesRuleModels)
		if err := moneyIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}
		// 获取承接人列表
		var cooperationContractUndertakerModels []*models.CooperationContractUndertaker
		cooperationContractUndertakerQuery := tx.Model(&cooperationContractUndertakerModels)
		if err := cooperationContractUndertakerQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}
		// 获取相关人列表
		var cooperationContractRelevantModels []*models.CooperationContractRelevant
		cooperationContractRelevantQuery := tx.Model(&cooperationContractRelevantModels)
		if err := cooperationContractRelevantQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
			return nil, err
		}
		return transform.TransformToCooperationContractDomainModelFromPgModels(
			cooperationContractModel,
			cooperationModeModels,
			dividendsIncentivesRuleModels,
			moneyIncentivesRuleModels,
			cooperationContractRelevantModels,
			cooperationContractUndertakerModels)
	}
}

func (repository *CooperationContractRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.CooperationContract, error) {
	tx := repository.transactionContext.PgTx
	var cooperationContractModels []*models.CooperationContract
	cooperationContracts := make([]*domain.CooperationContract, 0)
	query := sqlbuilder.BuildQuery(tx.Model(&cooperationContractModels), queryOptions)
	if cooperationContractNumber, ok := queryOptions["cooperationContractNumber"]; ok && cooperationContractNumber != "" {
		query.Where("cooperation_contract_number ilike ?", fmt.Sprintf("%%%s%%", cooperationContractNumber))
	}
	if cooperationContractName, ok := queryOptions["cooperationContactName"]; ok && cooperationContractName != "" {
		query.Where("cooperation_contract_name like ?", fmt.Sprintf("%%%s%%", cooperationContractName))
	}
	if departmentName, ok := queryOptions["departmentName"]; ok && departmentName != "" {
		query.Where(`(cooperation_contract.department->>'departmentName')::test LIKE ?`, fmt.Sprintf("%%%s%%", departmentName))
	}
	if sponsorName, ok := queryOptions["sponsorName"]; ok && sponsorName != "" {
		query.Where(`(cooperation_contract.cooperation_contract_sponsor->>'userName')::text LIKE ?`, fmt.Sprintf("%%%s%%", sponsorName))
	}
	if cooperationContractIds, ok := queryOptions["cooperationContractIds"]; ok && len(cooperationContractIds.([]int64)) != 0 {
		query.Where("cooperation_contract_id in (?)", pg.In(cooperationContractIds))
	}
	if companyId, ok := queryOptions["companyId"]; ok && companyId.(int64) != 0 {
		query.Where("company->>'companyId' = '?'", companyId)
	}
	if orgId, ok := queryOptions["orgId"]; ok && orgId.(int64) != 0 {
		query.Where("org->>'orgId' = '?'", orgId)
	}
	if orgIds, ok := queryOptions["orgIds"]; ok && len(orgIds.([]int64)) > 0 {
		query.Where("org->>'orgId' in (?)", pg.In(orgIds))
	}
	if incentivesType, ok := queryOptions["incentivesType"]; ok && incentivesType.(int32) != 0 {
		query.Where("incentives_type = ?", incentivesType)
	}
	offsetLimitFlag := true
	if offsetLimit, ok := queryOptions["offsetLimit"]; ok {
		offsetLimitFlag = offsetLimit.(bool)
	}
	if offsetLimitFlag {
		query.SetOffsetAndLimit(20)
	}
	query.SetOrderDirect("cooperation_contract_id", "DESC")
	if count, err := query.SelectAndCount(); err != nil {
		return 0, cooperationContracts, err
	} else {
		for _, cooperationContractModel := range cooperationContractModels {
			// 获取共创模式
			cooperationModeModel := new(models.CooperationMode)
			cooperationModeQuery := tx.Model(cooperationModeModel)
			if err := cooperationModeQuery.Where("cooperation_mode_number = ?", cooperationContractModel.CooperationModeNumber).First(); err != nil {
				return 0, nil, err
			}
			// 获取分红激励规则列表
			var dividendsIncentivesRuleModels []*models.DividendsIncentivesRule
			dividendsIncentivesRuleQuery := tx.Model(&dividendsIncentivesRuleModels)
			if err := dividendsIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
				return 0, nil, err
			}
			// 获取金额激励规则列表
			var moneyIncentivesRuleModels []*models.MoneyIncentivesRule
			moneyIncentivesRuleQuery := tx.Model(&moneyIncentivesRuleModels)
			if err := moneyIncentivesRuleQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
				return 0, nil, err
			}
			// 获取承接人列表
			var cooperationContractUndertakerModels []*models.CooperationContractUndertaker
			cooperationContractUndertakerQuery := tx.Model(&cooperationContractUndertakerModels)
			if err := cooperationContractUndertakerQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
				return 0, nil, err
			}
			// 获取相关人列表
			var cooperationContractRelevantModels []*models.CooperationContractRelevant
			cooperationContractRelevantQuery := tx.Model(&cooperationContractRelevantModels)
			if err := cooperationContractRelevantQuery.Where("cooperation_contract_number = ?", cooperationContractModel.CooperationContractNumber).Select(); err != nil {
				return 0, nil, err
			}
			if cooperationContract, err := transform.TransformToCooperationContractDomainModelFromPgModels(
				cooperationContractModel,
				cooperationModeModel,
				dividendsIncentivesRuleModels,
				moneyIncentivesRuleModels,
				cooperationContractRelevantModels,
				cooperationContractUndertakerModels); err != nil {
				return 0, cooperationContracts, err
			} else {
				cooperationContracts = append(cooperationContracts, cooperationContract)
			}
		}
		return int64(count), cooperationContracts, nil
	}
}

func NewCooperationContractRepository(transactionContext *pgTransaction.TransactionContext) (*CooperationContractRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &CooperationContractRepository{
			transactionContext: transactionContext,
		}, nil
	}
}