refactor:优化仓储

@@ -31,3 +31,10 @@ type Relevant struct {
 	// 公司
 	// 公司
 	Company *Company `json:"company"`
 	Company *Company `json:"company"`
 }
 }
+
+func (relevant *Relevant) Identify() interface{} {
+	if relevant.RelevantId == 0 {
+		return nil
+	}
+	return relevant.RelevantId
+}

@@ -37,3 +37,10 @@ type Undertaker struct {
 	// 合同附件
 	// 合同附件
 	ContractAttachment []*Attachment `json:"contractAttachment"`
 	ContractAttachment []*Attachment `json:"contractAttachment"`
 }
 }
+
+func (undertaker *Undertaker) Identify() interface{} {
+	if undertaker.UndertakerId == 0 {
+		return nil
+	}
+	return undertaker.UndertakerId
+}

@@ -15,14 +15,11 @@ import (
 
 
 type ContractUndertakerFeedbackRepository struct {
 type ContractUndertakerFeedbackRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *ContractUndertakerFeedbackRepository) nextIdentify() (int64, error) {
 func (repository *ContractUndertakerFeedbackRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -202,8 +199,13 @@ func NewContractUndertakerFeedbackRepository(transactionContext *pgTransaction.T
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &ContractUndertakerFeedbackRepository{
 		return &ContractUndertakerFeedbackRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -17,14 +17,11 @@ import (
 
 
 type CooperationApplicationRepository struct {
 type CooperationApplicationRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CooperationApplicationRepository) nextIdentify() (int64, error) {
 func (repository *CooperationApplicationRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -322,8 +319,13 @@ func NewCooperationApplicationRepository(transactionContext *pgTransaction.Trans
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CooperationApplicationRepository{
 		return &CooperationApplicationRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -15,14 +15,11 @@ import (
 
 
 type CooperationContractChangeLogRepository struct {
 type CooperationContractChangeLogRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CooperationContractChangeLogRepository) nextIdentify() (int64, error) {
 func (repository *CooperationContractChangeLogRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -198,8 +195,13 @@ func NewCooperationContractChangeLogRepository(transactionContext *pgTransaction
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CooperationContractChangeLogRepository{
 		return &CooperationContractChangeLogRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -15,14 +15,11 @@ import (
 
 
 type CooperationContractRelevantRepository struct {
 type CooperationContractRelevantRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CooperationContractRelevantRepository) nextIdentify() (int64, error) {
 func (repository *CooperationContractRelevantRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -210,8 +207,13 @@ func NewCooperationContractRelevantRepository(transactionContext *pgTransaction.
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CooperationContractRelevantRepository{
 		return &CooperationContractRelevantRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -16,14 +16,11 @@ import (
 
 
 type CooperationContractRepository struct {
 type CooperationContractRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CooperationContractRepository) nextIdentify() (int64, error) {
 func (repository *CooperationContractRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -108,7 +105,16 @@ func (repository *CooperationContractRepository) Save(cooperationContract *domai
 		// 新增相关人
 		// 新增相关人
 		var relevantPeopleModel []*models.CooperationContractRelevant
 		var relevantPeopleModel []*models.CooperationContractRelevant
 		for _, relevant := range cooperationContract.RelevantPeople {
 		for _, relevant := range cooperationContract.RelevantPeople {
+			if relevant.Identify() == nil {
+				orderGoodId, err := repository.nextIdentify()
+				if err != nil {
+					return nil, err
+				} else {
+					relevant.RelevantId = orderGoodId
+				}
+			}
 			relevantPeopleModel = append(relevantPeopleModel, &models.CooperationContractRelevant{
 			relevantPeopleModel = append(relevantPeopleModel, &models.CooperationContractRelevant{
+				CooperationContractRelevantId: relevant.RelevantId,
 				CooperationContractNumber:     cooperationContract.CooperationContractNumber,
 				CooperationContractNumber:     cooperationContract.CooperationContractNumber,
 				UserId:                        relevant.UserId,
 				UserId:                        relevant.UserId,
 				UserBaseId:                    relevant.UserBaseId,
 				UserBaseId:                    relevant.UserBaseId,
@@ -169,7 +175,16 @@ func (repository *CooperationContractRepository) Save(cooperationContract *domai
 		// 新增分红激励规则
 		// 新增分红激励规则
 		var dividendsIncentivesRulesModel []*models.DividendsIncentivesRule
 		var dividendsIncentivesRulesModel []*models.DividendsIncentivesRule
 		for _, rule := range cooperationContract.DividendsIncentivesRules {
 		for _, rule := range cooperationContract.DividendsIncentivesRules {
+			if rule.Identify() == nil {
+				ruleId, err := repository.nextIdentify()
+				if err != nil {
+					return nil, err
+				} else {
+					rule.DividendsIncentivesRuleId = ruleId
+				}
+			}
 			dividendsIncentivesRulesModel = append(dividendsIncentivesRulesModel, &models.DividendsIncentivesRule{
 			dividendsIncentivesRulesModel = append(dividendsIncentivesRulesModel, &models.DividendsIncentivesRule{
+				DividendsIncentivesRuleId:     rule.DividendsIncentivesRuleId,
 				CooperationContractNumber:     cooperationContract.CooperationContractNumber,
 				CooperationContractNumber:     cooperationContract.CooperationContractNumber,
 				ReferrerPercentage:            rule.ReferrerPercentage,
 				ReferrerPercentage:            rule.ReferrerPercentage,
 				SalesmanPercentage:            rule.SalesmanPercentage,
 				SalesmanPercentage:            rule.SalesmanPercentage,
@@ -197,7 +212,16 @@ func (repository *CooperationContractRepository) Save(cooperationContract *domai
 		// 新增金额激励规则
 		// 新增金额激励规则
 		var moneyIncentivesRulesModel []*models.MoneyIncentivesRule
 		var moneyIncentivesRulesModel []*models.MoneyIncentivesRule
 		for _, rule := range cooperationContract.MoneyIncentivesRules {
 		for _, rule := range cooperationContract.MoneyIncentivesRules {
+			if rule.Identify() == nil {
+				ruleId, err := repository.nextIdentify()
+				if err != nil {
+					return nil, err
+				} else {
+					rule.MoneyIncentivesRuleId = ruleId
+				}
+			}
 			moneyIncentivesRulesModel = append(moneyIncentivesRulesModel, &models.MoneyIncentivesRule{
 			moneyIncentivesRulesModel = append(moneyIncentivesRulesModel, &models.MoneyIncentivesRule{
+				MoneyIncentivesRuleId:     rule.MoneyIncentivesRuleId,
 				CooperationContractNumber: cooperationContract.CooperationContractNumber,
 				CooperationContractNumber: cooperationContract.CooperationContractNumber,
 				MoneyIncentivesAmount:     rule.MoneyIncentivesAmount,
 				MoneyIncentivesAmount:     rule.MoneyIncentivesAmount,
 				MoneyIncentivesStage:      rule.MoneyIncentivesStage,
 				MoneyIncentivesStage:      rule.MoneyIncentivesStage,
@@ -302,7 +326,16 @@ func (repository *CooperationContractRepository) Save(cooperationContract *domai
 		// 将待添加的相关人领域模型转换为数据模型
 		// 将待添加的相关人领域模型转换为数据模型
 		var cooperationContractRelevantPeopleToAddModels []*models.CooperationContractRelevant
 		var cooperationContractRelevantPeopleToAddModels []*models.CooperationContractRelevant
 		for _, relevantDomain := range cooperationContractRelevantPeopleToAdd {
 		for _, relevantDomain := range cooperationContractRelevantPeopleToAdd {
+			if relevantDomain.Identify() == nil {
+				relevantId, err := repository.nextIdentify()
+				if err != nil {
+					return nil, err
+				} else {
+					relevantDomain.RelevantId = relevantId
+				}
+			}
 			cooperationContractRelevantPeopleToAddModels = append(cooperationContractRelevantPeopleToAddModels, &models.CooperationContractRelevant{
 			cooperationContractRelevantPeopleToAddModels = append(cooperationContractRelevantPeopleToAddModels, &models.CooperationContractRelevant{
+				CooperationContractRelevantId: relevantDomain.RelevantId,
 				CooperationContractNumber:     relevantDomain.CooperationContractNumber,
 				CooperationContractNumber:     relevantDomain.CooperationContractNumber,
 				UserId:                        relevantDomain.UserId,
 				UserId:                        relevantDomain.UserId,
 				UserBaseId:                    relevantDomain.UserBaseId,
 				UserBaseId:                    relevantDomain.UserBaseId,
@@ -401,7 +434,16 @@ func (repository *CooperationContractRepository) Save(cooperationContract *domai
 		// 将待添加的相关人领域模型转换为数据模型
 		// 将待添加的相关人领域模型转换为数据模型
 		var cooperationContractUndertakersToAddModels []*models.CooperationContractUndertaker
 		var cooperationContractUndertakersToAddModels []*models.CooperationContractUndertaker
 		for _, undertakerDomain := range cooperationContractUndertakersToAdd {
 		for _, undertakerDomain := range cooperationContractUndertakersToAdd {
+			if undertakerDomain.Identify() == nil {
+				undertakerId, err := repository.nextIdentify()
+				if err != nil {
+					return nil, err
+				} else {
+					undertakerDomain.UndertakerId = undertakerId
+				}
+			}
 			cooperationContractUndertakersToAddModels = append(cooperationContractUndertakersToAddModels, &models.CooperationContractUndertaker{
 			cooperationContractUndertakersToAddModels = append(cooperationContractUndertakersToAddModels, &models.CooperationContractUndertaker{
+				CooperationContractUndertakerId: undertakerDomain.UndertakerId,
 				CooperationContractNumber:       undertakerDomain.CooperationContractNumber,
 				CooperationContractNumber:       undertakerDomain.CooperationContractNumber,
 				UserId:                          undertakerDomain.UserId,
 				UserId:                          undertakerDomain.UserId,
 				UserBaseId:                      undertakerDomain.UserBaseId,
 				UserBaseId:                      undertakerDomain.UserBaseId,
@@ -534,7 +576,16 @@ func (repository *CooperationContractRepository) Save(cooperationContract *domai
 		// 将待添加的分红激励规则领域模型转换为数据模型
 		// 将待添加的分红激励规则领域模型转换为数据模型
 		var dividendsIncentivesRulesToAddModels []*models.DividendsIncentivesRule
 		var dividendsIncentivesRulesToAddModels []*models.DividendsIncentivesRule
 		for _, dividendsIncentivesRuleDomain := range dividendsIncentivesRulesToAdd {
 		for _, dividendsIncentivesRuleDomain := range dividendsIncentivesRulesToAdd {
+			if dividendsIncentivesRuleDomain.Identify() == nil {
+				ruleId, err := repository.nextIdentify()
+				if err != nil {
+					return nil, err
+				} else {
+					dividendsIncentivesRuleDomain.DividendsIncentivesRuleId = ruleId
+				}
+			}
 			dividendsIncentivesRulesToAddModels = append(dividendsIncentivesRulesToAddModels, &models.DividendsIncentivesRule{
 			dividendsIncentivesRulesToAddModels = append(dividendsIncentivesRulesToAddModels, &models.DividendsIncentivesRule{
+				DividendsIncentivesRuleId:     dividendsIncentivesRuleDomain.DividendsIncentivesRuleId,
 				CooperationContractNumber:     dividendsIncentivesRuleDomain.CooperationContractNumber,
 				CooperationContractNumber:     dividendsIncentivesRuleDomain.CooperationContractNumber,
 				ReferrerPercentage:            dividendsIncentivesRuleDomain.ReferrerPercentage,
 				ReferrerPercentage:            dividendsIncentivesRuleDomain.ReferrerPercentage,
 				SalesmanPercentage:            dividendsIncentivesRuleDomain.SalesmanPercentage,
 				SalesmanPercentage:            dividendsIncentivesRuleDomain.SalesmanPercentage,
@@ -657,7 +708,16 @@ func (repository *CooperationContractRepository) Save(cooperationContract *domai
 		// 将待添加的金额激励规则领域模型转换为数据模型
 		// 将待添加的金额激励规则领域模型转换为数据模型
 		var moneyIncentivesRulesToAddModels []*models.MoneyIncentivesRule
 		var moneyIncentivesRulesToAddModels []*models.MoneyIncentivesRule
 		for _, moneyIncentivesRuleDomain := range moneyIncentivesRulesToAdd {
 		for _, moneyIncentivesRuleDomain := range moneyIncentivesRulesToAdd {
+			if moneyIncentivesRuleDomain.Identify() == nil {
+				ruleId, err := repository.nextIdentify()
+				if err != nil {
+					return nil, err
+				} else {
+					moneyIncentivesRuleDomain.MoneyIncentivesRuleId = ruleId
+				}
+			}
 			moneyIncentivesRulesToAddModels = append(moneyIncentivesRulesToAddModels, &models.MoneyIncentivesRule{
 			moneyIncentivesRulesToAddModels = append(moneyIncentivesRulesToAddModels, &models.MoneyIncentivesRule{
+				MoneyIncentivesRuleId:     moneyIncentivesRuleDomain.MoneyIncentivesRuleId,
 				CooperationContractNumber: moneyIncentivesRuleDomain.CooperationContractNumber,
 				CooperationContractNumber: moneyIncentivesRuleDomain.CooperationContractNumber,
 				MoneyIncentivesAmount:     moneyIncentivesRuleDomain.MoneyIncentivesAmount,
 				MoneyIncentivesAmount:     moneyIncentivesRuleDomain.MoneyIncentivesAmount,
 				MoneyIncentivesStage:      moneyIncentivesRuleDomain.MoneyIncentivesStage,
 				MoneyIncentivesStage:      moneyIncentivesRuleDomain.MoneyIncentivesStage,
@@ -1175,8 +1235,13 @@ func NewCooperationContractRepository(transactionContext *pgTransaction.Transact
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CooperationContractRepository{
 		return &CooperationContractRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -15,14 +15,11 @@ import (
 
 
 type CooperationContractUndertakerRepository struct {
 type CooperationContractUndertakerRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CooperationContractUndertakerRepository) nextIdentify() (int64, error) {
 func (repository *CooperationContractUndertakerRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -225,8 +222,13 @@ func NewCooperationContractUndertakerRepository(transactionContext *pgTransactio
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CooperationContractUndertakerRepository{
 		return &CooperationContractUndertakerRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -14,14 +14,11 @@ import (
 
 
 type CooperationModeRepository struct {
 type CooperationModeRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CooperationModeRepository) nextIdentify() (int64, error) {
 func (repository *CooperationModeRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -221,8 +218,13 @@ func NewCooperationModeRepository(transactionContext *pgTransaction.TransactionC
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CooperationModeRepository{
 		return &CooperationModeRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -17,14 +17,11 @@ import (
 
 
 type CooperationProjectRepository struct {
 type CooperationProjectRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CooperationProjectRepository) nextIdentify() (int64, error) {
 func (repository *CooperationProjectRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -317,8 +314,13 @@ func NewCooperationProjectRepository(transactionContext *pgTransaction.Transacti
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CooperationProjectRepository{
 		return &CooperationProjectRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -15,14 +15,11 @@ import (
 
 
 type CreditAccountRepository struct {
 type CreditAccountRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *CreditAccountRepository) nextIdentify() (int64, error) {
 func (repository *CreditAccountRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -249,8 +246,13 @@ func NewCreditAccountRepository(transactionContext *pgTransaction.TransactionCon
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &CreditAccountRepository{
 		return &CreditAccountRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -16,14 +16,11 @@ import (
 
 
 type DividendsEstimateRepository struct {
 type DividendsEstimateRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *DividendsEstimateRepository) nextIdentify() (int64, error) {
 func (repository *DividendsEstimateRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -332,8 +329,13 @@ func NewDividendsEstimateRepository(transactionContext *pgTransaction.Transactio
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &DividendsEstimateRepository{
 		return &DividendsEstimateRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }

@@ -15,14 +15,11 @@ import (
 
 
 type DividendsIncentivesRuleRepository struct {
 type DividendsIncentivesRuleRepository struct {
 	transactionContext *pgTransaction.TransactionContext
 	transactionContext *pgTransaction.TransactionContext
+	IdWorker           *snowflake.IdWorker
 }
 }
 
 
 func (repository *DividendsIncentivesRuleRepository) nextIdentify() (int64, error) {
 func (repository *DividendsIncentivesRuleRepository) nextIdentify() (int64, error) {
-	IdWorker, err := snowflake.NewIdWorker(1)
-	if err != nil {
-		return 0, err
-	}
-	id, err := IdWorker.NextId()
+	id, err := repository.IdWorker.NextId()
 	return id, err
 	return id, err
 }
 }
 
 
@@ -202,8 +199,13 @@ func NewDividendsIncentivesRuleRepository(transactionContext *pgTransaction.Tran
 	if transactionContext == nil {
 	if transactionContext == nil {
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 		return nil, fmt.Errorf("transactionContext参数不能为nil")
 	} else {
 	} else {
+		idWorker, err := snowflake.NewIdWorker(1)
+		if err != nil {
+			return nil, err
+		}
 		return &DividendsIncentivesRuleRepository{
 		return &DividendsIncentivesRuleRepository{
 			transactionContext: transactionContext,
 			transactionContext: transactionContext,
+			IdWorker:           idWorker,
 		}, nil
 		}, nil
 	}
 	}
 }
 }