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/cooperationProject/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/cooperationProject/dto"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/cooperationProject/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"
)

// CooperationProjectService 共创项目服务
type CooperationProjectService struct {
}

// CheckUndertaker 判断当前勾选的承接对象是否存在用户
func (cooperationProjectService *CooperationProjectService) CheckUndertaker(checkUndertakerQuery *query.CheckUndertakerQuery) (interface{}, error) {
	if err := checkUndertakerQuery.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
}

// CreateCooperationProject 创建共创项目服务
func (cooperationProjectService *CooperationProjectService) CreateCooperationProject(createCooperationProjectCommand *command.CreateCooperationProjectCommand) (interface{}, error) {
	if err := createCooperationProjectCommand.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(createCooperationProjectCommand.CompanyId, createCooperationProjectCommand.OrgId, createCooperationProjectCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取操作人失败")
	} else {
		operator = data
	}

	// 获取发起人
	var sponsor *domain.User
	if data, err := userService.UserFrom(createCooperationProjectCommand.CompanyId, createCooperationProjectCommand.OrgId, createCooperationProjectCommand.SponsorUid); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取发起人失败")
	} else {
		sponsor = data
	}

	// 获取发布人
	var publisher *domain.User
	if data, err := userService.UserFrom(createCooperationProjectCommand.CompanyId, createCooperationProjectCommand.OrgId, createCooperationProjectCommand.PublisherUid); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取发布人失败")
	} else {
		publisher = 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(createCooperationProjectCommand.CompanyId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取公司信息失败")
	} else {
		company = data
	}

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

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

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

	// 获取部门信息
	var department *domain.Department
	if data, err := departmentService.DepartmentFrom(createCooperationProjectCommand.CompanyId, createCooperationProjectCommand.DepartmentId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取部门信息失败")
	} else {
		department = data
	}

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

	// 共创项目DAO初始化
	var cooperationProjectDao *dao.CooperationProjectDao
	if value, err := factory.CreateCooperationProjectDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		cooperationProjectDao = value
	}

	// 查找共创模式
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	cooperationMode, err := cooperationModeRepository.FindOne(map[string]interface{}{
		"companyId":             createCooperationProjectCommand.CompanyId,
		"orgId":                 createCooperationProjectCommand.OrgId,
		"cooperationModeNumber": createCooperationProjectCommand.CooperationModeNumber,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创模式不存在")
	}
	if cooperationMode == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", createCooperationProjectCommand.CooperationModeNumber))
	} else {
		// 生成共创项目编号
		projectNumber, err2 := cooperationProjectDao.GenerateProjectNumber(map[string]interface{}{
			"companyId": createCooperationProjectCommand.CompanyId,
		})
		if err2 != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err2.Error())
		}

		// 校验共创项目编号是否唯一
		numberAvailable, err := cooperationProjectDao.CheckProjectNumberAvailable(map[string]interface{}{
			"companyId":                createCooperationProjectCommand.CompanyId,
			"orgId":                    createCooperationProjectCommand.OrgId,
			"cooperationProjectNumber": projectNumber,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if !numberAvailable {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "新增共创项目异常")
		}

		// 校验共创项目名称是否唯一
		nameAvailable, err := cooperationProjectDao.CheckProjectNameAvailable(map[string]interface{}{
			"companyId":              createCooperationProjectCommand.CompanyId,
			"orgId":                  createCooperationProjectCommand.OrgId,
			"cooperationProjectName": createCooperationProjectCommand.CooperationProjectName,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if !nameAvailable {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "共创项目名称重复")
		}

		newCooperationProject := &domain.CooperationProject{
			CooperationProjectNumber:          projectNumber,
			CooperationProjectName:            createCooperationProjectCommand.CooperationProjectName,
			CooperationProjectUndertakerTypes: createCooperationProjectCommand.CooperationProjectUndertakerTypes,
			CooperationProjectSponsor:         sponsor,
			CooperationMode:                   cooperationMode,
			CooperationProjectPublisher:       publisher,
			CooperationProjectDescription:     createCooperationProjectCommand.CooperationProjectDescription,
			CooperationProjectPublishTime:     time.Now(),
			Attachment:                        createCooperationProjectCommand.Attachment,
			Company:                           company,
			Department:                        department,
			Org:                               organization,
			Operator:                          operator,
			OperateTime:                       time.Now(),
			Status:                            1,
			UpdatedAt:                         time.Time{},
			DeletedAt:                         time.Time{},
			CreatedAt:                         time.Now(),
			ApplicantCount:                    0,
		}

		if cooperationProject, err := cooperationProjectRepository.Save(newCooperationProject); 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 cooperationProject, nil
		}
	}
}

// GetCooperationProject 返回共创项目服务
func (cooperationProjectService *CooperationProjectService) GetCooperationProject(getCooperationProjectQuery *query.GetCooperationProjectQuery) (interface{}, error) {
	if err := getCooperationProjectQuery.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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}

	// 共创申请仓储初始化
	var cooperationApplicationRepository domain.CooperationApplicationRepository
	if value, err := factory.CreateCooperationApplicationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationApplicationRepository = value
	}

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

	var getCooperationProjectQuerySpecific *query.GetCooperationProjectQuery
	if getCooperationProjectQuery.CooperationProjectId != 0 { // 根据ID查询
		getCooperationProjectQuerySpecific = &query.GetCooperationProjectQuery{
			CooperationProjectId:     getCooperationProjectQuery.CooperationProjectId,
			CooperationProjectNumber: "",
			CompanyId:                0,
			OrgId:                    0,
			UserId:                   0,
			UserBaseId:               0,
		}
	} else if getCooperationProjectQuery.CooperationProjectNumber != "" { // 根据编号查询
		getCooperationProjectQuerySpecific = getCooperationProjectQuery
	}

	// 获取共创项目
	cooperationProject, err := cooperationProjectRepository.FindOne(tool_funs.SimpleStructToMap(getCooperationProjectQuerySpecific))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationProject == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(getCooperationProjectQuery.CooperationProjectId, 10)))
	} else {
		// 共创项目DAO初始化
		var cooperationProjectDao *dao.CooperationProjectDao
		if value, err := factory.CreateCooperationProjectDao(map[string]interface{}{
			"transactionContext": transactionContext,
		}); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		} else {
			cooperationProjectDao = value
		}

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

		// 判断承接对象是否存在员工
		gotUser, err := cooperationProjectDao.CheckUndertakerTypesUncheckedAvailable(map[string]interface{}{
			"cooperationProjectNumber": cooperationProject.CooperationProjectNumber,
			"user":                     true,
			"companyId":                cooperationProject.Company.CompanyId,
			"orgId":                    cooperationProject.Org.OrgId,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if !gotUser {
			undertakerTypesUncheckedAvailable = append(undertakerTypesUncheckedAvailable, 1)
		}

		// 判断承接对象是否存在共创用户
		gotPartner, err := cooperationProjectDao.CheckUndertakerTypesUncheckedAvailable(map[string]interface{}{
			"cooperationProjectNumber": cooperationProject.CooperationProjectNumber,
			"partner":                  true,
			"companyId":                cooperationProject.Company.CompanyId,
			"orgId":                    cooperationProject.Org.OrgId,
		})
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		if !gotPartner {
			undertakerTypesUncheckedAvailable = append(undertakerTypesUncheckedAvailable, 2)
		}

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

		// 判断项目关联的合约承接人类型
		undertakers := make([]*domain.Undertaker, 0)
		if countContracts, cooperationContracts, err := cooperationContractRepository.Find(map[string]interface{}{
			"offsetLimit": false,
		}); err != nil {

		} else {
			if countContracts > 0 {
				for _, cooperationContract := range cooperationContracts {
					undertakers = append(undertakers, cooperationContract.Undertakers...)
				}
			}
		}

		var undertakerUserTypes []int32
		for _, undertaker := range undertakers {
			undertakerUserTypes = append(undertakerUserTypes, undertaker.UserType)
		}

		undertakerUserTypes = utils.RemoveDuplicationInt32(undertakerUserTypes)

		for i, userType := range undertakerUserTypes {
			if userType == 1025 {
				undertakerUserTypes[i] = 2
			}
		}

		if utils.IsContain(undertakerUserTypes, int32(1)) && utils.IsContain(undertakerUserTypes, int32(2)) {
			undertakerUserTypes = append(undertakerUserTypes, int32(3))
		}

		// 取项目承接人和合约承接人的交集
		newUndertakerTypesUncheckedAvailable := utils.Intersect32(undertakerTypesUncheckedAvailable, undertakerUserTypes)

		log.Logger.Info("承接人类型", map[string]interface{}{
			"undertakerUserTypes": undertakerUserTypes,
		})

		// 返回所有员工类型的申请通过人
		applicants := make([]*domain.User, 0)

		// 获取当前项目的所有申请
		if countApplication, cooperationApplications, err := cooperationApplicationRepository.Find(map[string]interface{}{
			"cooperationProjectNumberExact": cooperationProject.CooperationProjectNumber,
			"companyId":                     cooperationProject.Company.CompanyId,
			"orgId":                         cooperationProject.Org.OrgId,
			"offsetLimit":                   false,
		}); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			if countApplication > 0 {
				for _, cooperationApplication := range cooperationApplications {
					log.Logger.Info("申请人", map[string]interface{}{
						"applicant": cooperationApplication.CooperationApplicationApplicant,
					})
					userType := cooperationApplication.CooperationApplicationApplicant.UserType & 1
					fmt.Printf("用户类型值： %d\n", userType)
					if (userType == 1 || cooperationApplication.CooperationApplicationApplicant.UserType == 2) && cooperationApplication.CooperationApplicationStatus == 2 { // 申请人中的员工类型，审核中通过的
						applicants = append(applicants, cooperationApplication.CooperationApplicationApplicant)
					}
				}
			}
		}

		cooperationProjectDto := &dto.CooperationProjectsDto{}
		if err := cooperationProjectDto.LoadDto(cooperationProject, nil, newUndertakerTypesUncheckedAvailable, applicants); 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 cooperationProjectDto, nil
	}
}

// ListCooperationProject 返回共创项目列表
func (cooperationProjectService *CooperationProjectService) ListCooperationProject(listCooperationProjectQuery *query.ListCooperationProjectQuery) (interface{}, error) {
	if err := listCooperationProjectQuery.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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}
	if count, cooperationProjects, err := cooperationProjectRepository.Find(tool_funs.SimpleStructToMap(listCooperationProjectQuery)); 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{}{
			"list":  cooperationProjects,
			"total": count,
		}, nil
	}
}

// ReleaseCooperationProject 发布共创项目
func (cooperationProjectService *CooperationProjectService) ReleaseCooperationProject(releaseCooperationProjectCommand *command.ReleaseCooperationProjectCommand) (interface{}, error) {
	if err := releaseCooperationProjectCommand.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()
	}()
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil, nil
}

// RemoveCooperationProject 移除共创项目服务
func (cooperationProjectService *CooperationProjectService) RemoveCooperationProject(removeCooperationProjectCommand *command.RemoveCooperationProjectCommand) (interface{}, error) {
	if err := removeCooperationProjectCommand.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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}
	cooperationProject, err := cooperationProjectRepository.FindOne(map[string]interface{}{"cooperationProjectId": removeCooperationProjectCommand.CooperationProjectId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationProject == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(removeCooperationProjectCommand.CooperationProjectId, 10)))
	}
	if cooperationProjectRemoved, err := cooperationProjectRepository.Remove(cooperationProject); 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 cooperationProjectRemoved, nil
	}
}

// SearchCooperationProject 查询共创项目
func (cooperationProjectService *CooperationProjectService) SearchCooperationProject(searchCooperationProjectQuery *query.SearchCooperationProjectQuery) (interface{}, error) {
	if err := searchCooperationProjectQuery.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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}
	if count, cooperationProjects, err := cooperationProjectRepository.Find(tool_funs.SimpleStructToMap(searchCooperationProjectQuery)); 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{}{
			"total": count,
			"list":  cooperationProjects,
		}, nil
	}
}

// UpdateCooperationProject 更新共创项目服务
func (cooperationProjectService *CooperationProjectService) UpdateCooperationProject(updateCooperationProjectCommand *command.UpdateCooperationProjectCommand) (interface{}, error) {
	if err := updateCooperationProjectCommand.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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}

	// 共创申请仓储初始化
	var cooperationApplicationRepository domain.CooperationApplicationRepository
	if value, err := factory.CreateCooperationApplicationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationApplicationRepository = value
	}

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

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

	// 共创项目DAO初始化
	var cooperationProjectDao *dao.CooperationProjectDao
	if value, err := factory.CreateCooperationProjectDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		cooperationProjectDao = value
	}

	// 获取发起人
	var sponsor *domain.User
	// sponsorUid类型转换
	sponsorUid, err := strconv.ParseInt(updateCooperationProjectCommand.SponsorUid, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if data, err := userService.UserFrom(updateCooperationProjectCommand.CompanyId, updateCooperationProjectCommand.OrgId, sponsorUid); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取发起人失败")
	} else {
		sponsor = data
	}

	// 共创项目ID类型转换
	cooperationProjectId, err := strconv.ParseInt(updateCooperationProjectCommand.CooperationProjectId, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "共创项目编号类型错误")
	}

	// 查找共创项目
	cooperationProject, err := cooperationProjectRepository.FindOne(map[string]interface{}{
		"cooperationProjectId": cooperationProjectId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationProject == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", string(updateCooperationProjectCommand.CooperationProjectId)))
	}

	// 校验共创项目名称是否唯一
	if cooperationProject.CooperationProjectName != updateCooperationProjectCommand.CooperationProjectName {
		nameAvailable, _ := cooperationProjectDao.CheckProjectNameAvailable(map[string]interface{}{
			"companyId":              updateCooperationProjectCommand.CompanyId,
			"orgId":                  updateCooperationProjectCommand.OrgId,
			"cooperationProjectName": updateCooperationProjectCommand.CooperationProjectName,
		})
		if !nameAvailable {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, "共创项目名称重复")
		}
	}

	applicantTypes := make(map[int32]interface{})

	// 获取所有申请人
	if count, cooperationApplications, err := cooperationApplicationRepository.Find(map[string]interface{}{
		"cooperationProjectNumber":     cooperationProject.CooperationProjectNumber,
		"offsetLimit":                  false,
		"companyId":                    updateCooperationProjectCommand.CompanyId,
		"cooperationApplicationStatus": int32(2), // 共创申请审核状态，1待审核，2已同意，3已拒绝
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			for _, cooperationApplication := range cooperationApplications {
				applicantTypes[cooperationApplication.CooperationApplicationApplicant.UserType] = 1
			}
		}
	}

	var undertakerTypes []int32
	var k1, k2 int32
	if len(applicantTypes) > 0 {
		for k, _ := range applicantTypes {
			if k == 1 {
				k1 = k
			} else if k == 2 {
				k2 = k
			}
			undertakerTypes = append(undertakerTypes, k)
		}
	}
	if k1 != 0 && k2 != 0 {
		undertakerTypes = append(undertakerTypes, 3)
	}

	// 校验可以修改的承接人（申请人）类型
	for _, t := range undertakerTypes {
		if !utils.IsContain(updateCooperationProjectCommand.CooperationProjectUndertakerTypes, t) {
			switch t {
			case 1:
				return nil, application.ThrowError(application.BUSINESS_ERROR, "承接对象'员工'存在业务数据，不可取消勾选")
			case 2:
				return nil, application.ThrowError(application.BUSINESS_ERROR, "承接对象'共创用户'存在业务数据，不可取消勾选")
			case 3:
				return nil, application.ThrowError(application.BUSINESS_ERROR, "承接对象'公开'存在业务数据，不可取消勾选")
			}
		}
	}

	// 更新共创项目
	cooperationProject.Operator = operator
	cooperationProject.CooperationProjectSponsor = sponsor
	if err := cooperationProject.Update(tool_funs.SimpleStructToMap(updateCooperationProjectCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if cooperationProjectSaved, err := cooperationProjectRepository.Save(cooperationProject); 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 cooperationProjectSaved, nil
	}
}

// EndCooperationProject 结束共创项目
func (cooperationProjectService *CooperationProjectService) EndCooperationProject(updateCooperationProjectCommand *command.EndCooperationProjectCommand) (interface{}, error) {
	if err := updateCooperationProjectCommand.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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}
	cooperationProjectId, err := strconv.ParseInt(updateCooperationProjectCommand.CooperationProjectId, 10, 64)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	cooperationProject, err := cooperationProjectRepository.FindOne(map[string]interface{}{"cooperationProjectId": cooperationProjectId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationProject == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", updateCooperationProjectCommand.CooperationProjectId))
	}
	// 设置结束状态
	updateCooperationProjectCommand.Status = 2
	if err := cooperationProject.Update(tool_funs.SimpleStructToMap(updateCooperationProjectCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if cooperationProjectSaved, err := cooperationProjectRepository.Save(cooperationProject); 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 cooperationProjectSaved, nil
	}
}

// BatchEndCooperationProject 批量结束共创项目
func (cooperationProjectService *CooperationProjectService) BatchEndCooperationProject(batchEndCooperationProjectCommand *command.BatchEndCooperationProjectCommand) (interface{}, error) {
	if err := batchEndCooperationProjectCommand.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 cooperationProjectRepository domain.CooperationProjectRepository
	if value, err := factory.CreateCooperationProjectRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationProjectRepository = value
	}

	// 转换共创项目ID列表类型
	cooperationProjectIds, err := utils.SliceAtoi(batchEndCooperationProjectCommand.CooperationProjectIds)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if count, cooperationProjects, err := cooperationProjectRepository.Find(map[string]interface{}{
		"cooperationProjectIds": cooperationProjectIds,
		"offsetLimit":           false,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			for i, _ := range cooperationProjects {
				cooperationProjects[i].Status = 2
			}
			cooperationProjectsEnded, err := cooperationProjectRepository.UpdateMany(cooperationProjects)
			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 map[string]interface{}{
				"cooperationProjects": cooperationProjectsEnded,
			}, nil
		} else {
			return map[string]interface{}{}, nil
		}
	}
}

func NewCooperationProjectService(options map[string]interface{}) *CooperationProjectService {
	newCooperationProjectService := &CooperationProjectService{}
	return newCooperationProjectService
}