package service

import (
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	"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/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 operator *domain.User
	if data, err := userService.OperatorFrom(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId, createCooperationContractCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.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, err.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, err.Error())
	} else {
		company = data
	}

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

	// 获取组织机构信息
	var organization *domain.Org
	if data, err := organizationService.OrgFrom(createCooperationContractCommand.CompanyId, createCooperationContractCommand.OrgId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organization = 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()
	if err2 != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	// 校验共创合约编号是否唯一
	numberAvailable, _ := cooperationContractDao.CheckContractNumberAvailable(map[string]interface{}{
		"companyId":                 createCooperationContractCommand.CompanyId,
		"orgId":                     createCooperationContractCommand.OrgId,
		"cooperationContractNumber": contractNumber,
	})
	if !numberAvailable {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "新增共创合约异常")
	}

	// 获取承接人
	var undertakers []*domain.Undertaker
	for _, undertaker := range createCooperationContractCommand.Undertakers {
		var undertakerDomain *domain.Undertaker
		undertakerUid, _ := strconv.ParseInt(undertaker.UserId, 10, 64)
		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
		}

		// 获取推荐人
		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
			}
		}

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

	// 获取相关人
	var relevantPeople []*domain.Relevant
	for _, relevantPersonUid := range createCooperationContractCommand.RelevantPeople {
		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:                       relevantDomain.Org,
			Orgs:                      relevantDomain.Orgs,
			Department:                relevantDomain.Department,
			Roles:                     relevantDomain.Roles,
			UserInfo:                  relevantDomain.UserInfo,
			UserType:                  relevantDomain.UserType,
			Status:                    relevantDomain.Status,
			Company:                   relevantDomain.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:      int64(dividendsIncentivesRule.DividendsIncentivesStage),
			DividendsIncentivesStageEnd:   dividendsIncentivesRule.DividendsIncentivesStageEnd,
			DividendsIncentivesStageStart: dividendsIncentivesRule.DividendsIncentivesStageStart,
			Org:                           organization,
			Company:                       company,
			UpdatedAt:                     time.Time{},
			DeletedAt:                     time.Time{},
			CreatedAt:                     time.Now(),
		})
	}

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

	// 查找共创模式
	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{}{"cooperationModeNumber": createCooperationContractCommand.CooperationModeNumber})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationMode == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", createCooperationContractCommand.CooperationModeNumber))
	} else {
		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,
			Operator:                           operator,
			DividendsIncentivesRules:           dividendsIncentivesRules,
			MoneyIncentivesRules:               moneyIncentivesRules,
			Undertakers:                        undertakers,
			RelevantPeople:                     relevantPeople,
			OperateTime:                        time.Now(),
			CreatedAt:                          time.Now(),
			DeletedAt:                          time.Time{},
			UpdatedAt:                          time.Time{},
		}

		// 共创合约仓储初始化
		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 := transactionContext.CommitTransaction(); err != nil {
				return nil, application.ThrowError(application.TRANSACTION_ERROR, err.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, err.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
		}
		// 获取可删除的承接对象类型
		undertakerTypesUncheckedAvailable, err := cooperationContractDao.CheckUndertakerTypesUncheckedAvailable(map[string]interface{}{
			"cooperationContractNumber":          cooperationContract.CooperationContractNumber,
			"cooperationContractUndertakerTypes": cooperationContract.CooperationContractUndertakerTypes,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		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, err.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,
	}); 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()
	}()
	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": operateCooperationContractCommand.CooperationContractId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationContract == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", 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 cooperationContract, err := cooperationContractRepository.UpdateOne(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
	}
}

// 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
	}
	cooperationContractIds, _ := utils.SliceAtoi(batchOperateCooperationContractCommand.CooperationContractIds)
	if count, cooperationContracts, err := cooperationContractRepository.Find(map[string]interface{}{
		"cooperationContractIds": cooperationContractIds,
	}); 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())
			}
			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()
	}()
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil, 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, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

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

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

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

	// 获取组织机构信息
	var organization *domain.Org
	if data, err := organizationService.OrgFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organization = 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
	}
	cooperationContract, err := cooperationContractRepository.FindOne(map[string]interface{}{"cooperationContractId": updateCooperationContractCommand.CooperationContractId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationContract == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateCooperationContractCommand.CooperationContractId)))
	}
	// 更新合约基础信息
	if err := cooperationContract.Update(tool_funs.SimpleStructToMap(updateCooperationContractCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	// 用户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 sponsor *domain.User
	sponsorUid, _ := strconv.ParseInt(updateCooperationContractCommand.SponsorUid, 10, 64)
	if data, err := userService.OperatorFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, sponsorUid); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		sponsor = data
	}

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

	// 获取相关人
	var relevantPeople []*domain.Relevant
	for _, relevantPersonUid := range updateCooperationContractCommand.RelevantPeople {
		var relevantDomain *domain.Relevant
		relevantUid, _ := strconv.ParseInt(relevantPersonUid, 10, 64)
		if data, err := userService.RelevantFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, relevantUid); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			relevantDomain = data
		}
		relevantPeople = append(relevantPeople, &domain.Relevant{
			RelevantId:                relevantDomain.RelevantId,
			CooperationContractNumber: cooperationContract.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,
		})
	}
	// 更新合约相关人
	cooperationContract.RelevantPeople = relevantPeople

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

		// 获取推荐人
		var referrerDomain *domain.Referrer
		referrerUid, _ := strconv.ParseInt(undertaker.ReferrerId, 10, 64)
		if referrerUid > 0 {
			if data, err := userService.ReferrerFrom(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, referrerUid); err != nil {
				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(updateCooperationContractCommand.CompanyId, updateCooperationContractCommand.OrgId, salesmanUid); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				salesmanDomain = data
			}
		}

		undertakers = append(undertakers, &domain.Undertaker{
			UndertakerId:              undertaker.UndertakerId,
			UserId:                    undertakerDomain.UserId,
			CooperationContractNumber: cooperationContract.CooperationContractNumber,
			UserBaseId:                undertakerDomain.UserBaseId,
			Org:                       undertakerDomain.Org,
			Orgs:                      undertakerDomain.Orgs,
			Department:                undertakerDomain.Department,
			Roles:                     undertakerDomain.Roles,
			UserInfo:                  undertakerDomain.UserInfo,
			UserType:                  undertakerDomain.UserType,
			Referrer:                  referrerDomain,
			Salesman:                  salesmanDomain,
			Status:                    undertakerDomain.Status,
			Company:                   undertakerDomain.Company,
			ContractAttachment:        nil,
		})
	}
	// 更新承接人
	cooperationContract.Undertakers = undertakers

	// 获取分红规则列表
	var dividendsIncentivesRules []*domain.DividendsIncentivesRule
	for _, dividendsIncentivesRule := range updateCooperationContractCommand.DividendsIncentivesRules {
		dividendsIncentivesRuleId, _ := strconv.ParseInt(dividendsIncentivesRule.DividendsIncentivesRuleId, 10, 64)
		dividendsIncentivesRules = append(dividendsIncentivesRules, &domain.DividendsIncentivesRule{
			DividendsIncentivesRuleId:     dividendsIncentivesRuleId,
			CooperationContractNumber:     cooperationContract.CooperationContractNumber,
			ReferrerPercentage:            dividendsIncentivesRule.ReferrerPercentage,
			SalesmanPercentage:            dividendsIncentivesRule.SalesmanPercentage,
			DividendsIncentivesPercentage: dividendsIncentivesRule.DividendsIncentivesPercentage,
			DividendsIncentivesStage:      int64(dividendsIncentivesRule.DividendsIncentivesStage),
			DividendsIncentivesStageEnd:   dividendsIncentivesRule.DividendsIncentivesStageEnd,
			DividendsIncentivesStageStart: dividendsIncentivesRule.DividendsIncentivesStageStart,
			Org:                           organization,
			Company:                       company,
			UpdatedAt:                     time.Time{},
			DeletedAt:                     time.Time{},
			CreatedAt:                     time.Now(),
		})
	}
	// 更新分红规则列表
	cooperationContract.DividendsIncentivesRules = dividendsIncentivesRules

	// 获取金额激励规则列表
	var moneyIncentivesRules []*domain.MoneyIncentivesRule
	for _, moneyIncentivesRule := range updateCooperationContractCommand.MoneyIncentivesRules {
		moneyIncentivesRuleId, _ := strconv.ParseInt(moneyIncentivesRule.MoneyIncentivesRuleId, 10, 64)
		moneyIncentivesRules = append(moneyIncentivesRules, &domain.MoneyIncentivesRule{
			MoneyIncentivesRuleId:     moneyIncentivesRuleId,
			CooperationContractNumber: cooperationContract.CooperationContractNumber,
			MoneyIncentivesAmount:     float64(moneyIncentivesRule.MoneyIncentivesAmount),
			MoneyIncentivesStage:      int64(moneyIncentivesRule.MoneyIncentivesStage),
			MoneyIncentivesStageEnd:   moneyIncentivesRule.MoneyIncentivesStageEnd,
			MoneyIncentivesStageStart: moneyIncentivesRule.MoneyIncentivesStageStart,
			MoneyIncentivesTime:       time.Now(),
			ReferrerPercentage:        moneyIncentivesRule.ReferrerPercentage,
			SalesmanPercentage:        moneyIncentivesRule.SalesmanPercentage,
			Org:                       organization,
			Company:                   company,
			UpdatedAt:                 time.Time{},
			DeletedAt:                 time.Time{},
			CreatedAt:                 time.Now(),
		})
	}
	// 更新金额激励规则列表
	cooperationContract.MoneyIncentivesRules = moneyIncentivesRules

	if cooperationContract, err := cooperationContractRepository.Save(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
	}
}

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